@prosopo/keyring 2.9.59 → 2.9.61

package/dist/cjs/pair/decode.cjs

@@ -1,32 +1,34 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const utilCrypto = require("@prosopo/util-crypto");
-const defaults = require("./defaults.cjs");
-const SEED_OFFSET = defaults.PAIR_HDR.length;
+const require_defaults = require("./defaults.cjs");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+//#region src/pair/decode.ts
+var SEED_OFFSET = require_defaults.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 = utilCrypto.jsonDecryptData(encrypted, passphrase, encType);
-  const header = decrypted.subarray(0, defaults.PAIR_HDR.length);
-  if (!util.u8aEq(header, defaults.PAIR_HDR)) {
-    throw new Error("Invalid encoding header found in body");
-  }
-  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + defaults.SEC_LENGTH);
-  let divOffset = SEED_OFFSET + defaults.SEC_LENGTH;
-  let divider = decrypted.subarray(divOffset, divOffset + defaults.PAIR_DIV.length);
-  if (!util.u8aEq(divider, defaults.PAIR_DIV)) {
-    divOffset = SEED_OFFSET + defaults.SEED_LENGTH;
-    secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
-    divider = decrypted.subarray(divOffset, divOffset + defaults.PAIR_DIV.length);
-    if (!util.u8aEq(divider, defaults.PAIR_DIV)) {
-      throw new Error("Invalid encoding divider found in body");
-    }
-  }
-  const pubOffset = divOffset + defaults.PAIR_DIV.length;
-  const publicKey = decrypted.subarray(pubOffset, pubOffset + defaults.PUB_LENGTH);
-  return {
-    publicKey,
-    secretKey
-  };
+	const encType = Array.isArray(_encType) || _encType === void 0 ? _encType : [_encType];
+	const decrypted = (0, _prosopo_util_crypto.jsonDecryptData)(encrypted, passphrase, encType);
+	const header = decrypted.subarray(0, require_defaults.PAIR_HDR.length);
+	if (!(0, _polkadot_util.u8aEq)(header, require_defaults.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 + require_defaults.PAIR_DIV.length);
+	if (!(0, _polkadot_util.u8aEq)(divider, require_defaults.PAIR_DIV)) {
+		divOffset = SEED_OFFSET + 32;
+		secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
+		divider = decrypted.subarray(divOffset, divOffset + require_defaults.PAIR_DIV.length);
+		if (!(0, _polkadot_util.u8aEq)(divider, require_defaults.PAIR_DIV)) throw new Error("Invalid encoding divider found in body");
+	}
+	const pubOffset = divOffset + require_defaults.PAIR_DIV.length;
+	return {
+		publicKey: decrypted.subarray(pubOffset, pubOffset + 32),
+		secretKey
+	};
 }
+//#endregion
 exports.decodePair = decodePair;

package/dist/cjs/pair/defaults.cjs

