@prosopo/keyring 2.9.59 → 2.9.61

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/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/toJson.js

@@ -1,14 +1,11 @@
-import { objectSpread } from "@polkadot/util";
 import { jsonEncryptFormat } from "@prosopo/util-crypto";
+import { objectSpread } from "@polkadot/util";
+//#region src/pair/toJson.ts
 function pairToJson(type, { address, meta }, encoded, isEncrypted) {
-  return objectSpread(
-    jsonEncryptFormat(encoded, ["pkcs8", type], isEncrypted),
-    {
-      address,
-      meta
-    }
-  );
+	return objectSpread(jsonEncryptFormat(encoded, ["pkcs8", type], isEncrypted), {
+		address,
+		meta
+	});
 }
-export {
-  pairToJson
-};
+//#endregion
+export { pairToJson };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/keyring",
-	"version": "2.9.59",
+	"version": "2.9.61",
 	"description": "Keypair generator for Prosopo",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -39,24 +39,24 @@
 	"dependencies": {
 		"@polkadot/util": "13.5.7",
 		"@polkadot/util-crypto": "13.5.7",
-		"@prosopo/common": "3.1.47",
-		"@prosopo/types": "4.9.11",
-		"@prosopo/util": "3.3.4",
+		"@prosopo/common": "3.1.48",
+		"@prosopo/types": "4.10.0",
+		"@prosopo/util": "3.3.5",
 		"@prosopo/util-crypto": "13.5.30",
 		"dotenv": "16.4.5"
 	},
 	"devDependencies": {
-		"@prosopo/config": "3.3.4",
+		"@prosopo/config": "3.3.5",
 		"@types/node": "22.10.2",
-		"@vitest/coverage-v8": "3.2.4",
+		"@vitest/coverage-v8": "4.1.10",
 		"concurrently": "9.0.1",
 		"del-cli": "6.0.0",
 		"npm-run-all": "4.1.5",
 		"tslib": "2.7.0",
 		"tsx": "4.20.3",
 		"typescript": "5.6.2",
-		"vite": "6.4.1",
-		"vitest": "3.2.4"
+		"vite": "8.1.5",
+		"vitest": "4.1.10"
 	},
 	"sideEffects": false
 }