@pezkuwi/keyring 14.0.6 → 14.0.10

package/build/cjs/pair/index.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPair = createPair;
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const decode_js_1 = require("./decode.js");
+const encode_js_1 = require("./encode.js");
+const toJson_js_1 = require("./toJson.js");
+const SIG_TYPE_NONE = new Uint8Array();
+const TYPE_FROM_SEED = {
+    ecdsa: util_crypto_1.secp256k1PairFromSeed,
+    ed25519: util_crypto_1.ed25519PairFromSeed,
+    ethereum: util_crypto_1.secp256k1PairFromSeed,
+    sr25519: util_crypto_1.sr25519PairFromSeed
+};
+const TYPE_PREFIX = {
+    ecdsa: new Uint8Array([2]),
+    ed25519: new Uint8Array([0]),
+    ethereum: new Uint8Array([2]),
+    sr25519: new Uint8Array([1])
+};
+const TYPE_SIGNATURE = {
+    ecdsa: (m, p) => (0, util_crypto_1.secp256k1Sign)(m, p, 'blake2'),
+    ed25519: util_crypto_1.ed25519Sign,
+    ethereum: (m, p) => (0, util_crypto_1.secp256k1Sign)(m, p, 'keccak'),
+    sr25519: util_crypto_1.sr25519Sign
+};
+const TYPE_ADDRESS = {
+    ecdsa: (p) => p.length > 32 ? (0, util_crypto_1.blake2AsU8a)(p) : p,
+    ed25519: (p) => p,
+    ethereum: (p) => p.length === 20 ? p : (0, util_crypto_1.keccakAsU8a)((0, util_crypto_1.secp256k1Expand)(p)),
+    sr25519: (p) => p
+};
+function isLocked(secretKey) {
+    return !secretKey || (0, util_1.u8aEmpty)(secretKey);
+}
+function vrfHash(proof, context, extra) {
+    return (0, util_crypto_1.blake2AsU8a)((0, util_1.u8aConcat)(context || '', extra || '', proof));
+}
+/**
+ * @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 = (0, decode_js_1.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 = (0, encode_js_1.encodePair)({ publicKey, secretKey }, passphrase); // re-encode, latest version
+        encTypes = undefined; // swap to defaults, latest version follows
+        return encoded;
+    };
+    const encodeAddress = () => {
+        const raw = TYPE_ADDRESS[type](publicKey);
+        return type === 'ethereum'
+            ? (0, util_crypto_1.ethereumEncode)(raw)
+            : toSS58(raw);
+    };
+    return {
+        get address() {
+            return encodeAddress();
+        },
+        get addressRaw() {
+            const raw = TYPE_ADDRESS[type](publicKey);
+            return type === 'ethereum'
+                ? raw.slice(-20)
+                : raw;
+        },
+        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, meta) => {
+            if (type === 'ethereum') {
+                throw new Error('Unable to derive on this keypair');
+            }
+            else if (isLocked(secretKey)) {
+                throw new Error('Cannot derive on a locked keypair');
+            }
+            const { path } = (0, util_crypto_1.keyExtractPath)(suri);
+            const derived = (0, util_crypto_1.keyFromPath)({ publicKey, secretKey }, path, type);
+            return createPair({ toSS58, type }, derived, meta, null);
+        },
+        encodePkcs8: (passphrase) => {
+            return recode(passphrase);
+        },
+        lock: () => {
+            secretKey = new Uint8Array();
+        },
+        setMeta: (additional) => {
+            meta = (0, util_1.objectSpread)({}, meta, additional);
+        },
+        sign: (message, options = {}) => {
+            if (isLocked(secretKey)) {
+                throw new Error('Cannot sign with a locked key pair');
+            }
+            return (0, util_1.u8aConcat)(options.withType
+                ? TYPE_PREFIX[type]
+                : SIG_TYPE_NONE, TYPE_SIGNATURE[type]((0, util_1.u8aToU8a)(message), { publicKey, secretKey }));
+        },
+        toJson: (passphrase) => {
+            // NOTE: For ecdsa and ethereum, the publicKey cannot be extracted from the address. For these
+            // pass the hex-encoded publicKey through to the address portion of the JSON (before decoding)
+            // unless the publicKey is already an address
+            const address = ['ecdsa', 'ethereum'].includes(type)
+                ? publicKey.length === 20
+                    ? (0, util_1.u8aToHex)(publicKey)
+                    : (0, util_1.u8aToHex)((0, util_crypto_1.secp256k1Compress)(publicKey))
+                : encodeAddress();
+            return (0, toJson_js_1.pairToJson)(type, { address, meta }, recode(passphrase), !!passphrase);
+        },
+        unlock: (passphrase) => {
+            return decodePkcs8(passphrase);
+        },
+        verify: (message, signature, signerPublic) => {
+            return (0, util_crypto_1.signatureVerify)(message, signature, TYPE_ADDRESS[type]((0, util_1.u8aToU8a)(signerPublic))).isValid;
+        },
+        vrfSign: (message, context, extra) => {
+            if (isLocked(secretKey)) {
+                throw new Error('Cannot sign with a locked key pair');
+            }
+            if (type === 'sr25519') {
+                return (0, util_crypto_1.sr25519VrfSign)(message, { secretKey }, context, extra);
+            }
+            const proof = TYPE_SIGNATURE[type]((0, util_1.u8aToU8a)(message), { publicKey, secretKey });
+            return (0, util_1.u8aConcat)(vrfHash(proof, context, extra), proof);
+        },
+        vrfVerify: (message, vrfResult, signerPublic, context, extra) => {
+            if (type === 'sr25519') {
+                return (0, util_crypto_1.sr25519VrfVerify)(message, vrfResult, publicKey, context, extra);
+            }
+            const result = (0, util_crypto_1.signatureVerify)(message, (0, util_1.u8aConcat)(TYPE_PREFIX[type], vrfResult.subarray(32)), TYPE_ADDRESS[type]((0, util_1.u8aToU8a)(signerPublic)));
+            return result.isValid && (0, util_1.u8aEq)(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra));
+        }
+    };
+}

package/build/cjs/pair/nobody.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nobody = nobody;
+const publicKey = new Uint8Array(32);
+const address = '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM';
+const meta = {
+    isTesting: true,
+    name: 'nobody'
+};
+const json = {
+    address,
+    encoded: '',
+    encoding: {
+        content: ['pkcs8', 'ed25519'],
+        type: 'none',
+        version: '0'
+    },
+    meta
+};
+const pair = {
+    address,
+    addressRaw: publicKey,
+    decodePkcs8: (_passphrase, _encoded) => undefined,
+    derive: (_suri, _meta) => pair,
+    encodePkcs8: (_passphrase) => new Uint8Array(0),
+    isLocked: true,
+    lock: () => {
+        // no locking, it is always locked
+    },
+    meta,
+    publicKey,
+    setMeta: (_meta) => undefined,
+    sign: (_message) => new Uint8Array(64),
+    toJson: (_passphrase) => json,
+    type: 'ed25519',
+    unlock: (_passphrase) => undefined,
+    verify: (_message, _signature) => false,
+    vrfSign: (_message, _context, _extra) => new Uint8Array(96),
+    vrfVerify: (_message, _vrfResult, _context, _extra) => false
+};
+function nobody() {
+    return pair;
+}

package/build/cjs/pair/toJson.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pairToJson = pairToJson;
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+function pairToJson(type, { address, meta }, encoded, isEncrypted) {
+    return (0, util_1.objectSpread)((0, util_crypto_1.jsonEncryptFormat)(encoded, ['pkcs8', type], isEncrypted), {
+        address,
+        meta
+    });
+}

package/build/cjs/pair/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/pairs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pairs = void 0;
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+class Pairs {
+    #map = {};
+    add(pair) {
+        this.#map[(0, util_crypto_1.decodeAddress)(pair.address).toString()] = pair;
+        return pair;
+    }
+    all() {
+        return Object.values(this.#map);
+    }
+    get(address) {
+        const pair = this.#map[(0, util_crypto_1.decodeAddress)(address).toString()];
+        if (!pair) {
+            throw new Error(`Unable to retrieve keypair '${(0, util_1.isU8a)(address) || (0, util_1.isHex)(address)
+                ? (0, util_1.u8aToHex)((0, util_1.u8aToU8a)(address))
+                : address}'`);
+        }
+        return pair;
+    }
+    remove(address) {
+        delete this.#map[(0, util_crypto_1.decodeAddress)(address).toString()];
+    }
+}
+exports.Pairs = Pairs;

package/build/cjs/testing.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAIRSETHEREUM = exports.PAIRSSR25519 = void 0;
+exports.createTestKeyring = createTestKeyring;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("./pair/index.js");
+const keyring_js_1 = require("./keyring.js");
+exports.PAIRSSR25519 = [
+    {
+        p: '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d',
+        s: '0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011', // nosemgrep
+        seed: 'Alice',
+        type: 'sr25519'
+    },
+    {
+        p: '0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f',
+        s: '0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd', // nosemgrep
+        seed: 'Alice//stash',
+        type: 'sr25519'
+    },
+    {
+        p: '0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48',
+        s: '0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325', // nosemgrep
+        seed: 'Bob',
+        type: 'sr25519'
+    },
+    {
+        p: '0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e',
+        s: '0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde', // nosemgrep
+        seed: 'Bob//stash',
+        type: 'sr25519'
+    },
+    {
+        p: '0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22',
+        s: '0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c', // nosemgrep
+        seed: 'Charlie',
+        type: 'sr25519'
+    },
+    {
+        p: '0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20',
+        s: '0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568', // nosemgrep
+        seed: 'Dave',
+        type: 'sr25519'
+    },
+    {
+        p: '0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e',
+        s: '0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587', // nosemgrep
+        seed: 'Eve',
+        type: 'sr25519'
+    },
+    {
+        p: '0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c',
+        s: '0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426', // nosemgrep
+        seed: 'Ferdie',
+        type: 'sr25519'
+    }
+];
+exports.PAIRSETHEREUM = [
+    {
+        name: 'Alith',
+        p: '0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f',
+        s: '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133', // nosemgrep
+        type: 'ethereum'
+    },
+    {
+        name: 'Baltathar',
+        p: '0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518',
+        s: '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b', // nosemgrep
+        type: 'ethereum'
+    },
+    {
+        name: 'Charleth',
+        p: '0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e',
+        s: '0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b', // nosemgrep
+        type: 'ethereum'
+    },
+    {
+        name: 'Dorothy',
+        p: '0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c',
+        s: '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68', // nosemgrep
+        type: 'ethereum'
+    },
+    {
+        name: 'Ethan',
+        p: '0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa',
+        s: '0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4', // nosemgrep
+        type: 'ethereum'
+    },
+    {
+        name: 'Faith',
+        p: '0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74',
+        s: '0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df', // nosemgrep
+        type: 'ethereum'
+    }
+];
+function createMeta(name, seed) {
+    if (!name && !seed) {
+        throw new Error('Testing pair should have either a name or a seed');
+    }
+    return {
+        isTesting: true,
+        name: name || seed?.replace('//', '_').toLowerCase()
+    };
+}
+/**
+ * @name testKeyring
+ * @summary Create an instance of Keyring pre-populated with locked test accounts
+ * @description The test accounts (i.e. alice, bob, dave, eve, ferdie)
+ * are available on the dev chain and each test account is initialized with DOT funds.
+ */
+function createTestKeyring(options = {}, isDerived = true) {
+    const keyring = new keyring_js_1.Keyring(options);
+    const pairs = options.type === 'ethereum'
+        ? exports.PAIRSETHEREUM
+        : exports.PAIRSSR25519;
+    for (const { name, p, s, seed, type } of pairs) {
+        const meta = createMeta(name, seed);
+        const pair = !isDerived && !name && seed
+            ? keyring.addFromUri(seed, meta, options.type)
+            : keyring.addPair((0, index_js_1.createPair)({ toSS58: keyring.encodeAddress, type }, { publicKey: (0, util_1.hexToU8a)(p), secretKey: (0, util_1.hexToU8a)(s) }, meta));
+        pair.lock = () => {
+            // we don't have lock/unlock functionality here
+        };
+    }
+    return keyring;
+}

