@prosopo/keyring 2.9.60 → 2.9.62

package/dist/pair/decode.js

@@ -1,32 +1,32 @@
-import { u8aEq } from "@polkadot/util";
+import { PAIR_DIV, PAIR_HDR } from "./defaults.js";
 import { jsonDecryptData } from "@prosopo/util-crypto";
-import { PAIR_HDR, SEC_LENGTH, PAIR_DIV, SEED_LENGTH, PUB_LENGTH } from "./defaults.js";
-const SEED_OFFSET = PAIR_HDR.length;
+import { u8aEq } from "@polkadot/util";
+//#region src/pair/decode.ts
+var SEED_OFFSET = PAIR_HDR.length;
+/**
+* Decode a pair, taking into account the generation-specific formats and headers
+*
+* For divisor/headers, don't rely on the magic being static. These will
+* change between generations, aka with the long-awaited 4th generation
+* of the format. The external decode interface is the only way to use and decode these.
+**/
 function decodePair(passphrase, encrypted, _encType) {
-  const encType = Array.isArray(_encType) || _encType === void 0 ? _encType : [_encType];
-  const decrypted = jsonDecryptData(encrypted, passphrase, encType);
-  const header = decrypted.subarray(0, PAIR_HDR.length);
-  if (!u8aEq(header, PAIR_HDR)) {
-    throw new Error("Invalid encoding header found in body");
-  }
-  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
-  let divOffset = SEED_OFFSET + SEC_LENGTH;
-  let divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-  if (!u8aEq(divider, PAIR_DIV)) {
-    divOffset = SEED_OFFSET + SEED_LENGTH;
-    secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
-    divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
-    if (!u8aEq(divider, PAIR_DIV)) {
-      throw new Error("Invalid encoding divider found in body");
-    }
-  }
-  const pubOffset = divOffset + PAIR_DIV.length;
-  const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
-  return {
-    publicKey,
-    secretKey
-  };
+	const decrypted = jsonDecryptData(encrypted, passphrase, Array.isArray(_encType) || _encType === void 0 ? _encType : [_encType]);
+	if (!u8aEq(decrypted.subarray(0, PAIR_HDR.length), PAIR_HDR)) throw new Error("Invalid encoding header found in body");
+	let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + 64);
+	let divOffset = SEED_OFFSET + 64;
+	let divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
+	if (!u8aEq(divider, PAIR_DIV)) {
+		divOffset = SEED_OFFSET + 32;
+		secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
+		divider = decrypted.subarray(divOffset, divOffset + PAIR_DIV.length);
+		if (!u8aEq(divider, PAIR_DIV)) throw new Error("Invalid encoding divider found in body");
+	}
+	const pubOffset = divOffset + PAIR_DIV.length;
+	return {
+		publicKey: decrypted.subarray(pubOffset, pubOffset + 32),
+		secretKey
+	};
 }
-export {
-  decodePair
-};
+//#endregion
+export { decodePair };

package/dist/pair/decode.spec.js

