@pezkuwi/keyring 14.0.23 → 14.0.25

package/build-deno/pair/nobody.ts

@@ -1,58 +0,0 @@
-
-import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types.ts';
-
-const publicKey = new Uint8Array(32);
-
-const address = '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM';
-
-const meta = {
-  isTesting: true,
-  name: 'nobody'
-};
-
-const json: KeyringPair$Json = {
-  address,
-  encoded: '',
-  encoding: {
-    content: ['pkcs8', 'ed25519'],
-    type: 'none',
-    version: '0'
-  },
-  meta
-};
-
-const pair: KeyringPair = {
-  address,
-  addressRaw: publicKey,
-  decodePkcs8: (_passphrase?: string, _encoded?: Uint8Array): void =>
-    undefined,
-  derive: (_suri: string, _meta?: KeyringPair$Meta): KeyringPair =>
-    pair,
-  encodePkcs8: (_passphrase?: string): Uint8Array =>
-    new Uint8Array(0),
-  isLocked: true,
-  lock: (): void => {
-    // no locking, it is always locked
-  },
-  meta,
-  publicKey,
-  setMeta: (_meta: KeyringPair$Meta): void =>
-    undefined,
-  sign: (_message: Uint8Array): Uint8Array =>
-    new Uint8Array(64),
-  toJson: (_passphrase?: string): KeyringPair$Json =>
-    json,
-  type: 'ed25519',
-  unlock: (_passphrase?: string): void =>
-    undefined,
-  verify: (_message: Uint8Array, _signature: Uint8Array): boolean =>
-    false,
-  vrfSign: (_message: Uint8Array, _context?: string | Uint8Array, _extra?: string | Uint8Array): Uint8Array =>
-    new Uint8Array(96),
-  vrfVerify: (_message: Uint8Array, _vrfResult: Uint8Array, _context?: string | Uint8Array, _extra?: string | Uint8Array): boolean =>
-    false
-};
-
-export function nobody (): KeyringPair {
-  return pair;
-}

package/build-deno/pair/toJson.ts

@@ -1,18 +0,0 @@
-
-import type { KeypairType } from 'https://deno.land/x/pezkuwi/util-crypto/types.ts';
-import type { KeyringPair$Json, KeyringPair$Meta } from '../types.ts';
-
-import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { jsonEncryptFormat } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
-
-interface PairStateJson {
-  address: string;
-  meta: KeyringPair$Meta;
-}
-
-export function pairToJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
-  return objectSpread(jsonEncryptFormat(encoded, ['pkcs8', type], isEncrypted), {
-    address,
-    meta
-  });
-}

package/build-deno/pair/types.ts

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

package/build-deno/pairs.ts

