@prosopo/keyring 2.8.6 → 2.8.7

package/dist/keyring/keyring.js

@@ -1,146 +1,271 @@
-var _Keyring_pairs, _Keyring_type, _Keyring_ss58;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { stringToU8a } from "@polkadot/util";
 import { hexToU8a } from "@polkadot/util/hex";
 import { isHex } from "@polkadot/util/is";
-import { decodeAddress, mnemonicToMiniSecret } from "@prosopo/util-crypto";
-import { encodeAddress } from "@prosopo/util-crypto";
-import { base64Decode } from "@prosopo/util-crypto";
-import { sr25519FromSeed } from "@prosopo/util-crypto";
-import { keyExtractSuri, keyFromPath } from "@prosopo/util-crypto";
+import { sr25519FromSeed, decodeAddress, encodeAddress, base64Decode, keyExtractSuri, mnemonicToMiniSecret, keyFromPath } from "@prosopo/util-crypto";
 import { createPair } from "../pair/index.js";
 import { Pairs } from "./pairs.js";
-export const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+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");
-    },
+  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;
+  return publicKey;
 }
-export class Keyring {
-    constructor(options = {}) {
-        _Keyring_pairs.set(this, void 0);
-        _Keyring_type.set(this, void 0);
-        _Keyring_ss58.set(this, void 0);
-        this.decodeAddress = decodeAddress;
-        this.encodeAddress = (address, ss58Format) => {
-            return encodeAddress(address, ss58Format ?? __classPrivateFieldGet(this, _Keyring_ss58, "f"));
-        };
-        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"}`);
-        }
-        __classPrivateFieldSet(this, _Keyring_pairs, new Pairs(), "f");
-        __classPrivateFieldSet(this, _Keyring_ss58, options.ss58Format, "f");
-        __classPrivateFieldSet(this, _Keyring_type, options.type, "f");
-    }
-    get pairs() {
-        return this.getPairs();
-    }
-    get publicKeys() {
-        return this.getPublicKeys();
-    }
-    get type() {
-        return __classPrivateFieldGet(this, _Keyring_type, "f");
-    }
-    addPair(pair) {
-        return __classPrivateFieldGet(this, _Keyring_pairs, "f").add(pair);
-    }
-    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));
+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"}`
+      );
     }
