@pezkuwi/keyring 14.0.23 → 14.0.25

package/build/keyring.js

@@ -1,257 +0,0 @@
-import { hexToU8a, isHex, stringToU8a } from '@pezkuwi/util';
-import { base64Decode, decodeAddress, ed25519PairFromSeed as ed25519FromSeed, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed, sr25519PairFromSeed as sr25519FromSeed } from '@pezkuwi/util-crypto';
-import { createPair } from './pair/index.js';
-import { DEV_PHRASE } from './defaults.js';
-import { Pairs } from './pairs.js';
-const PairFromSeed = {
-    ecdsa: (seed) => secp256k1FromSeed(seed),
-    ed25519: (seed) => ed25519FromSeed(seed),
-    ethereum: (seed) => secp256k1FromSeed(seed),
-    sr25519: (seed) => sr25519FromSeed(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.
- */
-export class Keyring {
-    #pairs;
-    #type;
-    #ss58;
-    decodeAddress = 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();
-        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(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(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 = isHex(address)
-            ? hexToU8a(address)
-            : this.decodeAddress(address, ignoreChecksum);
-        const decoded = isHex(encoded)
-            ? hexToU8a(encoded)
-            : base64Decode(encoded);
-        return createPair({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
-    }
-    /**
-     * @name createFromPair
-     * @summary Creates a pair from an explicit publicKey/secreteKey combination
-     */
-    createFromPair(pair, meta = {}, type = this.type) {
-        return createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
-    }
-    /**
-     * @name createFromUri
-     * @summary Creates a Keypair from an suri
-     * @description This creates a pair from the suri, but does not add it to the keyring
-     */
-    createFromUri(_suri, meta = {}, type = this.type, wordlist) {
-        // here we only aut-add the dev phrase if we have a hard-derived path
-        const suri = _suri.startsWith('//')
-            ? `${DEV_PHRASE}${_suri}`
-            : _suri;
-        const { derivePath, password, path, phrase } = keyExtractSuri(suri);
-        let seed;
-        const isPhraseHex = isHex(phrase, 256);
-        if (isPhraseHex) {
-            seed = hexToU8a(phrase);
-        }
-        else {
-            const parts = phrase.split(' ');
-            if ([12, 15, 18, 21, 24].includes(parts.length)) {
-                seed = type === 'ethereum'
-                    ? mnemonicToLegacySeed(phrase, '', false, 64)
-                    : 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 = 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
-                : hdEthereum(seed, derivePath.substring(1))
-            : keyFromPath(PairFromSeed[type](seed), path, type);
-        return 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'
-            ? ethereumEncode(address)
-            : 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);
-    }
-}

package/build/package.json

@@ -1,294 +0,0 @@
-{
-  "author": "Dijital Kurdistan Tech Institute <dev@pezkuwichain.io>",
-  "bugs": "https://github.com/pezkuwichain/pezkuwi-common/issues",
-  "description": "Keyring management",
-  "engines": {
-    "node": ">=18"
-  },
-  "homepage": "https://github.com/pezkuwichain/pezkuwi-common/tree/master/packages/keyring#readme",
-  "license": "Apache-2.0",
-  "name": "@pezkuwi/keyring",
-  "repository": {
-    "directory": "packages/keyring",
-    "type": "git",
-    "url": "https://github.com/pezkuwichain/pezkuwi-common.git"
-  },
-  "sideEffects": [
-    "./packageDetect.js",
-    "./cjs/packageDetect.js"
-  ],
-  "type": "module",
-  "version": "14.0.23",
-  "main": "./cjs/index.js",
-  "module": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
-  "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
-    ".": {
-      "module": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      },
-      "require": {
-        "types": "./cjs/index.d.ts",
-        "default": "./cjs/index.js"
-      },
-      "default": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
-    },
-    "./bundle": {
-      "module": {
-        "types": "./bundle.d.ts",
-        "default": "./bundle.js"
-      },
-      "require": {
-        "types": "./cjs/bundle.d.ts",
-        "default": "./cjs/bundle.js"
-      },
-      "default": {
-        "types": "./bundle.d.ts",
-        "default": "./bundle.js"
-      }
-    },
-    "./defaults": {
-      "module": {
-        "types": "./defaults.d.ts",
-        "default": "./defaults.js"
-      },
-      "require": {
-        "types": "./cjs/defaults.d.ts",
-        "default": "./cjs/defaults.js"
-      },
-      "default": {
-        "types": "./defaults.d.ts",
-        "default": "./defaults.js"
-      }
-    },
-    "./keyring": {
-      "module": {
-        "types": "./keyring.d.ts",
-        "default": "./keyring.js"
-      },
-      "require": {
-        "types": "./cjs/keyring.d.ts",
-        "default": "./cjs/keyring.js"
-      },
-      "default": {
-        "types": "./keyring.d.ts",
-        "default": "./keyring.js"
-      }
-    },
-    "./package.json": {
-      "require": "./cjs/package.json",
-      "default": "./package.json"
-    },
-    "./packageDetect": {
-      "module": {
-        "types": "./packageDetect.d.ts",
-        "default": "./packageDetect.js"
-      },
-      "require": {
-        "types": "./cjs/packageDetect.d.ts",
-        "default": "./cjs/packageDetect.js"
-      },
-      "default": {
-        "types": "./packageDetect.d.ts",
-        "default": "./packageDetect.js"
-      }
-    },
-    "./packageInfo.js": {
-      "module": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      },
-      "require": {
-        "types": "./cjs/packageInfo.d.ts",
-        "default": "./cjs/packageInfo.js"
-      },
-      "default": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      }
-    },
-    "./packageInfo": {
-      "module": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      },
-      "require": {
-        "types": "./cjs/packageInfo.d.ts",
-        "default": "./cjs/packageInfo.js"
-      },
-      "default": {
-        "types": "./packageInfo.d.ts",
-        "default": "./packageInfo.js"
-      }
-    },
-    "./pair": {
-      "module": {
-        "types": "./pair/index.d.ts",
-        "default": "./pair/index.js"
-      },
-      "require": {
-        "types": "./cjs/pair/index.d.ts",
-        "default": "./cjs/pair/index.js"
-      },
-      "default": {
-        "types": "./pair/index.d.ts",
-        "default": "./pair/index.js"
-      }
-    },
-    "./pair/decode": {
-      "module": {
-        "types": "./pair/decode.d.ts",
-        "default": "./pair/decode.js"
-      },
-      "require": {
-        "types": "./cjs/pair/decode.d.ts",
-        "default": "./cjs/pair/decode.js"
-      },
-      "default": {
-        "types": "./pair/decode.d.ts",
-        "default": "./pair/decode.js"
-      }
-    },
-    "./pair/defaults": {
-      "module": {
-        "types": "./pair/defaults.d.ts",
-        "default": "./pair/defaults.js"
-      },
-      "require": {
-        "types": "./cjs/pair/defaults.d.ts",
-        "default": "./cjs/pair/defaults.js"
-      },
-      "default": {
-        "types": "./pair/defaults.d.ts",
-        "default": "./pair/defaults.js"
-      }
-    },
-    "./pair/encode": {
-      "module": {
-        "types": "./pair/encode.d.ts",
-        "default": "./pair/encode.js"
-      },
-      "require": {
-        "types": "./cjs/pair/encode.d.ts",
-        "default": "./cjs/pair/encode.js"
-      },
-      "default": {
-        "types": "./pair/encode.d.ts",
-        "default": "./pair/encode.js"
-      }
-    },
-    "./pair/nobody": {
-      "module": {
-        "types": "./pair/nobody.d.ts",
-        "default": "./pair/nobody.js"
-      },
-      "require": {
-        "types": "./cjs/pair/nobody.d.ts",
-        "default": "./cjs/pair/nobody.js"
-      },
-      "default": {
-        "types": "./pair/nobody.d.ts",
-        "default": "./pair/nobody.js"
-      }
-    },
-    "./pair/toJson": {
-      "module": {
-        "types": "./pair/toJson.d.ts",
-        "default": "./pair/toJson.js"
-      },
-      "require": {
-        "types": "./cjs/pair/toJson.d.ts",
-        "default": "./cjs/pair/toJson.js"
-      },
-      "default": {
-        "types": "./pair/toJson.d.ts",
-        "default": "./pair/toJson.js"
-      }
-    },
-    "./pair/types": {
-      "module": {
-        "types": "./pair/types.d.ts",
-        "default": "./pair/types.js"
-      },
-      "require": {
-        "types": "./cjs/pair/types.d.ts",
-        "default": "./cjs/pair/types.js"
-      },
-      "default": {
-        "types": "./pair/types.d.ts",
-        "default": "./pair/types.js"
-      }
-    },
-    "./pairs": {
-      "module": {
-        "types": "./pairs.d.ts",
-        "default": "./pairs.js"
-      },
-      "require": {
-        "types": "./cjs/pairs.d.ts",
-        "default": "./cjs/pairs.js"
-      },
-      "default": {
-        "types": "./pairs.d.ts",
-        "default": "./pairs.js"
-      }
-    },
-    "./testing": {
-      "module": {
-        "types": "./testing.d.ts",
-        "default": "./testing.js"
-      },
-      "require": {
-        "types": "./cjs/testing.d.ts",
-        "default": "./cjs/testing.js"
-      },
-      "default": {
-        "types": "./testing.d.ts",
-        "default": "./testing.js"
-      }
-    },
-    "./testingPairs": {
-      "module": {
-        "types": "./testingPairs.d.ts",
-        "default": "./testingPairs.js"
-      },
-      "require": {
-        "types": "./cjs/testingPairs.d.ts",
-        "default": "./cjs/testingPairs.js"
-      },
-      "default": {
-        "types": "./testingPairs.d.ts",
-        "default": "./testingPairs.js"
-      }
-    },
-    "./types": {
-      "module": {
-        "types": "./types.d.ts",
-        "default": "./types.js"
-      },
-      "require": {
-        "types": "./cjs/types.d.ts",
-        "default": "./cjs/types.js"
-      },
-      "default": {
-        "types": "./types.d.ts",
-        "default": "./types.js"
-      }
-    }
-  },
-  "dependencies": {
-    "@pezkuwi/util": "14.0.23",
-    "@pezkuwi/util-crypto": "14.0.23",
-    "tslib": "^2.8.0"
-  },
-  "peerDependencies": {
-    "@pezkuwi/util": "14.0.23",
-    "@pezkuwi/util-crypto": "14.0.23"
-  }
-}

package/build/packageDetect.d.ts

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

package/build/packageDetect.js

@@ -1,5 +0,0 @@
-import { detectPackage } from '@pezkuwi/util';
-import { packageInfo as utilInfo } from '@pezkuwi/util/packageInfo';
-import { packageInfo as cryptoInfo } from '@pezkuwi/util-crypto/packageInfo';
-import { packageInfo } from './packageInfo.js';
-detectPackage(packageInfo, null, [cryptoInfo, utilInfo]);

package/build/packageInfo.d.ts

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

package/build/packageInfo.js

@@ -1 +0,0 @@
-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.23' };

package/build/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/pair/decode.js

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

package/build/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/pair/defaults.js

@@ -1,12 +0,0 @@
-/** public/secret section divider (generation 1-3, will change in 4, don't rely on value) */
-export const 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) */
-export const 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 */
-export const PUB_LENGTH = 32;
-/** length of a salt */
-export const SALT_LENGTH = 32;
-/** length of a secret key */
-export const SEC_LENGTH = 64;
-/** length of a user-input seed */
-export const SEED_LENGTH = 32;

package/build/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;