@@ -1,39 +0,0 @@
-
-import type { KeyringPair, KeyringPairs } from './types.ts';
-
-import { isHex, isU8a, u8aToHex, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { decodeAddress } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
-
-type KeyringPairMap = Record<string, KeyringPair>;
-
-export class Pairs implements KeyringPairs {
-  readonly #map: KeyringPairMap = {};
-
-  public add (pair: KeyringPair): KeyringPair {
-    this.#map[decodeAddress(pair.address).toString()] = pair;
-
-    return pair;
-  }
-
-  public all (): KeyringPair[] {
-    return Object.values(this.#map);
-  }
-
-  public get (address: string | Uint8Array): KeyringPair {
-    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;
-  }
-
-  public remove (address: string | Uint8Array): void {
-    delete this.#map[decodeAddress(address).toString()];
-  }
-}

package/build-deno/testing.ts

@@ -1,150 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { KeypairType } from 'https://deno.land/x/pezkuwi/util-crypto/types.ts';
-import type { KeyringInstance, KeyringOptions } from './types.ts';
-
-import { hexToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { createPair } from './pair/index.ts';
-import { Keyring } from './keyring.ts';
-
-interface PairDef {
-  name?: string;
-  p: HexString;
-  s: HexString;
-  seed?: string;
-  type: KeypairType
-}
-
-export const PAIRSSR25519: PairDef[] = [
-  {
-    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'
-  }
-];
-
-export const PAIRSETHEREUM: PairDef[] = [
-  {
-    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?: string, seed?: string) {
-  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.
- */
-export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
-  const keyring = new Keyring(options);
-  const pairs = options.type === 'ethereum'
-    ? PAIRSETHEREUM
-    : 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(
-        createPair(
-          { toSS58: keyring.encodeAddress, type },
-          { publicKey: hexToU8a(p), secretKey: hexToU8a(s) },
-          meta
-        )
-      );
-
-    pair.lock = (): void => {
-      // we don't have lock/unlock functionality here
-    };
-  }
-
-  return keyring;
-}

package/build-deno/testingPairs.ts

@@ -1,54 +0,0 @@
-
-import type { KeypairType } from 'https://deno.land/x/pezkuwi/util-crypto/types.ts';
-import type { KeyringOptions, KeyringPair } from './types.ts';
-
-import { nobody } from './pair/nobody.ts';
-import { createTestKeyring } from './testing.ts';
-
-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 function createTestPairs <O extends KeyringOptions, M = DetectMap<O>> (options?: O, isDerived = true): M {
-  const keyring = createTestKeyring(options, isDerived);
-  const pairs = keyring.getPairs();
-  const map: TestKeyringMap = { nobody: nobody() };
-
-  for (const p of pairs) {
-    if (p.meta.name) {
-      map[p.meta.name] = p;
-    }
-  }
-
-  return map as M;
-}

package/build-deno/types.ts

@@ -1,129 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { EncryptedJson, Keypair, KeypairType, Prefix } from 'https://deno.land/x/pezkuwi/util-crypto/types.ts';
-
-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/bundle.d.ts

@@ -1,7 +0,0 @@
-export { decodeAddress, encodeAddress, setSS58Format } from '@pezkuwi/util-crypto';
-export { Keyring } from './keyring.js';
-export { packageInfo } from './packageInfo.js';
-export { createPair } from './pair/index.js';
-export { createTestKeyring } from './testing.js';
-export { createTestPairs } from './testingPairs.js';
-export * from './defaults.js';

package/build-tsc/defaults.d.ts

@@ -1,2 +0,0 @@
-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-tsc/index.d.ts

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

package/build-tsc/keyring.d.ts

@@ -1,145 +0,0 @@
-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;
-}

package/build-tsc/packageDetect.d.ts

@@ -1 +0,0 @@
-export {};

package/build-tsc/packageInfo.d.ts

@@ -1,6 +0,0 @@
-export declare const packageInfo: {
-    name: string;
-    path: string;
-    type: string;
-    version: string;
-};

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

@@ -1,12 +0,0 @@
-import type { EncryptedJsonEncoding } from '@pezkuwi/util-crypto/types';
-/**
- * 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.
- **/
-export declare function decodePair(passphrase?: string, encrypted?: Uint8Array | null, _encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[]): {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
-};

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

@@ -1,12 +0,0 @@
-/** public/secret section divider (generation 1-3, will change in 4, don't rely on value) */
-export declare const PAIR_DIV: Uint8Array<ArrayBuffer>;
-/** public/secret start block (generation 1-3, will change in 4, don't rely on value) */
-export declare const PAIR_HDR: Uint8Array<ArrayBuffer>;
-/** length of a public key */
-export declare const PUB_LENGTH = 32;
-/** length of a salt */
-export declare const SALT_LENGTH = 32;
-/** length of a secret key */
-export declare const SEC_LENGTH = 64;
-/** length of a user-input seed */
-export declare const SEED_LENGTH = 32;

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

@@ -1,5 +0,0 @@
-import type { PairInfo } from './types.js';
-/**
- * Encode a pair with the latest generation format (generation 3)
- **/
-export declare function encodePair({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array;