-    addFromJson(json, ignoreChecksum) {
-        return this.addPair(this.createFromJson(json, ignoreChecksum));
+    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}`
+      );
     }
-    addFromMnemonic(mnemonic, meta = {}, type = this.type) {
-        return this.addFromUri(mnemonic, meta, type);
+    const cryptoType = version === "0" || !Array.isArray(content) ? this.type : content[1];
+    if (!cryptoType) {
+      throw new Error("cryptoType is undefined");
     }
-    addFromPair(pair, meta = {}, type = this.type) {
-        return this.addPair(this.createFromPair(pair, meta, type));
+    const encType = !Array.isArray(type) ? [type] : type;
+    if (!["sr25519"].includes(cryptoType)) {
+      throw new Error(`Unknown crypto type ${cryptoType}`);
     }
-    addFromSeed(seed, meta = {}, type = this.type) {
-        return this.addPair(createPair({ toSS58: this.encodeAddress, type }, PairFromSeed[type](seed), meta, null));
-    }
-    addFromUri(suri, meta = {}, type = this.type) {
-        return this.addPair(this.createFromUri(suri, meta, type));
-    }
-    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 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"
+          );
         }
-        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);
-    }
-    createFromPair(pair, meta = {}, type = this.type) {
-        return createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
-    }
-    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);
-    }
-    getPair(address) {
-        return __classPrivateFieldGet(this, _Keyring_pairs, "f").get(address);
-    }
-    getPairs() {
-        return __classPrivateFieldGet(this, _Keyring_pairs, "f").all();
-    }
-    getPublicKeys() {
-        return __classPrivateFieldGet(this, _Keyring_pairs, "f").all().map(pairToPublic);
-    }
-    removePair(address) {
-        __classPrivateFieldGet(this, _Keyring_pairs, "f").remove(address);
-    }
-    setSS58Format(ss58) {
-        __classPrivateFieldSet(this, _Keyring_ss58, ss58, "f");
-    }
-    toJson(address, passphrase) {
-        return __classPrivateFieldGet(this, _Keyring_pairs, "f").get(address).toJson(passphrase);
+        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);
+  }
 }
-_Keyring_pairs = new WeakMap(), _Keyring_type = new WeakMap(), _Keyring_ss58 = new WeakMap();
-//# sourceMappingURL=keyring.js.map
+export {
+  DEV_PHRASE,
+  Keyring
+};

package/dist/keyring/pairs.js

@@ -1,31 +1,28 @@
-var _Pairs_map;
-import { __classPrivateFieldGet } from "tslib";
-import { isHex, isU8a, u8aToU8a } from "@polkadot/util";
+import { isU8a, isHex, u8aToU8a } from "@polkadot/util";
 import { u8aToHex } from "@prosopo/util";
 import { decodeAddress } from "@prosopo/util-crypto";
-export class Pairs {
-    constructor() {
-        _Pairs_map.set(this, {});
-    }
-    add(pair) {
-        __classPrivateFieldGet(this, _Pairs_map, "f")[decodeAddress(pair.address).toString()] = pair;
-        return pair;
-    }
-    all() {
-        return Object.values(__classPrivateFieldGet(this, _Pairs_map, "f"));
-    }
-    get(address) {
-        const pair = __classPrivateFieldGet(this, _Pairs_map, "f")[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 __classPrivateFieldGet(this, _Pairs_map, "f")[decodeAddress(address).toString()];
+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()];
+  }
 }
-_Pairs_map = new WeakMap();
-//# sourceMappingURL=pairs.js.map
+export {
+  Pairs
+};

package/dist/pair/decode.js

@@ -1,30 +1,32 @@
 import { u8aEq } from "@polkadot/util";
 import { jsonDecryptData } from "@prosopo/util-crypto";
-import { PAIR_DIV, PAIR_HDR, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH, } from "./defaults.js";
+import { PAIR_HDR, SEC_LENGTH, PAIR_DIV, SEED_LENGTH, PUB_LENGTH } from "./defaults.js";
 const SEED_OFFSET = PAIR_HDR.length;
-export function decodePair(passphrase, encrypted, _encType) {
-    const encType = Array.isArray(_encType) || _encType === undefined ? _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);
+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)) {
-        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");
-        }
+      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 pubOffset = divOffset + PAIR_DIV.length;
+  const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
+  return {
+    publicKey,
+    secretKey
+  };
 }
-//# sourceMappingURL=decode.js.map
+export {
+  decodePair
+};

package/dist/pair/defaults.js

@@ -1,9 +1,31 @@
-export const PAIR_DIV = new Uint8Array([161, 35, 3, 33, 0]);
-export const PAIR_HDR = new Uint8Array([
-    48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32,
+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
 ]);
-export const PUB_LENGTH = 32;
-export const SALT_LENGTH = 32;
-export const SEC_LENGTH = 64;
-export const SEED_LENGTH = 32;
-//# sourceMappingURL=defaults.js.map
+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
+};

package/dist/pair/encode.js

@@ -1,16 +1,18 @@
 import { u8aConcat } from "@polkadot/util";
-import { naclEncrypt, scryptEncode, scryptToU8a } from "@prosopo/util-crypto";
-import { PAIR_DIV, PAIR_HDR } from "./defaults.js";
-export 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);
+import { scryptEncode, naclEncrypt, scryptToU8a } from "@prosopo/util-crypto";
+import { PAIR_HDR, PAIR_DIV } from "./defaults.js";
+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);
 }
-//# sourceMappingURL=encode.js.map
+export {
+  encodePair
+};