@@ -1,31 +1,31 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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;
+/** 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
 exports.PAIR_DIV = PAIR_DIV;
 exports.PAIR_HDR = PAIR_HDR;
-exports.PUB_LENGTH = PUB_LENGTH;
-exports.SALT_LENGTH = SALT_LENGTH;
-exports.SEC_LENGTH = SEC_LENGTH;
-exports.SEED_LENGTH = SEED_LENGTH;

package/dist/cjs/pair/encode.cjs

@@ -1,18 +1,17 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const utilCrypto = require("@prosopo/util-crypto");
-const defaults = require("./defaults.cjs");
+const require_defaults = require("./defaults.cjs");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+//#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 = util.u8aConcat(defaults.PAIR_HDR, secretKey, defaults.PAIR_DIV, publicKey);
-  if (!passphrase) {
-    return encoded;
-  }
-  const { params, password, salt } = utilCrypto.scryptEncode(passphrase);
-  const { encrypted, nonce } = utilCrypto.naclEncrypt(encoded, password.subarray(0, 32));
-  return util.u8aConcat(utilCrypto.scryptToU8a(salt, params), nonce, encrypted);
+	if (!secretKey) throw new Error("Expected a valid secretKey to be passed to encode");
+	const encoded = (0, _polkadot_util.u8aConcat)(require_defaults.PAIR_HDR, secretKey, require_defaults.PAIR_DIV, publicKey);
+	if (!passphrase) return encoded;
+	const { params, password, salt } = (0, _prosopo_util_crypto.scryptEncode)(passphrase);
+	const { encrypted, nonce } = (0, _prosopo_util_crypto.naclEncrypt)(encoded, password.subarray(0, 32));
+	return (0, _polkadot_util.u8aConcat)((0, _prosopo_util_crypto.scryptToU8a)(salt, params), nonce, encrypted);
 }
+//#endregion
 exports.encodePair = encodePair;

package/dist/cjs/pair/index.cjs

@@ -1,177 +1,201 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const utilCrypto = require("@prosopo/util-crypto");
-const decode = require("./decode.cjs");
-const encode = require("./encode.cjs");
-const toJson = require("./toJson.cjs");
-const SIG_TYPE_NONE = new Uint8Array([]);
-const TYPE_FROM_SEED = {
-  sr25519: utilCrypto.sr25519FromSeed,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+const require_decode = require("./decode.cjs");
+const require_encode = require("./encode.cjs");
+const require_toJson = require("./toJson.cjs");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+//#region src/pair/index.ts
+var SIG_TYPE_NONE = new Uint8Array([]);
+var TYPE_FROM_SEED = {
+	sr25519: _prosopo_util_crypto.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: utilCrypto.sr25519Sign,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+var TYPE_SIGNATURE = {
+	sr25519: _prosopo_util_crypto.sr25519Sign,
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
-const TYPE_JWT_ISSUE = {
-  sr25519: utilCrypto.sr25519jwtIssue,
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+var TYPE_JWT_ISSUE = {
+	sr25519: _prosopo_util_crypto.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 || util.u8aEmpty(secretKey);
-}
-function vrfHash(proof, context, extra) {
-  return utilCrypto.blake2AsU8a(util.u8aConcat(context || "", extra || "", proof));
+	return !secretKey || (0, _polkadot_util.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 = decode.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 = encode.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 } = utilCrypto.keyExtractPath(suri);
-      const derived = utilCrypto.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 utilCrypto.jwtVerify(jwt, publicKey);
-    },
-    lock: () => {
-      secretKey = new Uint8Array([]);
-    },
-    setMeta: (additional) => {
-      meta = util.objectSpread({}, meta, additional);
-    },
-    sign: (message, options = {}) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot sign with a locked key pair");
-      }
-      return util.u8aConcat(
-        options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE,
-        TYPE_SIGNATURE[type](util.u8aToU8a(message), { publicKey, secretKey })
-      );
-    },
-    toJson: (passphrase) => {
-      const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? util.u8aToHex(publicKey) : util.u8aToHex(utilCrypto.secp256k1Compress(publicKey)) : encodeAddress();
-      return toJson.pairToJson(
-        type,
-        { address, meta },
-        recode(passphrase),
-        !!passphrase
-      );
-    },
-    unlock: (passphrase) => {
-      decodePkcs8(passphrase);
-    },
-    verify: (message, signature, signerPublic) => {
-      return utilCrypto.signatureVerify(
-        message,
-        signature,
-        TYPE_ADDRESS[type](util.u8aToU8a(signerPublic))
-      ).isValid;
-    },
-    vrfSign: (message, context, extra) => {
-      if (isLocked(secretKey)) {
-        throw new Error("Cannot sign with a locked key pair");
-      }
-      return utilCrypto.sr25519VrfSign(message, { secretKey }, context, extra);
-    },
-    vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
-      return utilCrypto.sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
-    }
-  };
+	const decodePkcs8 = (passphrase, userEncoded) => {
+		const decoded = require_decode.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 = require_encode.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 } = (0, _prosopo_util_crypto.keyExtractPath)(suri);
+			const derived = (0, _prosopo_util_crypto.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 (0, _prosopo_util_crypto.jwtVerify)(jwt, publicKey);
+		},
+		lock: () => {
+			secretKey = new Uint8Array([]);
+		},
+		setMeta: (additional) => {
+			meta = (0, _polkadot_util.objectSpread)({}, meta, additional);
+		},
+		sign: (message, options = {}) => {
+			if (isLocked(secretKey)) throw new Error("Cannot sign with a locked key pair");
+			return (0, _polkadot_util.u8aConcat)(options.withType ? TYPE_PREFIX[type] : SIG_TYPE_NONE, TYPE_SIGNATURE[type]((0, _polkadot_util.u8aToU8a)(message), {
+				publicKey,
+				secretKey
+			}));
+		},
+		toJson: (passphrase) => {
+			const address = ["ecdsa", "ethereum"].includes(type) ? publicKey.length === 20 ? (0, _polkadot_util.u8aToHex)(publicKey) : (0, _polkadot_util.u8aToHex)((0, _prosopo_util_crypto.secp256k1Compress)(publicKey)) : encodeAddress();
+			return require_toJson.pairToJson(type, {
+				address,
+				meta
+			}, recode(passphrase), !!passphrase);
+		},
+		unlock: (passphrase) => {
+			decodePkcs8(passphrase);
+		},
+		verify: (message, signature, signerPublic) => {
+			return (0, _prosopo_util_crypto.signatureVerify)(message, signature, TYPE_ADDRESS[type]((0, _polkadot_util.u8aToU8a)(signerPublic))).isValid;
+		},
+		vrfSign: (message, context, extra) => {
+			if (isLocked(secretKey)) throw new Error("Cannot sign with a locked key pair");
+			return (0, _prosopo_util_crypto.sr25519VrfSign)(message, { secretKey }, context, extra);
+		},
+		vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
+			return (0, _prosopo_util_crypto.sr25519VrfVerify)(message, vrfResult, publicKey, context, extra);
+		}
+	};
 }
+//#endregion
 exports.createPair = createPair;

package/dist/cjs/pair/toJson.cjs

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const utilCrypto = require("@prosopo/util-crypto");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+//#region src/pair/toJson.ts
 function pairToJson(type, { address, meta }, encoded, isEncrypted) {
-  return util.objectSpread(
-    utilCrypto.jsonEncryptFormat(encoded, ["pkcs8", type], isEncrypted),
-    {
-      address,
-      meta
-    }
-  );
+	return (0, _polkadot_util.objectSpread)((0, _prosopo_util_crypto.jsonEncryptFormat)(encoded, ["pkcs8", type], isEncrypted), {
+		address,
+		meta
+	});
 }
+//#endregion
 exports.pairToJson = pairToJson;

package/dist/index.js

@@ -1,19 +1,8 @@
-import "./accounts/index.js";
-import "./keyring/index.js";
+import "./_virtual/_rolldown/runtime.js";
 import { createPair } from "./pair/index.js";
+import { Pairs } from "./keyring/pairs.js";
+import { DEV_PHRASE, Keyring } from "./keyring/keyring.js";
 import { generateMiniSecret, generateMnemonic } from "./accounts/mnemonic.js";
 import { getPair } from "./accounts/getPair.js";
 import { getDefaultProviders, getDefaultSiteKeys } from "./accounts/testAccounts.js";
-import { DEV_PHRASE, Keyring } from "./keyring/keyring.js";
-import { Pairs } from "./keyring/pairs.js";
-export {
-  DEV_PHRASE,
-  Keyring,
-  Pairs,
-  createPair,
-  generateMiniSecret,
-  generateMnemonic,
-  getDefaultProviders,
-  getDefaultSiteKeys,
-  getPair
-};
+export { DEV_PHRASE, Keyring, Pairs, createPair, generateMiniSecret, generateMnemonic, getDefaultProviders, getDefaultSiteKeys, getPair };

package/dist/keyring/index.js

@@ -1,7 +1,3 @@
-import { DEV_PHRASE, Keyring } from "./keyring.js";
 import { Pairs } from "./pairs.js";
-export {
-  DEV_PHRASE,
-  Keyring,
-  Pairs
-};
+import { DEV_PHRASE, Keyring } from "./keyring.js";
+export { DEV_PHRASE, Keyring, Pairs };