@pezkuwi/keyring 14.0.7 → 14.0.10

package/build-deno/pair/nobody.ts

@@ -0,0 +1,58 @@
+
+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

@@ -0,0 +1,18 @@
+
+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

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

package/build-deno/pairs.ts

@@ -0,0 +1,39 @@
+
+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

@@ -0,0 +1,150 @@
+
+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

@@ -0,0 +1,54 @@
+
+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

@@ -0,0 +1,129 @@
+
+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-cjs/packageDetect.js

@@ -0,0 +1,7 @@
+"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/{cjs → build-tsc-cjs}/packageInfo.js

@@ -1,4 +1,4 @@
 "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.6' };
+exports.packageInfo = { name: '@pezkuwi/keyring', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.10' };

package/{packageInfo.js → build-tsc-esm/packageInfo.js}

@@ -1 +1 @@
-export const packageInfo = { name: '@pezkuwi/keyring', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.6' };
+export const packageInfo = { name: '@pezkuwi/keyring', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.10' };