@prosopo/keyring 2.9.59 → 2.9.61

package/dist/cjs/index.cjs

@@ -1,19 +1,16 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./accounts/index.cjs");
-require("./keyring/index.cjs");
-const index = require("./pair/index.cjs");
-const mnemonic = require("./accounts/mnemonic.cjs");
-const getPair = require("./accounts/getPair.cjs");
-const testAccounts = require("./accounts/testAccounts.cjs");
-const keyring = require("./keyring/keyring.cjs");
-const pairs = require("./keyring/pairs.cjs");
-exports.createPair = index.createPair;
-exports.generateMiniSecret = mnemonic.generateMiniSecret;
-exports.generateMnemonic = mnemonic.generateMnemonic;
-exports.getPair = getPair.getPair;
-exports.getDefaultProviders = testAccounts.getDefaultProviders;
-exports.getDefaultSiteKeys = testAccounts.getDefaultSiteKeys;
-exports.DEV_PHRASE = keyring.DEV_PHRASE;
-exports.Keyring = keyring.Keyring;
-exports.Pairs = pairs.Pairs;
+const require_index = require("./pair/index.cjs");
+const require_pairs = require("./keyring/pairs.cjs");
+const require_keyring = require("./keyring/keyring.cjs");
+const require_mnemonic = require("./accounts/mnemonic.cjs");
+const require_getPair = require("./accounts/getPair.cjs");
+const require_testAccounts = require("./accounts/testAccounts.cjs");
+exports.DEV_PHRASE = require_keyring.DEV_PHRASE;
+exports.Keyring = require_keyring.Keyring;
+exports.Pairs = require_pairs.Pairs;
+exports.createPair = require_index.createPair;
+exports.generateMiniSecret = require_mnemonic.generateMiniSecret;
+exports.generateMnemonic = require_mnemonic.generateMnemonic;
+exports.getDefaultProviders = require_testAccounts.getDefaultProviders;
+exports.getDefaultSiteKeys = require_testAccounts.getDefaultSiteKeys;
+exports.getPair = require_getPair.getPair;

package/dist/cjs/keyring/index.cjs

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const keyring = require("./keyring.cjs");
-const pairs = require("./pairs.cjs");
-exports.DEV_PHRASE = keyring.DEV_PHRASE;
-exports.Keyring = keyring.Keyring;
-exports.Pairs = pairs.Pairs;
+const require_pairs = require("./pairs.cjs");
+const require_keyring = require("./keyring.cjs");
+exports.DEV_PHRASE = require_keyring.DEV_PHRASE;
+exports.Keyring = require_keyring.Keyring;
+exports.Pairs = require_pairs.Pairs;

package/dist/cjs/keyring/keyring.cjs