@@ -5,7 +5,7 @@ describe("decode", () => {
     it("fails when no data provided", () => {
         expect(() => keyring.alice.decodePkcs8()).toThrow(/(No encrypted data available|Password required)/);
     });
-    it("returns correct publicKey from encoded", () => {
+    it("returns correct publicKey from encoded", { timeout: 60000 }, () => {
         const PASS = "testing";
         expect(() => keyring.alice.decodePkcs8(PASS, keyring.alice.encodePkcs8(PASS))).not.toThrow();
     });

package/dist/pair/decode.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"decode.spec.js","sourceRoot":"","sources":["../../src/pair/decode.spec.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,OAAO,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,CAAC;AAE5D,QAAQ,CAAC,QAAQ,EAAE,GAAS,EAAE;IAC7B,EAAE,CAAC,6BAA6B,EAAE,GAAS,EAAE;QAC5C,MAAM,CAAC,GAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CACtD,iDAAiD,CACjD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAS,EAAE;QACvD,MAAM,IAAI,GAAG,SAAS,CAAC;QAEvB,MAAM,CAAC,GAAS,EAAE,CACjB,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAChE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC"}
+{"version":3,"file":"decode.spec.js","sourceRoot":"","sources":["../../src/pair/decode.spec.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,OAAO,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,CAAC;AAE5D,QAAQ,CAAC,QAAQ,EAAE,GAAS,EAAE;IAC7B,EAAE,CAAC,6BAA6B,EAAE,GAAS,EAAE;QAC5C,MAAM,CAAC,GAAS,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CACtD,iDAAiD,CACjD,CAAC;IACH,CAAC,CAAC,CAAC;IAIH,EAAE,CAAC,wCAAwC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,GAAS,EAAE;QAC3E,MAAM,IAAI,GAAG,SAAS,CAAC;QAEvB,MAAM,CAAC,GAAS,EAAE,CACjB,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAChE,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/pair/defaults.js

@@ -1,31 +1,30 @@
-const PAIR_DIV = new Uint8Array([161, 35, 3, 33, 0]);
-const PAIR_HDR = new Uint8Array([
-  48,
-  83,
-  2,
-  1,
-  1,
-  48,
-  5,
-  6,
-  3,
-  43,
-  101,
-  112,
-  4,
-  34,
-  4,
-  32
+//#region src/pair/defaults.ts
+/** public/secret section divider (generation 1-3, will change in 4, don't rely on value) */
+var PAIR_DIV = new Uint8Array([
+	161,
+	35,
+	3,
+	33,
+	0
 ]);
-const PUB_LENGTH = 32;
-const SALT_LENGTH = 32;
-const SEC_LENGTH = 64;
-const SEED_LENGTH = 32;
-export {
-  PAIR_DIV,
-  PAIR_HDR,
-  PUB_LENGTH,
-  SALT_LENGTH,
-  SEC_LENGTH,
-  SEED_LENGTH
-};
+/** public/secret start block (generation 1-3, will change in 4, don't rely on value) */
+var PAIR_HDR = new Uint8Array([
+	48,
+	83,
+	2,
+	1,
+	1,
+	48,
+	5,
+	6,
+	3,
+	43,
+	101,
+	112,
+	4,
+	34,
+	4,
+	32
+]);
+//#endregion
+export { PAIR_DIV, PAIR_HDR };

package/dist/pair/encode.js

@@ -1,18 +1,17 @@
+import { PAIR_DIV, PAIR_HDR } from "./defaults.js";
+import { naclEncrypt, scryptEncode, scryptToU8a } from "@prosopo/util-crypto";
 import { u8aConcat } from "@polkadot/util";
-import { scryptEncode, naclEncrypt, scryptToU8a } from "@prosopo/util-crypto";
-import { PAIR_HDR, PAIR_DIV } from "./defaults.js";
+//#region src/pair/encode.ts
+/**
+* Encode a pair with the latest generation format (generation 3)
+**/
 function encodePair({ publicKey, secretKey }, passphrase) {
-  if (!secretKey) {
-    throw new Error("Expected a valid secretKey to be passed to encode");
-  }
-  const encoded = u8aConcat(PAIR_HDR, secretKey, PAIR_DIV, publicKey);
-  if (!passphrase) {
-    return encoded;
-  }
-  const { params, password, salt } = scryptEncode(passphrase);
-  const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-  return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+	if (!secretKey) throw new Error("Expected a valid secretKey to be passed to encode");
+	const encoded = u8aConcat(PAIR_HDR, secretKey, PAIR_DIV, publicKey);
+	if (!passphrase) return encoded;
+	const { params, password, salt } = scryptEncode(passphrase);
+	const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+	return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
 }
-export {
-  encodePair
-};
+//#endregion
+export { encodePair };

package/dist/pair/encode.spec.js

@@ -9,7 +9,7 @@ describe("encode", () => {
     it("returns PKCS8 when no passphrase supplied", () => {
         expect(keyring.alice.encodePkcs8()).toHaveLength(DECODED_LENGTH);
     });
-    it("returns encoded PKCS8 when passphrase supplied", () => {
+    it("returns encoded PKCS8 when passphrase supplied", { timeout: 60000 }, () => {
         expect(keyring.alice.encodePkcs8("testing")).toHaveLength(ENCODED_LENGTH);
     });
 });

package/dist/pair/encode.spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"encode.spec.js","sourceRoot":"","sources":["../../src/pair/encode.spec.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3E,MAAM,cAAc,GACnB,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;AAC7D,MAAM,cAAc,GAAG,EAAE,GAAG,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;AAE1E,MAAM,OAAO,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,CAAC;AAE5D,QAAQ,CAAC,QAAQ,EAAE,GAAS,EAAE;IAC7B,EAAE,CAAC,2CAA2C,EAAE,GAAS,EAAE;QAC1D,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,GAAS,EAAE;QAC/D,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;AACJ,CAAC,CAAC,CAAC"}
+{"version":3,"file":"encode.spec.js","sourceRoot":"","sources":["../../src/pair/encode.spec.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3E,MAAM,cAAc,GACnB,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;AAC7D,MAAM,cAAc,GAAG,EAAE,GAAG,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;AAE1E,MAAM,OAAO,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,CAAC;AAE5D,QAAQ,CAAC,QAAQ,EAAE,GAAS,EAAE;IAC7B,EAAE,CAAC,2CAA2C,EAAE,GAAS,EAAE;QAC1D,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAIH,EAAE,CACD,gDAAgD,EAChD,EAAE,OAAO,EAAE,KAAK,EAAE,EAClB,GAAS,EAAE;QACV,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IAC3E,CAAC,CACD,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/pair/index.js

@@ -1,177 +1,200 @@
-import { u8aEmpty, u8aConcat, u8aToU8a, u8aToHex, objectSpread } from "@polkadot/util";
-import { sr25519FromSeed, sr25519Sign, sr25519jwtIssue, blake2AsU8a, sr25519VrfVerify, sr25519VrfSign, signatureVerify, secp256k1Compress, jwtVerify, keyExtractPath, keyFromPath } from "@prosopo/util-crypto";
 import { decodePair } from "./decode.js";
 import { encodePair } from "./encode.js";
 import { pairToJson } from "./toJson.js";
-const SIG_TYPE_NONE = new Uint8Array([]);
-const TYPE_FROM_SEED = {
-  sr25519: sr25519FromSeed,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+import { jwtVerify, keyExtractPath, keyFromPath, secp256k1Compress, signatureVerify, sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify, sr25519jwtIssue } from "@prosopo/util-crypto";
+import { objectSpread, u8aConcat, u8aEmpty, u8aToHex, u8aToU8a } from "@polkadot/util";
+//#region src/pair/index.ts
+var SIG_TYPE_NONE = new Uint8Array([]);
+var TYPE_FROM_SEED = {
+	sr25519: sr25519FromSeed,
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
-const TYPE_PREFIX = {
-  ecdsa: new Uint8Array([2]),
-  ed25519: new Uint8Array([0]),
-  ethereum: new Uint8Array([2]),
-  sr25519: new Uint8Array([1])
+var TYPE_PREFIX = {
+	ecdsa: new Uint8Array([2]),
+	ed25519: new Uint8Array([0]),
+	ethereum: new Uint8Array([2]),
+	sr25519: new Uint8Array([1])
 };
-const TYPE_SIGNATURE = {
-  sr25519: sr25519Sign,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+var TYPE_SIGNATURE = {
+	sr25519: sr25519Sign,
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
-const TYPE_JWT_ISSUE = {
-  sr25519: sr25519jwtIssue,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+var TYPE_JWT_ISSUE = {
+	sr25519: sr25519jwtIssue,
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
-const TYPE_ADDRESS = {
-  sr25519: (p) => p,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+var TYPE_ADDRESS = {
+	sr25519: (p) => p,
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
 function isLocked(secretKey) {
-  return !secretKey || u8aEmpty(secretKey);
-}
-function vrfHash(proof, context, extra) {
-  return blake2AsU8a(u8aConcat(context || "", extra || "", proof));
+	return !secretKey || u8aEmpty(secretKey);
 }
+/**
+* @name createPair
+* @summary Creates a keyring pair object
+* @description Creates a keyring pair object with provided account public key, metadata, and encoded arguments.
+* The keyring pair stores the account state including the encoded address and associated metadata.
+*
+* It has properties whose values are functions that may be called to perform account actions:
+*
+* - `address` function retrieves the address associated with the account.
+* - `decodedPkcs8` function is called with the account passphrase and account encoded public key.
+* It decodes the encoded public key using the passphrase provided to obtain the decoded account public key
+* and associated secret key that are then available in memory, and changes the account address stored in the
+* state of the pair to correspond to the address of the decoded public key.
+* - `encodePkcs8` function when provided with the correct passphrase associated with the account pair
+* and when the secret key is in memory (when the account pair is not locked) it returns an encoded
+* public key of the account.
+* - `meta` is the metadata that is stored in the state of the pair, either when it was originally
+* created or set via `setMeta`.
+* - `publicKey` returns the public key stored in memory for the pair.
+* - `sign` may be used to return a signature by signing a provided message with the secret
+* key (if it is in memory) using Nacl.
+* - `toJson` calls another `toJson` function and provides the state of the pair,
+* it generates arguments to be passed to the other `toJson` function including an encoded public key of the account
+* that it generates using the secret key from memory (if it has been made available in memory)
+* and the optionally provided passphrase argument. It passes a third boolean argument to `toJson`
+* indicating whether the public key has been encoded or not (if a passphrase argument was provided then it is encoded).
+* The `toJson` function that it calls returns a JSON object with properties including the `address`
+* and `meta` that are assigned with the values stored in the corresponding state variables of the account pair,
+* an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
+* property that indicates whether the public key value of the `encoded` property is encoded or not.
+*/
 function createPair({ toSS58, type }, { publicKey, secretKey }, meta = {}, encoded = null, encTypes) {
-  const decodePkcs8 = (passphrase, userEncoded) => {
-    const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
-    if (decoded.secretKey.length === 64) {
-      publicKey = decoded.publicKey;
-      secretKey = decoded.secretKey;
-    } else {
-      const pair = TYPE_FROM_SEED[type](decoded.secretKey);
-      publicKey = pair.publicKey;
-      secretKey = pair.secretKey;
-    }
-  };
-  const recode = (passphrase) => {
-    isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
-    encoded = encodePair({ publicKey, secretKey }, passphrase);
-    encTypes = void 0;
-    return encoded;
-  };
-  const encodeAddress = () => {
-    const raw = TYPE_ADDRESS[type](publicKey);
-    return toSS58(raw);
-  };
-  return {
-    get address() {
-      return encodeAddress();
-    },
-    get addressRaw() {
-      return TYPE_ADDRESS[type](publicKey);
-    },
-    get isLocked() {
-      return isLocked(secretKey);
-    },
-    get meta() {
-      return meta;
-    },
-    get publicKey() {
-      return publicKey;
-    },
-    get type() {
-      return type;
-    },
-    // eslint-disable-next-line sort-keys
-    decodePkcs8,
-    derive: (suri, meta2) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot derive on a locked keypair");
-      }
-      const { path } = keyExtractPath(suri);
-      const derived = keyFromPath({ publicKey, secretKey }, path, type);
-      return createPair({ toSS58, type }, derived, meta2, null);
-    },
-    encodePkcs8: (passphrase) => {
-      return recode(passphrase);
-    },
-    jwtIssue: (options, message) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot sign with a locked key pair");
-      }
-      return TYPE_JWT_ISSUE[type]({ publicKey, secretKey }, options, message);
-    },
-    jwtVerify: (jwt) => {
-      return jwtVerify(jwt, publicKey);
-    },
-    lock: () => {
-      secretKey = new Uint8Array([]);
-    },
-    setMeta: (additional) => {
-      meta = objectSpread({}, meta, additional);
-    },
-    sign: (message, options = {}) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot sign with a locked key pair");
-      }
-      return u8aConcat(
-        options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE,
-        TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey })
-      );
-    },
-    toJson: (passphrase) => {
-      const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? u8aToHex(publicKey) : u8aToHex(secp256k1Compress(publicKey)) : encodeAddress();
-      return pairToJson(
-        type,
-        { address, meta },
-        recode(passphrase),
-        !!passphrase
-      );
-    },
-    unlock: (passphrase) => {
-      decodePkcs8(passphrase);
-    },
-    verify: (message, signature, signerPublic) => {
-      return signatureVerify(
-        message,
-        signature,
-        TYPE_ADDRESS[type](u8aToU8a(signerPublic))
-      ).isValid;
-    },
-    vrfSign: (message, context, extra) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot sign with a locked key pair");
-      }
-      return sr25519VrfSign(message, { secretKey }, context, extra);
-    },
-    vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
-      return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
-    }
-  };
+	const decodePkcs8 = (passphrase, userEncoded) => {
+		const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
+		if (decoded.secretKey.length === 64) {
+			publicKey = decoded.publicKey;
+			secretKey = decoded.secretKey;
+		} else {
+			const pair = TYPE_FROM_SEED[type](decoded.secretKey);
+			publicKey = pair.publicKey;
+			secretKey = pair.secretKey;
+		}
+	};
+	const recode = (passphrase) => {
+		isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
+		encoded = encodePair({
+			publicKey,
+			secretKey
+		}, passphrase);
+		encTypes = void 0;
+		return encoded;
+	};
+	const encodeAddress = () => {
+		return toSS58(TYPE_ADDRESS[type](publicKey));
+	};
+	return {
+		get address() {
+			return encodeAddress();
+		},
+		get addressRaw() {
+			return TYPE_ADDRESS[type](publicKey);
+		},
+		get isLocked() {
+			return isLocked(secretKey);
+		},
+		get meta() {
+			return meta;
+		},
+		get publicKey() {
+			return publicKey;
+		},
+		get type() {
+			return type;
+		},
+		decodePkcs8,
+		derive: (suri, meta) => {
+			if (isLocked(secretKey)) throw new Error("Cannot derive on a locked keypair");
+			const { path } = keyExtractPath(suri);
+			const derived = keyFromPath({
+				publicKey,
+				secretKey
+			}, path, type);
+			return createPair({
+				toSS58,
+				type
+			}, derived, meta, null);
+		},
+		encodePkcs8: (passphrase) => {
+			return recode(passphrase);
+		},
+		jwtIssue: (options, message) => {
+			if (isLocked(secretKey)) throw new Error("Cannot sign with a locked key pair");
+			return TYPE_JWT_ISSUE[type]({
+				publicKey,
+				secretKey
+			}, options, message);
+		},
+		jwtVerify: (jwt) => {
+			return jwtVerify(jwt, publicKey);
+		},
+		lock: () => {
+			secretKey = new Uint8Array([]);
+		},
+		setMeta: (additional) => {
+			meta = objectSpread({}, meta, additional);
+		},
+		sign: (message, options = {}) => {
+			if (isLocked(secretKey)) throw new Error("Cannot sign with a locked key pair");
+			return u8aConcat(options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE, TYPE_SIGNATURE[type](u8aToU8a(message), {
+				publicKey,
+				secretKey
+			}));
+		},
+		toJson: (passphrase) => {
+			return pairToJson(type, {
+				address: ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? u8aToHex(publicKey) : u8aToHex(secp256k1Compress(publicKey)) : encodeAddress(),
+				meta
+			}, recode(passphrase), !!passphrase);
+		},
+		unlock: (passphrase) => {
+			decodePkcs8(passphrase);
+		},
+		verify: (message, signature, signerPublic) => {
+			return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
+		},
+		vrfSign: (message, context, extra) => {
+			if (isLocked(secretKey)) throw new Error("Cannot sign with a locked key pair");
+			return sr25519VrfSign(message, { secretKey }, context, extra);
+		},
+		vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
+			return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
+		}
+	};
 }
-export {
-  createPair
-};
+//#endregion
+export { createPair };

package/dist/pair/nobody.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nobody.test.d.ts.map

package/dist/pair/nobody.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nobody.test.d.ts","sourceRoot":"","sources":["../../src/pair/nobody.test.ts"],"names":[],"mappings":""}

package/dist/pair/nobody.test.js

@@ -0,0 +1,77 @@
+import { encodeAddress } from "@prosopo/util-crypto";
+import { describe, expect, it } from "vitest";
+import { PAIR_DIV, PAIR_HDR, PUB_LENGTH, SALT_LENGTH, SEC_LENGTH, SEED_LENGTH, } from "./defaults.js";
+import { nobody } from "./nobody.js";
+describe("nobody", () => {
+    it("is the all-zero public key, encoded as the well-known address", () => {
+        const pair = nobody();
+        expect(pair.publicKey).toEqual(new Uint8Array(32));
+        expect(pair.address).toBe("5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM");
+        expect(pair.address).toBe(encodeAddress(pair.publicKey, 42));
+    });
+    it("is permanently locked", () => {
+        const pair = nobody();
+        expect(pair.isLocked).toBe(true);
+        pair.unlock("anything");
+        expect(pair.isLocked).toBe(true);
+        pair.lock();
+        expect(pair.isLocked).toBe(true);
+    });
+    it("never verifies a signature, whatever it is given", () => {
+        const pair = nobody();
+        expect(pair.verify(new Uint8Array(1), new Uint8Array(64), pair.publicKey)).toBe(false);
+        expect(pair.verify(new Uint8Array(0), pair.sign(new Uint8Array(1)), pair.publicKey)).toBe(false);
+        expect(pair.vrfVerify(new Uint8Array(1), new Uint8Array(96), pair.publicKey)).toBe(false);
+    });
+    it("never reports a JWT as valid", () => {
+        const result = nobody().jwtVerify(nobody().jwtIssue());
+        expect(result.isValid).toBe(false);
+        expect(result.error).toBe("JWT verification failed");
+        expect(result.publicKey).toEqual(new Uint8Array(32));
+    });
+    it("returns correctly sized but empty signatures", () => {
+        const pair = nobody();
+        expect(pair.sign(new Uint8Array(1))).toEqual(new Uint8Array(64));
+        expect(pair.vrfSign(new Uint8Array(1))).toEqual(new Uint8Array(96));
+        expect(pair.encodePkcs8()).toEqual(new Uint8Array(0));
+    });
+    it("derives to itself, so no chain of derivation can escape it", () => {
+        const pair = nobody();
+        expect(pair.derive("//anything")).toBe(pair);
+        expect(pair.derive("//a").derive("//b")).toBe(pair);
+    });
+    it("ignores attempts to change its meta", () => {
+        const pair = nobody();
+        pair.setMeta({ name: "somebody" });
+        expect(pair.meta.name).toBe("nobody");
+        expect(pair.meta.isTesting).toBe(true);
+    });
+    it("serialises to an unencrypted v0 json blob", () => {
+        const json = nobody().toJson();
+        expect(json.address).toBe(nobody().address);
+        expect(json.encoded).toBe("");
+        expect(json.encoding.version).toBe("0");
+        expect(json.encoding.type).toBe("none");
+    });
+    it("returns the same shared instance each call", () => {
+        expect(nobody()).toBe(nobody());
+    });
+    it("accepts pkcs8 decoding without throwing", () => {
+        expect(() => nobody().decodePkcs8("pass", new Uint8Array(1))).not.toThrow();
+    });
+});
+describe("pair defaults", () => {
+    it("declares the sr25519 key and seed lengths", () => {
+        expect(PUB_LENGTH).toBe(32);
+        expect(SEED_LENGTH).toBe(32);
+        expect(SALT_LENGTH).toBe(32);
+        expect(SEC_LENGTH).toBe(64);
+    });
+    it("declares the pkcs8 header and divider used by the encoder", () => {
+        expect(Array.from(PAIR_DIV)).toEqual([161, 35, 3, 33, 0]);
+        expect(Array.from(PAIR_HDR)).toEqual([
+            48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32,
+        ]);
+    });
+});
+//# sourceMappingURL=nobody.test.js.map