@pezkuwi/keyring 14.0.12 → 14.0.14

package/build-tsc/pair/index.d.ts

@@ -1,40 +0,0 @@
-import type { EncryptedJsonEncoding, KeypairType } from '@pezkuwi/util-crypto/types';
-import type { KeyringPair, KeyringPair$Meta } from '../types.js';
-import type { PairInfo } from './types.js';
-interface Setup {
-    toSS58: (publicKey: Uint8Array) => string;
-    type: KeypairType;
-}
-/**
- * @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.
- */
-export declare function createPair({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta?: KeyringPair$Meta, encoded?: Uint8Array | null, encTypes?: EncryptedJsonEncoding[]): KeyringPair;
-export {};

package/build-tsc/pair/nobody.d.ts

@@ -1,2 +0,0 @@
-import type { KeyringPair } from '../types.js';
-export declare function nobody(): KeyringPair;

package/build-tsc/pair/toJson.d.ts

@@ -1,8 +0,0 @@
-import type { KeypairType } from '@pezkuwi/util-crypto/types';
-import type { KeyringPair$Json, KeyringPair$Meta } from '../types.js';
-interface PairStateJson {
-    address: string;
-    meta: KeyringPair$Meta;
-}
-export declare function pairToJson(type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json;
-export {};

package/build-tsc/pair/types.d.ts

@@ -1,5 +0,0 @@
-export interface PairInfo {
-    publicKey: Uint8Array;
-    secretKey?: Uint8Array | undefined;
-    seed?: Uint8Array | null;
-}

package/build-tsc/pairs.d.ts

@@ -1,8 +0,0 @@
-import type { KeyringPair, KeyringPairs } from './types.js';
-export declare class Pairs implements KeyringPairs {
-    #private;
-    add(pair: KeyringPair): KeyringPair;
-    all(): KeyringPair[];
-    get(address: string | Uint8Array): KeyringPair;
-    remove(address: string | Uint8Array): void;
-}

package/build-tsc/testing.d.ts

@@ -1,20 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { KeypairType } from '@pezkuwi/util-crypto/types';
-import type { KeyringInstance, KeyringOptions } from './types.js';
-interface PairDef {
-    name?: string;
-    p: HexString;
-    s: HexString;
-    seed?: string;
-    type: KeypairType;
-}
-export declare const PAIRSSR25519: PairDef[];
-export declare const PAIRSETHEREUM: PairDef[];
-/**
- * @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.
- */
-export declare function createTestKeyring(options?: KeyringOptions, isDerived?: boolean): KeyringInstance;
-export {};

package/build-tsc/testingPairs.d.ts

@@ -1,25 +0,0 @@
-import type { KeypairType } from '@pezkuwi/util-crypto/types';
-import type { KeyringOptions, KeyringPair } from './types.js';
-export interface TestKeyringMap {
-    nobody: KeyringPair;
-    [index: string]: KeyringPair;
-}
-export interface TestKeyringMapBizinikiwi extends TestKeyringMap {
-    alice: KeyringPair;
-    bob: KeyringPair;
-    charlie: KeyringPair;
-    dave: KeyringPair;
-    eve: KeyringPair;
-    ferdie: KeyringPair;
-}
-export interface TestKeyringMapEthereum extends TestKeyringMap {
-    Alith: KeyringPair;
-    Baltathar: KeyringPair;
-    Charleth: KeyringPair;
-    Dorothy: KeyringPair;
-    Ethan: KeyringPair;
-    Faith: KeyringPair;
-}
-export type DetectMap<O extends KeyringOptions | undefined> = DetectPairType<O> extends 'ethereum' ? TestKeyringMapEthereum : TestKeyringMapBizinikiwi;
-export type DetectPairType<O extends KeyringOptions | undefined> = O extends KeyringOptions ? O['type'] extends KeypairType ? O['type'] : 'sr25519' : 'sr25519';
-export declare function createTestPairs<O extends KeyringOptions, M = DetectMap<O>>(options?: O, isDerived?: boolean): M;

package/build-tsc/types.d.ts

@@ -1,111 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { EncryptedJson, Keypair, KeypairType, Prefix } from '@pezkuwi/util-crypto/types';
-export interface KeyringOptions {
-    /** The ss58Format to use for address encoding (defaults to 42) */
-    ss58Format?: Prefix;
-    /** The type of keyring to create (defaults to ed25519) */
-    type?: KeypairType;
-}
-export interface KeyringPair$MetaHardware {
-    accountIndex?: number;
-    accountOffset?: number;
-    addressOffset?: number;
-    hardwareType?: 'ledger';
-}
-export interface KeyringPair$MetaFlags {
-    isDefaultAuthSelected?: boolean;
-    isExternal?: boolean;
-    isHardware?: boolean;
-    isHidden?: boolean;
-    isInjected?: boolean;
-    isMultisig?: boolean;
-    isProxied?: boolean;
-    isRecent?: boolean;
-    isTesting?: boolean;
-}
-export interface KeyringPair$MetaContract {
-    abi: string;
-    genesisHash?: HexString | null;
-}
-export interface KeyringPair$MetaExtension {
-    source?: string;
-}
-export interface KeyringPair$MetaMultisig {
-    threshold?: number;
-    who?: string[];
-}
-export interface KeyringPair$MetaParent {
-    parentAddress?: string;
-    parentName?: string;
-}
-export interface KeyringPair$Meta extends KeyringPair$MetaExtension, KeyringPair$MetaFlags, KeyringPair$MetaHardware, KeyringPair$MetaMultisig, KeyringPair$MetaParent {
-    address?: string;
-    contract?: KeyringPair$MetaContract;
-    genesisHash?: HexString | null;
-    name?: string;
-    suri?: string;
-    tags?: string[];
-    type?: KeypairType;
-    whenCreated?: number;
-    whenEdited?: number;
-    whenUsed?: number;
-    [key: string]: unknown;
-}
-export interface KeyringPair$Json extends EncryptedJson {
-    /** The ss58 encoded address or the hex-encoded version (the latter is for ETH-compat chains) */
-    address: string;
-    /** The underlying metadata associated with the keypair */
-    meta: KeyringPair$Meta;
-}
-export interface SignOptions {
-    /** Create a MultiSignature-compatible output with an indicator type */
-    withType?: boolean;
-}
-export interface KeyringPair {
-    readonly address: string;
-    readonly addressRaw: Uint8Array;
-    readonly meta: KeyringPair$Meta;
-    readonly isLocked: boolean;
-    readonly publicKey: Uint8Array;
-    readonly type: KeypairType;
-    decodePkcs8(passphrase?: string, encoded?: Uint8Array): void;
-    derive(suri: string, meta?: KeyringPair$Meta): KeyringPair;
-    encodePkcs8(passphrase?: string): Uint8Array;
-    lock(): void;
-    setMeta(meta: KeyringPair$Meta): void;
-    sign(message: string | Uint8Array, options?: SignOptions): Uint8Array;
-    toJson(passphrase?: string): KeyringPair$Json;
-    unlock(passphrase?: string): void;
-    verify(message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array): boolean;
-    vrfSign(message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
-    vrfVerify(message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
-}
-export interface KeyringPairs {
-    add: (pair: KeyringPair) => KeyringPair;
-    all: () => KeyringPair[];
-    get: (address: string | Uint8Array) => KeyringPair;
-    remove: (address: string | Uint8Array) => void;
-}
-export interface KeyringInstance {
-    readonly pairs: KeyringPair[];
-    readonly publicKeys: Uint8Array[];
-    readonly type: KeypairType;
-    decodeAddress(encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format?: Prefix): Uint8Array;
-    encodeAddress(key: Uint8Array | string, ss58Format?: Prefix): string;
-    setSS58Format(ss58Format: Prefix): void;
-    addPair(pair: KeyringPair): KeyringPair;
-    addFromAddress(address: string | Uint8Array, meta?: KeyringPair$Meta, encoded?: Uint8Array | null, type?: KeypairType, ignoreChecksum?: boolean): KeyringPair;
-    addFromJson(pair: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
-    addFromMnemonic(mnemonic: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
-    addFromPair(pair: Keypair, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
-    addFromSeed(seed: Uint8Array, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
-    addFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
-    createFromJson(json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
-    createFromPair(pair: Keypair, meta: KeyringPair$Meta, type: KeypairType): KeyringPair;
-    createFromUri(suri: string, meta?: KeyringPair$Meta, type?: KeypairType, wordlist?: string[]): KeyringPair;
-    getPair(address: string | Uint8Array): KeyringPair;
-    getPairs(): KeyringPair[];
-    getPublicKeys(): Uint8Array[];
-    removePair(address: string | Uint8Array): void;
-    toJson(address: string | Uint8Array, passphrase?: string): KeyringPair$Json;
-}

package/build-tsc-cjs/bundle.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTestPairs = exports.createTestKeyring = exports.createPair = exports.packageInfo = exports.Keyring = exports.setSS58Format = exports.encodeAddress = exports.decodeAddress = void 0;
-const tslib_1 = require("tslib");
-var util_crypto_1 = require("@pezkuwi/util-crypto");
-Object.defineProperty(exports, "decodeAddress", { enumerable: true, get: function () { return util_crypto_1.decodeAddress; } });
-Object.defineProperty(exports, "encodeAddress", { enumerable: true, get: function () { return util_crypto_1.encodeAddress; } });
-Object.defineProperty(exports, "setSS58Format", { enumerable: true, get: function () { return util_crypto_1.setSS58Format; } });
-var keyring_js_1 = require("./keyring.js");
-Object.defineProperty(exports, "Keyring", { enumerable: true, get: function () { return keyring_js_1.Keyring; } });
-var packageInfo_js_1 = require("./packageInfo.js");
-Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
-var index_js_1 = require("./pair/index.js");
-Object.defineProperty(exports, "createPair", { enumerable: true, get: function () { return index_js_1.createPair; } });
-var testing_js_1 = require("./testing.js");
-Object.defineProperty(exports, "createTestKeyring", { enumerable: true, get: function () { return testing_js_1.createTestKeyring; } });
-var testingPairs_js_1 = require("./testingPairs.js");
-Object.defineProperty(exports, "createTestPairs", { enumerable: true, get: function () { return testingPairs_js_1.createTestPairs; } });
-tslib_1.__exportStar(require("./defaults.js"), exports);

package/build-tsc-cjs/defaults.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEV_SEED = exports.DEV_PHRASE = void 0;
-exports.DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
-exports.DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';

package/build-tsc-cjs/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-require("./packageDetect.js");
-const bundle_js_1 = require("./bundle.js");
-tslib_1.__exportStar(require("./bundle.js"), exports);
-exports.default = bundle_js_1.Keyring;

package/build-tsc-cjs/keyring.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Keyring = void 0;
-const util_1 = require("@pezkuwi/util");
-const util_crypto_1 = require("@pezkuwi/util-crypto");
-const index_js_1 = require("./pair/index.js");
-const defaults_js_1 = require("./defaults.js");
-const pairs_js_1 = require("./pairs.js");
-const PairFromSeed = {
-    ecdsa: (seed) => (0, util_crypto_1.secp256k1PairFromSeed)(seed),
-    ed25519: (seed) => (0, util_crypto_1.ed25519PairFromSeed)(seed),
-    ethereum: (seed) => (0, util_crypto_1.secp256k1PairFromSeed)(seed),
-    sr25519: (seed) => (0, util_crypto_1.sr25519PairFromSeed)(seed)
-};
-function pairToPublic({ publicKey }) {
-    return publicKey;
-}
-/**
- * # @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.
- */
-class Keyring {
-    #pairs;
-    #type;
-    #ss58;
-    decodeAddress = util_crypto_1.decodeAddress;
-    constructor(options = {}) {
-        options.type = options.type || 'ed25519';
-        if (!['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined')) {
-            throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
-        }
-        this.#pairs = new pairs_js_1.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((0, index_js_1.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, wordlist) {
-        return this.addFromUri(mnemonic, meta, type, wordlist);
-    }
-    /**
-     * @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((0, index_js_1.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, wordlist) {
-        return this.addPair(this.createFromUri(suri, meta, type, wordlist));
-    }
-    /**
-     * @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];
-        const encType = !Array.isArray(type)
-            ? [type]
-            : type;
-        if (!['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType)) {
-            throw new Error(`Unknown crypto type ${cryptoType}`);
-        }
-        // Here the address and publicKey are 32 bytes and isomorphic. This is why the address field needs to be the public key for ethereum type pairs
-        const publicKey = (0, util_1.isHex)(address)
-            ? (0, util_1.hexToU8a)(address)
-            : this.decodeAddress(address, ignoreChecksum);
-        const decoded = (0, util_1.isHex)(encoded)
-            ? (0, util_1.hexToU8a)(encoded)
-            : (0, util_crypto_1.base64Decode)(encoded);
-        return (0, index_js_1.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 (0, index_js_1.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, wordlist) {
-        // here we only aut-add the dev phrase if we have a hard-derived path
-        const suri = _suri.startsWith('//')
-            ? `${defaults_js_1.DEV_PHRASE}${_suri}`
-            : _suri;
-        const { derivePath, password, path, phrase } = (0, util_crypto_1.keyExtractSuri)(suri);
-        let seed;
-        const isPhraseHex = (0, util_1.isHex)(phrase, 256);
-        if (isPhraseHex) {
-            seed = (0, util_1.hexToU8a)(phrase);
-        }
-        else {
-            const parts = phrase.split(' ');
-            if ([12, 15, 18, 21, 24].includes(parts.length)) {
-                seed = type === 'ethereum'
-                    ? (0, util_crypto_1.mnemonicToLegacySeed)(phrase, '', false, 64)
-                    : (0, util_crypto_1.mnemonicToMiniSecret)(phrase, password, wordlist);
-            }
-            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, util_1.stringToU8a)(phrase.padEnd(32));
-            }
-        }
-        const derived = type === 'ethereum'
-            ? isPhraseHex
-                ? PairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
-                : (0, util_crypto_1.hdEthereum)(seed, derivePath.substring(1))
-            : (0, util_crypto_1.keyFromPath)(PairFromSeed[type](seed), path, type);
-        return (0, index_js_1.createPair)({ toSS58: this.encodeAddress, type }, derived, meta, null);
-    }
-    /**
-     * @name encodeAddress
-     * @description Encodes the input into an ss58 representation
-     */
-    encodeAddress = (address, ss58Format) => {
-        return this.type === 'ethereum'
-            ? (0, util_crypto_1.ethereumEncode)(address)
-            : (0, util_crypto_1.encodeAddress)(address, ss58Format ?? this.#ss58);
-    };
-    /**
-     * @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);
-    }
-}
-exports.Keyring = Keyring;

package/build-tsc-cjs/packageDetect.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("@pezkuwi/util");
-const packageInfo_1 = require("@pezkuwi/util/packageInfo");
-const packageInfo_2 = require("@pezkuwi/util-crypto/packageInfo");
-const packageInfo_js_1 = require("./packageInfo.js");
-(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_2.packageInfo, packageInfo_1.packageInfo]);

package/build-tsc-cjs/packageInfo.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/keyring', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.12' };

package/build-tsc-cjs/pair/decode.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodePair = decodePair;
-const util_1 = require("@pezkuwi/util");
-const util_crypto_1 = require("@pezkuwi/util-crypto");
-const defaults_js_1 = require("./defaults.js");
-const SEED_OFFSET = defaults_js_1.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 === undefined
-        ? _encType
-        : [_encType];
-    const decrypted = (0, util_crypto_1.jsonDecryptData)(encrypted, passphrase, encType);
-    const header = decrypted.subarray(0, defaults_js_1.PAIR_HDR.length);
-    // check the start header (generations 1-3)
-    if (!(0, util_1.u8aEq)(header, defaults_js_1.PAIR_HDR)) {
-        throw new Error('Invalid encoding header found in body');
-    }
-    // setup for generation 3 format
-    let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + defaults_js_1.SEC_LENGTH);
-    let divOffset = SEED_OFFSET + defaults_js_1.SEC_LENGTH;
-    let divider = decrypted.subarray(divOffset, divOffset + defaults_js_1.PAIR_DIV.length);
-    // old-style (generation 1 & 2), we have the seed here
-    if (!(0, util_1.u8aEq)(divider, defaults_js_1.PAIR_DIV)) {
-        divOffset = SEED_OFFSET + defaults_js_1.SEED_LENGTH;
-        secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
-        divider = decrypted.subarray(divOffset, divOffset + defaults_js_1.PAIR_DIV.length);
-        // check the divisior at this point (already checked for generation 3)
-        if (!(0, util_1.u8aEq)(divider, defaults_js_1.PAIR_DIV)) {
-            throw new Error('Invalid encoding divider found in body');
-        }
-    }
-    const pubOffset = divOffset + defaults_js_1.PAIR_DIV.length;
-    const publicKey = decrypted.subarray(pubOffset, pubOffset + defaults_js_1.PUB_LENGTH);
-    return {
-        publicKey,
-        secretKey
-    };
-}

package/build-tsc-cjs/pair/defaults.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEED_LENGTH = exports.SEC_LENGTH = exports.SALT_LENGTH = exports.PUB_LENGTH = exports.PAIR_HDR = exports.PAIR_DIV = void 0;
-/** public/secret section divider (generation 1-3, will change in 4, don't rely on value) */
-exports.PAIR_DIV = new Uint8Array([161, 35, 3, 33, 0]);
-/** public/secret start block (generation 1-3, will change in 4, don't rely on value) */
-exports.PAIR_HDR = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
-/** length of a public key */
-exports.PUB_LENGTH = 32;
-/** length of a salt */
-exports.SALT_LENGTH = 32;
-/** length of a secret key */
-exports.SEC_LENGTH = 64;
-/** length of a user-input seed */
-exports.SEED_LENGTH = 32;

package/build-tsc-cjs/pair/encode.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodePair = encodePair;
-const util_1 = require("@pezkuwi/util");
-const util_crypto_1 = require("@pezkuwi/util-crypto");
-const defaults_js_1 = require("./defaults.js");
-/**
- * Encode a pair with the latest generation format (generation 3)
- **/
-function encodePair({ publicKey, secretKey }, passphrase) {
-    if (!secretKey) {
-        throw new Error('Expected a valid secretKey to be passed to encode');
-    }
-    const encoded = (0, util_1.u8aConcat)(defaults_js_1.PAIR_HDR, secretKey, defaults_js_1.PAIR_DIV, publicKey);
-    if (!passphrase) {
-        return encoded;
-    }
-    // this is only for generation 3 (previous generations are only handled in decoding)
-    const { params, password, salt } = (0, util_crypto_1.scryptEncode)(passphrase);
-    const { encrypted, nonce } = (0, util_crypto_1.naclEncrypt)(encoded, password.subarray(0, 32));
-    return (0, util_1.u8aConcat)((0, util_crypto_1.scryptToU8a)(salt, params), nonce, encrypted);
-}