@prosopo/keyring 2.9.59 → 2.9.61

package/dist/keyring/keyring.js

@@ -1,271 +1,260 @@
-import { stringToU8a } from "@polkadot/util";
-import { hexToU8a } from "@polkadot/util/hex";
-import { isHex } from "@polkadot/util/is";
-import { sr25519FromSeed, decodeAddress, encodeAddress, base64Decode, keyExtractSuri, mnemonicToMiniSecret, keyFromPath } from "@prosopo/util-crypto";
 import { createPair } from "../pair/index.js";
 import { Pairs } from "./pairs.js";
-const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-const PairFromSeed = {
-  sr25519: (seed) => sr25519FromSeed(seed),
-  ed25519: () => {
-    throw new Error("Not Implemented");
-  },
-  ecdsa: () => {
-    throw new Error("Not Implemented");
-  },
-  ethereum: () => {
-    throw new Error("Not Implemented");
-  }
+import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, mnemonicToMiniSecret, sr25519FromSeed } from "@prosopo/util-crypto";
+import { stringToU8a } from "@polkadot/util";
+import { hexToU8a } from "@polkadot/util/hex";
+import { isHex as isHex$1 } from "@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) => 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 = decodeAddress;
-    this.encodeAddress = (address, ss58Format) => {
-      return 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();
-    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(
-      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(
-      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 = isHex(address) ? hexToU8a(address) : this.decodeAddress(address, ignoreChecksum);
-    const decoded = isHex(encoded) ? hexToU8a(encoded) : base64Decode(encoded);
-    return 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 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 } = keyExtractSuri(suri);
-    let seed;
-    const isPhraseHex = isHex(phrase, 256);
-    if (isPhraseHex) {
-      seed = 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"
-          );
-        })() : 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 = stringToU8a(phrase.padEnd(32));
-      }
-    }
-    const derived = keyFromPath(PairFromSeed[type](seed), path, type);
-    return 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;
 }
-export {
-  DEV_PHRASE,
-  Keyring
+/**
+* # @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 = decodeAddress;
+		this.encodeAddress = (address, ss58Format) => {
+			return 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();
+		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(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(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 = isHex$1(address) ? hexToU8a(address) : this.decodeAddress(address, ignoreChecksum);
+		const decoded = isHex$1(encoded) ? hexToU8a(encoded) : base64Decode(encoded);
+		return 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 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 { derivePath, password, path, phrase } = keyExtractSuri(_suri.startsWith("//") ? `${DEV_PHRASE}${_suri}` : _suri);
+		let seed;
+		if (isHex$1(phrase, 256)) seed = 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");
+			})() : 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 = stringToU8a(phrase.padEnd(32));
+			}
+		}
+		const derived = keyFromPath(PairFromSeed[type](seed), path, type);
+		return 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
+export { DEV_PHRASE, Keyring };

package/dist/keyring/pairs.js

@@ -1,28 +1,24 @@
-import { isU8a, isHex, u8aToU8a } from "@polkadot/util";
-import { u8aToHex } from "@prosopo/util";
 import { decodeAddress } from "@prosopo/util-crypto";
-class Pairs {
-  #map = {};
-  add(pair) {
-    this.#map[decodeAddress(pair.address).toString()] = pair;
-    return pair;
-  }
-  all() {
-    return Object.values(this.#map);
-  }
-  get(address) {
-    const pair = this.#map[decodeAddress(address).toString()];
-    if (!pair) {
-      throw new Error(
-        `Unable to retrieve keypair '${isU8a(address) || isHex(address) ? u8aToHex(u8aToU8a(address)) : address}'`
-      );
-    }
-    return pair;
-  }
-  remove(address) {
-    delete this.#map[decodeAddress(address).toString()];
-  }
-}
-export {
-  Pairs
+import { isHex, isU8a, u8aToU8a } from "@polkadot/util";
+import { u8aToHex as u8aToHex$1 } from "@prosopo/util";
+//#region src/keyring/pairs.ts
+var Pairs = class {
+	#map = {};
+	add(pair) {
+		this.#map[decodeAddress(pair.address).toString()] = pair;
+		return pair;
+	}
+	all() {
+		return Object.values(this.#map);
+	}
+	get(address) {
+		const pair = this.#map[decodeAddress(address).toString()];
+		if (!pair) throw new Error(`Unable to retrieve keypair '${isU8a(address) || isHex(address) ? u8aToHex$1(u8aToU8a(address)) : address}'`);
+		return pair;
+	}
+	remove(address) {
+		delete this.#map[decodeAddress(address).toString()];
+	}
 };
+//#endregion
+export { Pairs };

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 };