package/build/cjs/testingPairs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestPairs = createTestPairs;
+const nobody_js_1 = require("./pair/nobody.js");
+const testing_js_1 = require("./testing.js");
+function createTestPairs(options, isDerived = true) {
+    const keyring = (0, testing_js_1.createTestKeyring)(options, isDerived);
+    const pairs = keyring.getPairs();
+    const map = { nobody: (0, nobody_js_1.nobody)() };
+    for (const p of pairs) {
+        if (p.meta.name) {
+            map[p.meta.name] = p;
+        }
+    }
+    return map;
+}

package/build/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+export declare const DEV_SEED = "0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e";

package/build/defaults.js

@@ -0,0 +1,2 @@
+export const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
+export const DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';

package/build/index.d.ts

@@ -0,0 +1,4 @@
+import './packageDetect.js';
+import { Keyring } from './bundle.js';
+export * from './bundle.js';
+export default Keyring;

package/build/index.js

@@ -0,0 +1,4 @@
+import './packageDetect.js';
+import { Keyring } from './bundle.js';
+export * from './bundle.js';
+export default Keyring;

package/build/keyring.d.ts

@@ -0,0 +1,145 @@
+import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@pezkuwi/util-crypto/types';
+import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types.js';
+import { decodeAddress } from '@pezkuwi/util-crypto';
+/**
+ * # @pezkuwi/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.
+ */
+export declare class Keyring implements KeyringInstance {
+    #private;
+    decodeAddress: typeof decodeAddress;
+    constructor(options?: KeyringOptions);
+    /**
+     * @description retrieve the pairs (alias for getPairs)
+     */
+    get pairs(): KeyringPair[];
+    /**
+     * @description retrieve the publicKeys (alias for getPublicKeys)
+     */
+    get publicKeys(): Uint8Array[];
+    /**
+     * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
+     */
+    get type(): KeypairType;
+    /**
+     * @name addPair
+     * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
+     */
+    addPair(pair: KeyringPair): KeyringPair;
+    /**
+     * @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: string | Uint8Array, meta?: KeyringPair$Meta, encoded?: Uint8Array | null, type?: KeypairType, ignoreChecksum?: boolean, encType?: EncryptedJsonEncoding[]): KeyringPair;
+    /**
+     * @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: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
+    /**
+     * @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: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
+    /**
+     * @name addFromPair
+     * @summary Stores an account created from an explicit publicKey/secreteKey combination
+     */
+    addFromPair(pair: Keypair, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    /**
+     * @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: Uint8Array, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    /**
+     * @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: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
+    /**
+     * @name createFromJson
+     * @description Creates a pair from a JSON keyfile
+     */
+    createFromJson({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
+    /**
+     * @name createFromPair
+     * @summary Creates a pair from an explicit publicKey/secreteKey combination
+     */
+    createFromPair(pair: Keypair, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+    /**
+     * @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: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
+    /**
+     * @name encodeAddress
+     * @description Encodes the input into an ss58 representation
+     */
+    encodeAddress: (address: Uint8Array | string, ss58Format?: number) => string;
+    /**
+     * @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: string | Uint8Array): KeyringPair;
+    /**
+     * @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(): KeyringPair[];
+    /**
+     * @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(): Uint8Array[];
+    /**
+     * @name removePair
+     * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
+     */
+    removePair(address: string | Uint8Array): void;
+    /**
+     * @name setSS58Format;
+     * @description Sets the ss58 format for the keyring
+     */
+    setSS58Format(ss58: number): void;
+    /**
+     * @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: string | Uint8Array, passphrase?: string): KeyringPair$Json;
+}