@@ -1,271 +1,262 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util = require("@polkadot/util");
-const hex = require("@polkadot/util/hex");
-const is = require("@polkadot/util/is");
-const utilCrypto = require("@prosopo/util-crypto");
-const index = require("../pair/index.cjs");
-const pairs = require("./pairs.cjs");
-const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-const PairFromSeed = {
-  sr25519: (seed) => utilCrypto.sr25519FromSeed(seed),
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+const require_index = require("../pair/index.cjs");
+const require_pairs = require("./pairs.cjs");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+let _polkadot_util_hex = require("@polkadot/util/hex");
+let _polkadot_util_is = require("@polkadot/util/is");
+//#region src/keyring/keyring.ts
+var DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+var PairFromSeed = {
+	sr25519: (seed) => (0, _prosopo_util_crypto.sr25519FromSeed)(seed),
+	ed25519: () => {
+		throw new Error("Not Implemented");
+	},
+	ecdsa: () => {
+		throw new Error("Not Implemented");
+	},
+	ethereum: () => {
+		throw new Error("Not Implemented");
+	}
 };
 function pairToPublic({ publicKey }) {
-  return publicKey;
-}
-class Keyring {
-  constructor(options = {}) {
-    this.decodeAddress = utilCrypto.decodeAddress;
-    this.encodeAddress = (address, ss58Format) => {
-      return utilCrypto.encodeAddress(address, ss58Format ?? this.#ss58);
-    };
-    options.type = options.type || "sr25519";
-    if (!["sr25519"].includes(options.type || "undefined")) {
-      throw new Error(
-        `Expected a keyring type of either 'sr25519', found '${options.type || "unknown"}`
-      );
-    }
-    this.#pairs = new pairs.Pairs();
-    this.#ss58 = options.ss58Format;
-    this.#type = options.type;
-  }
-  #pairs;
-  #type;
-  #ss58;
-  /**
-   * @description retrieve the pairs (alias for getPairs)
-   */
-  get pairs() {
-    return this.getPairs();
-  }
-  /**
-   * @description retrieve the publicKeys (alias for getPublicKeys)
-   */
-  get publicKeys() {
-    return this.getPublicKeys();
-  }
-  /**
-   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
-   */
-  get type() {
-    return this.#type;
-  }
-  /**
-   * @name addPair
-   * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   */
-  addPair(pair) {
-    return this.#pairs.add(pair);
-  }
-  /**
-   * @name addFromAddress
-   * @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
-   * the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from them that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  addFromAddress(address, meta = {}, encoded = null, type = this.type, ignoreChecksum, encType) {
-    const publicKey = this.decodeAddress(address, ignoreChecksum);
-    return this.addPair(
-      index.createPair(
-        { toSS58: this.encodeAddress, type },
-        { publicKey, secretKey: new Uint8Array() },
-        meta,
-        encoded,
-        encType
-      )
-    );
-  }
-  /**
-   * @name addFromJson
-   * @summary Stores an account, given JSON data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to provide a json object argument that contains account information (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from it that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  addFromJson(json, ignoreChecksum) {
-    return this.addPair(this.createFromJson(json, ignoreChecksum));
-  }
-  /**
-   * @name addFromMnemonic
-   * @summary Stores an account, given a mnemonic, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to provide a mnemonic (seed phrase that is provided when account is originally created)
-   * argument and a metadata argument that contains account information (that may be obtained from the json file
-   * of an account backup), and then generates a keyring pair from it that it passes to
-   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  addFromMnemonic(mnemonic, meta = {}, type = this.type) {
-    return this.addFromUri(mnemonic, meta, type);
-  }
-  /**
-   * @name addFromPair
-   * @summary Stores an account created from an explicit publicKey/secreteKey combination
-   */
-  addFromPair(pair, meta = {}, type = this.type) {
-    return this.addPair(this.createFromPair(pair, meta, type));
-  }
-  /**
-   * @name addFromSeed
-   * @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Stores in a keyring pair dictionary the public key of the pair as a key and the pair as the associated value.
-   * Allows user to provide the account seed as an argument, and then generates a keyring pair from it that it passes to
-   * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
-   */
-  addFromSeed(seed, meta = {}, type = this.type) {
-    return this.addPair(
-      index.createPair(
-        { toSS58: this.encodeAddress, type },
-        PairFromSeed[type](seed),
-        meta,
-        null
-      )
-    );
-  }
-  /**
-   * @name addFromUri
-   * @summary Creates an account via an suri
-   * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed). The secret can be a hex string, mnemonic phrase or a string (to be padded)
-   */
-  addFromUri(suri, meta = {}, type = this.type) {
-    return this.addPair(this.createFromUri(suri, meta, type));
-  }
-  /**
-   * @name createFromJson
-   * @description Creates a pair from a JSON keyfile
-   */
-  createFromJson({
-    address,
-    encoded,
-    encoding: { content, type, version },
-    meta
-  }, ignoreChecksum) {
-    if (version === "3" && content[0] !== "pkcs8") {
-      throw new Error(
-        `Unable to decode non-pkcs8 type, [${content.join(",")}] found}`
-      );
-    }
-    const cryptoType = version === "0" || !Array.isArray(content) ? this.type : content[1];
-    if (!cryptoType) {
-      throw new Error("cryptoType is undefined");
-    }
-    const encType = !Array.isArray(type) ? [type] : type;
-    if (!["sr25519"].includes(cryptoType)) {
-      throw new Error(`Unknown crypto type ${cryptoType}`);
-    }
-    const publicKey = is.isHex(address) ? hex.hexToU8a(address) : this.decodeAddress(address, ignoreChecksum);
-    const decoded = is.isHex(encoded) ? hex.hexToU8a(encoded) : utilCrypto.base64Decode(encoded);
-    return index.createPair(
-      { toSS58: this.encodeAddress, type: cryptoType },
-      { publicKey, secretKey: new Uint8Array() },
-      meta,
-      decoded,
-      encType
-    );
-  }
-  /**
-   * @name createFromPair
-   * @summary Creates a pair from an explicit publicKey/secreteKey combination
-   */
-  createFromPair(pair, meta = {}, type = this.type) {
-    return index.createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
-  }
-  /**
-   * @name createFromUri
-   * @summary Creates a Keypair from an suri
-   * @description This creates a pair from the suri, but does not add it to the keyring
-   */
-  createFromUri(_suri, meta = {}, type = this.type) {
-    const suri = _suri.startsWith("//") ? `${DEV_PHRASE}${_suri}` : _suri;
-    const { derivePath, password, path, phrase } = utilCrypto.keyExtractSuri(suri);
-    let seed;
-    const isPhraseHex = is.isHex(phrase, 256);
-    if (isPhraseHex) {
-      seed = hex.hexToU8a(phrase);
-    } else {
-      const parts = phrase.split(" ");
-      if ([12, 15, 18, 21, 24].includes(parts.length)) {
-        seed = type === "ethereum" ? (() => {
-          throw new Error(
-            "Not implemented - Prosopo Keyring supports sr25519 only"
-          );
-        })() : utilCrypto.mnemonicToMiniSecret(phrase, password);
-      } else {
-        if (phrase.length > 32) {
-          throw new Error(
-            "specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes"
-          );
-        }
-        seed = util.stringToU8a(phrase.padEnd(32));
-      }
-    }
-    const derived = utilCrypto.keyFromPath(PairFromSeed[type](seed), path, type);
-    return index.createPair(
-      { toSS58: this.encodeAddress, type },
-      derived,
-      meta,
-      null
-    );
-  }
-  /**
-   * @name getPair
-   * @summary Retrieves an account keyring pair from the Keyring Pair Dictionary, given an account address
-   * @description Returns a keyring pair value from the keyring pair dictionary by performing
-   * a key lookup using the provided account address or public key (after decoding it).
-   */
-  getPair(address) {
-    return this.#pairs.get(address);
-  }
-  /**
-   * @name getPairs
-   * @summary Retrieves all account keyring pairs from the Keyring Pair Dictionary
-   * @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
-   */
-  getPairs() {
-    return this.#pairs.all();
-  }
-  /**
-   * @name getPublicKeys
-   * @summary Retrieves Public Keys of all Keyring Pairs stored in the Keyring Pair Dictionary
-   * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
-   */
-  getPublicKeys() {
-    return this.#pairs.all().map(pairToPublic);
-  }
-  /**
-   * @name removePair
-   * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
-   */
-  removePair(address) {
-    this.#pairs.remove(address);
-  }
-  /**
-   * @name setSS58Format;
-   * @description Sets the ss58 format for the keyring
-   */
-  setSS58Format(ss58) {
-    this.#ss58 = ss58;
-  }
-  /**
-   * @name toJson
-   * @summary Returns a JSON object associated with the input argument that contains metadata assocated with an account
-   * @description Returns a JSON object containing the metadata associated with an account
-   * when valid address or public key and when the account passphrase is provided if the account secret
-   * is not already unlocked and available in memory. Note that in [Polkadot-JS Apps](https://github.com/polkadot-js/apps) the user
-   * may backup their account to a JSON file that contains this information.
-   */
-  toJson(address, passphrase) {
-    return this.#pairs.get(address).toJson(passphrase);
-  }
+	return publicKey;
 }
+/**
+* # @polkadot/keyring
+*
+* ## Overview
+*
+* @name Keyring
+* @summary Keyring management of user accounts
+* @description Allows generation of keyring pairs from a variety of input combinations, such as
+* json object containing account address or public key, account metadata, and account encoded using
+* `addFromJson`, or by providing those values as arguments separately to `addFromAddress`,
+* or by providing the mnemonic (seed phrase) and account metadata as arguments to `addFromMnemonic`.
+* Stores the keyring pairs in a keyring pair dictionary. Removal of the keyring pairs from the keyring pair
+* dictionary is achieved using `removePair`. Retrieval of all the stored pairs via `getPairs` or perform
+* lookup of a pair for a given account address or public key using `getPair`. JSON metadata associated with
+* an account may be obtained using `toJson` accompanied by the account passphrase.
+*/
+var Keyring = class {
+	#pairs;
+	#type;
+	#ss58;
+	constructor(options = {}) {
+		this.decodeAddress = _prosopo_util_crypto.decodeAddress;
+		this.encodeAddress = (address, ss58Format) => {
+			return (0, _prosopo_util_crypto.encodeAddress)(address, ss58Format ?? this.#ss58);
+		};
+		options.type = options.type || "sr25519";
+		if (!["sr25519"].includes(options.type || "undefined")) throw new Error(`Expected a keyring type of either 'sr25519', found '${options.type || "unknown"}`);
+		this.#pairs = new require_pairs.Pairs();
+		this.#ss58 = options.ss58Format;
+		this.#type = options.type;
+	}
+	/**
+	* @description retrieve the pairs (alias for getPairs)
+	*/
+	get pairs() {
+		return this.getPairs();
+	}
+	/**
+	* @description retrieve the publicKeys (alias for getPublicKeys)
+	*/
+	get publicKeys() {
+		return this.getPublicKeys();
+	}
+	/**
+	* @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
+	*/
+	get type() {
+		return this.#type;
+	}
+	/**
+	* @name addPair
+	* @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+	*/
+	addPair(pair) {
+		return this.#pairs.add(pair);
+	}
+	/**
+	* @name addFromAddress
+	* @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+	* @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
+	* the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
+	* of an account backup), and then generates a keyring pair from them that it passes to
+	* `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+	*/
+	addFromAddress(address, meta = {}, encoded = null, type = this.type, ignoreChecksum, encType) {
+		const publicKey = this.decodeAddress(address, ignoreChecksum);
+		return this.addPair(require_index.createPair({
+			toSS58: this.encodeAddress,
+			type
+		}, {
+			publicKey,
+			secretKey: /* @__PURE__ */ new Uint8Array()
+		}, meta, encoded, encType));
+	}
+	/**
+	* @name addFromJson
+	* @summary Stores an account, given JSON data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+	* @description Allows user to provide a json object argument that contains account information (that may be obtained from the json file
+	* of an account backup), and then generates a keyring pair from it that it passes to
+	* `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+	*/
+	addFromJson(json, ignoreChecksum) {
+		return this.addPair(this.createFromJson(json, ignoreChecksum));
+	}
+	/**
+	* @name addFromMnemonic
+	* @summary Stores an account, given a mnemonic, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+	* @description Allows user to provide a mnemonic (seed phrase that is provided when account is originally created)
+	* argument and a metadata argument that contains account information (that may be obtained from the json file
+	* of an account backup), and then generates a keyring pair from it that it passes to
+	* `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+	*/
+	addFromMnemonic(mnemonic, meta = {}, type = this.type) {
+		return this.addFromUri(mnemonic, meta, type);
+	}
+	/**
+	* @name addFromPair
+	* @summary Stores an account created from an explicit publicKey/secreteKey combination
+	*/
+	addFromPair(pair, meta = {}, type = this.type) {
+		return this.addPair(this.createFromPair(pair, meta, type));
+	}
+	/**
+	* @name addFromSeed
+	* @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+	* @description Stores in a keyring pair dictionary the public key of the pair as a key and the pair as the associated value.
+	* Allows user to provide the account seed as an argument, and then generates a keyring pair from it that it passes to
+	* `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
+	*/
+	addFromSeed(seed, meta = {}, type = this.type) {
+		return this.addPair(require_index.createPair({
+			toSS58: this.encodeAddress,
+			type
+		}, PairFromSeed[type](seed), meta, null));
+	}
+	/**
+	* @name addFromUri
+	* @summary Creates an account via an suri
+	* @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed). The secret can be a hex string, mnemonic phrase or a string (to be padded)
+	*/
+	addFromUri(suri, meta = {}, type = this.type) {
+		return this.addPair(this.createFromUri(suri, meta, type));
+	}
+	/**
+	* @name createFromJson
+	* @description Creates a pair from a JSON keyfile
+	*/
+	createFromJson({ address, encoded, encoding: { content, type, version }, meta }, ignoreChecksum) {
+		if (version === "3" && content[0] !== "pkcs8") throw new Error(`Unable to decode non-pkcs8 type, [${content.join(",")}] found}`);
+		const cryptoType = version === "0" || !Array.isArray(content) ? this.type : content[1];
+		if (!cryptoType) throw new Error("cryptoType is undefined");
+		const encType = !Array.isArray(type) ? [type] : type;
+		if (!["sr25519"].includes(cryptoType)) throw new Error(`Unknown crypto type ${cryptoType}`);
+		const publicKey = (0, _polkadot_util_is.isHex)(address) ? (0, _polkadot_util_hex.hexToU8a)(address) : this.decodeAddress(address, ignoreChecksum);
+		const decoded = (0, _polkadot_util_is.isHex)(encoded) ? (0, _polkadot_util_hex.hexToU8a)(encoded) : (0, _prosopo_util_crypto.base64Decode)(encoded);
+		return require_index.createPair({
+			toSS58: this.encodeAddress,
+			type: cryptoType
+		}, {
+			publicKey,
+			secretKey: /* @__PURE__ */ new Uint8Array()
+		}, meta, decoded, encType);
+	}
+	/**
+	* @name createFromPair
+	* @summary Creates a pair from an explicit publicKey/secreteKey combination
+	*/
+	createFromPair(pair, meta = {}, type = this.type) {
+		return require_index.createPair({
+			toSS58: this.encodeAddress,
+			type
+		}, pair, meta, null);
+	}
+	/**
+	* @name createFromUri
+	* @summary Creates a Keypair from an suri
+	* @description This creates a pair from the suri, but does not add it to the keyring
+	*/
+	createFromUri(_suri, meta = {}, type = this.type) {
+		const suri = _suri.startsWith("//") ? `${DEV_PHRASE}${_suri}` : _suri;
+		const { derivePath, password, path, phrase } = (0, _prosopo_util_crypto.keyExtractSuri)(suri);
+		let seed;
+		if ((0, _polkadot_util_is.isHex)(phrase, 256)) seed = (0, _polkadot_util_hex.hexToU8a)(phrase);
+		else {
+			const parts = phrase.split(" ");
+			if ([
+				12,
+				15,
+				18,
+				21,
+				24
+			].includes(parts.length)) seed = type === "ethereum" ? (() => {
+				throw new Error("Not implemented - Prosopo Keyring supports sr25519 only");
+			})() : (0, _prosopo_util_crypto.mnemonicToMiniSecret)(phrase, password);
+			else {
+				if (phrase.length > 32) throw new Error("specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes");
+				seed = (0, _polkadot_util.stringToU8a)(phrase.padEnd(32));
+			}
+		}
+		const derived = (0, _prosopo_util_crypto.keyFromPath)(PairFromSeed[type](seed), path, type);
+		return require_index.createPair({
+			toSS58: this.encodeAddress,
+			type
+		}, derived, meta, null);
+	}
+	/**
+	* @name getPair
+	* @summary Retrieves an account keyring pair from the Keyring Pair Dictionary, given an account address
+	* @description Returns a keyring pair value from the keyring pair dictionary by performing
+	* a key lookup using the provided account address or public key (after decoding it).
+	*/
+	getPair(address) {
+		return this.#pairs.get(address);
+	}
+	/**
+	* @name getPairs
+	* @summary Retrieves all account keyring pairs from the Keyring Pair Dictionary
+	* @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
+	*/
+	getPairs() {
+		return this.#pairs.all();
+	}
+	/**
+	* @name getPublicKeys
+	* @summary Retrieves Public Keys of all Keyring Pairs stored in the Keyring Pair Dictionary
+	* @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
+	*/
+	getPublicKeys() {
+		return this.#pairs.all().map(pairToPublic);
+	}
+	/**
+	* @name removePair
+	* @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
+	*/
+	removePair(address) {
+		this.#pairs.remove(address);
+	}
+	/**
+	* @name setSS58Format;
+	* @description Sets the ss58 format for the keyring
+	*/
+	setSS58Format(ss58) {
+		this.#ss58 = ss58;
+	}
+	/**
+	* @name toJson
+	* @summary Returns a JSON object associated with the input argument that contains metadata assocated with an account
+	* @description Returns a JSON object containing the metadata associated with an account
+	* when valid address or public key and when the account passphrase is provided if the account secret
+	* is not already unlocked and available in memory. Note that in [Polkadot-JS Apps](https://github.com/polkadot-js/apps) the user
+	* may backup their account to a JSON file that contains this information.
+	*/
+	toJson(address, passphrase) {
+		return this.#pairs.get(address).toJson(passphrase);
+	}
+};
+//#endregion
 exports.DEV_PHRASE = DEV_PHRASE;
 exports.Keyring = Keyring;

package/dist/cjs/keyring/pairs.cjs

@@ -1,28 +1,24 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const util$1 = require("@polkadot/util");
-const util = require("@prosopo/util");
-const utilCrypto = require("@prosopo/util-crypto");
-class Pairs {
-  #map = {};
-  add(pair) {
-    this.#map[utilCrypto.decodeAddress(pair.address).toString()] = pair;
-    return pair;
-  }
-  all() {
-    return Object.values(this.#map);
-  }
-  get(address) {
-    const pair = this.#map[utilCrypto.decodeAddress(address).toString()];
-    if (!pair) {
-      throw new Error(
-        `Unable to retrieve keypair '${util$1.isU8a(address) || util$1.isHex(address) ? util.u8aToHex(util$1.u8aToU8a(address)) : address}'`
-      );
-    }
-    return pair;
-  }
-  remove(address) {
-    delete this.#map[utilCrypto.decodeAddress(address).toString()];
-  }
-}
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+let _polkadot_util = require("@polkadot/util");
+let _prosopo_util = require("@prosopo/util");
+//#region src/keyring/pairs.ts
+var Pairs = class {
+	#map = {};
+	add(pair) {
+		this.#map[(0, _prosopo_util_crypto.decodeAddress)(pair.address).toString()] = pair;
+		return pair;
+	}
+	all() {
+		return Object.values(this.#map);
+	}
+	get(address) {
+		const pair = this.#map[(0, _prosopo_util_crypto.decodeAddress)(address).toString()];
+		if (!pair) throw new Error(`Unable to retrieve keypair '${(0, _polkadot_util.isU8a)(address) || (0, _polkadot_util.isHex)(address) ? (0, _prosopo_util.u8aToHex)((0, _polkadot_util.u8aToU8a)(address)) : address}'`);
+		return pair;
+	}
+	remove(address) {
+		delete this.#map[(0, _prosopo_util_crypto.decodeAddress)(address).toString()];
+	}
+};
+//#endregion
 exports.Pairs = Pairs;