@pezkuwi/util-crypto 14.0.22 → 14.0.23

package/build-tsc/ed25519/pair/fromString.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromString
+ * @summary Creates a new public/secret keypair from a string.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromString } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromString(value: string): Keypair;

package/build-tsc/ed25519/sign.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../types.js';
+/**
+ * @name ed25519Sign
+ * @summary Signs a message using the supplied secretKey
+ * @description
+ * Returns message signature of `message`, using the `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Sign } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Sign([...], [...]); // => [...]
+ * ```
+ */
+export declare function ed25519Sign(message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array;

package/build-tsc/ed25519/verify.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name ed25519Sign
+ * @summary Verifies the signature on the supplied message.
+ * @description
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Verify } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Verify([...], [...], [...]); // => true/false
+ * ```
+ */
+export declare function ed25519Verify(message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, onlyJs?: boolean): boolean;

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

@@ -0,0 +1,2 @@
+import type { HexString } from '@pezkuwi/util/types';
+export declare function ethereumEncode(addressOrPublic?: string | Uint8Array): HexString;

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

@@ -0,0 +1,3 @@
+export { ethereumEncode } from './encode.js';
+export { isEthereumAddress } from './isAddress.js';
+export { isEthereumChecksum } from './isChecksum.js';

package/build-tsc/ethereum/isAddress.d.ts

@@ -0,0 +1 @@
+export declare function isEthereumAddress(address?: string): boolean;

package/build-tsc/ethereum/isChecksum.d.ts

@@ -0,0 +1 @@
+export declare function isEthereumChecksum(_address: string): boolean;

package/build-tsc/hd/ethereum/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdEthereum(seed: Uint8Array, path?: string): Keypair;

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

@@ -0,0 +1,3 @@
+export { hdEthereum } from './ethereum/index.js';
+export { hdLedger } from './ledger/index.js';
+export { hdValidatePath } from './validatePath.js';

package/build-tsc/hd/ledger/derivePrivate.d.ts

@@ -0,0 +1 @@
+export declare function ledgerDerivePrivate(xprv: Uint8Array, index: number): Uint8Array;

package/build-tsc/hd/ledger/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdLedger(_mnemonic: string, path: string): Keypair;

package/build-tsc/hd/ledger/master.d.ts

@@ -0,0 +1 @@
+export declare function ledgerMaster(mnemonic: string, password?: string): Uint8Array;

package/build-tsc/hd/validatePath.d.ts

@@ -0,0 +1,2 @@
+export declare const HARDENED = 2147483648;
+export declare function hdValidatePath(path: string): boolean;

package/build-tsc/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '@pezkuwi/util/types';
+export type { HexString } from '@pezkuwi/util/types';
+interface DualHash {
+    256: (u8a: Uint8Array) => Uint8Array;
+    512: (u8a: Uint8Array) => Uint8Array;
+}
+/** @internal */
+export declare function createAsHex<T extends (...args: never[]) => Uint8Array>(fn: T): (...args: Parameters<T>) => HexString;
+/** @internal */
+export declare function createBitHasher(bitLength: 256 | 512, fn: (data: string | Uint8Array, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/** @internal */
+export declare function createDualHasher(wa: DualHash, js: DualHash): (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;

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

@@ -0,0 +1 @@
+export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

package/build-tsc/hmac/shaAsU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+export declare function hmacShaAsU8a(key: Uint8Array | string, data: Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean): Uint8Array;
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+export declare const hmacSha256AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+export declare const hmacSha512AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;

package/build-tsc/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build-tsc/json/constants.d.ts

@@ -0,0 +1,6 @@
+import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.js';
+export declare const ENCODING: EncryptedJsonEncoding[];
+export declare const ENCODING_NONE: EncryptedJsonEncoding[];
+export declare const ENCODING_VERSION: EncryptedJsonVersion;
+export declare const NONCE_LENGTH = 24;
+export declare const SCRYPT_LENGTH: number;

package/build-tsc/json/decrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonDecrypt({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array;

package/build-tsc/json/decryptData.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJsonEncoding } from './types.js';
+export declare function jsonDecryptData(encrypted?: Uint8Array | null, passphrase?: string | null, encType?: EncryptedJsonEncoding[]): Uint8Array;

package/build-tsc/json/encrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncrypt(data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson;

package/build-tsc/json/encryptFormat.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncryptFormat(encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson;

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

@@ -0,0 +1,4 @@
+export { jsonDecrypt } from './decrypt.js';
+export { jsonDecryptData } from './decryptData.js';
+export { jsonEncrypt } from './encrypt.js';
+export { jsonEncryptFormat } from './encryptFormat.js';

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

@@ -0,0 +1,16 @@
+export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
+export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
+export interface EncryptedJsonDescriptor {
+    /** Descriptor for the content */
+    content: string[];
+    /** The encoding (in current/latest versions this is always an array) */
+    type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
+    /** The version of encoding applied */
+    version: EncryptedJsonVersion;
+}
+export interface EncryptedJson {
+    /** The encoded string */
+    encoded: string;
+    /** The encoding used */
+    encoding: EncryptedJsonDescriptor;
+}

package/build-tsc/keccak/asU8a.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @name keccakAsU8a
+ * @summary Creates a keccak Uint8Array from the input.
+ * @description
+ * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { keccakAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * keccakAsU8a('123'); // => Uint8Array
+ * ```
+ */
+export declare const keccakAsU8a: (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+export declare const keccak256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+export declare const keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+export declare const keccakAsHex: (value: string | Uint8Array<ArrayBufferLike>, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

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

@@ -0,0 +1,4 @@
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/build-tsc/key/DeriveJunction.d.ts

@@ -0,0 +1,12 @@
+import { BN } from '@pezkuwi/util';
+export declare class DeriveJunction {
+    #private;
+    static from(value: string): DeriveJunction;
+    get chainCode(): Uint8Array;
+    get isHard(): boolean;
+    get isSoft(): boolean;
+    hard(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    harden(): DeriveJunction;
+    soft(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    soften(): DeriveJunction;
+}

package/build-tsc/key/extractPath.d.ts

@@ -0,0 +1,9 @@
+import { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    parts: string[] | null;
+    path: DeriveJunction[];
+}
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+export declare function keyExtractPath(derivePath: string): ExtractResult;

package/build-tsc/key/extractSuri.d.ts

@@ -0,0 +1,11 @@
+import type { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    derivePath: string;
+    password?: string;
+    path: DeriveJunction[];
+    phrase: string;
+}
+/**
+ * @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).
+ */
+export declare function keyExtractSuri(suri: string): ExtractResult;

package/build-tsc/key/fromPath.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair, KeypairType } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyFromPath(pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair;

package/build-tsc/key/hdkdDerive.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function createSeedDeriveFn(fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair;

package/build-tsc/key/hdkdEcdsa.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEcdsa: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/build-tsc/key/hdkdEd25519.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEd25519: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/build-tsc/key/hdkdSr25519.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyHdkdSr25519(keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair;

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

@@ -0,0 +1,9 @@
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+export { keyExtractPath } from './extractPath.js';
+export { keyExtractSuri } from './extractSuri.js';
+export { keyFromPath } from './fromPath.js';
+export { keyHdkdEcdsa } from './hdkdEcdsa.js';
+export { keyHdkdEd25519 } from './hdkdEd25519.js';
+export { keyHdkdSr25519 } from './hdkdSr25519.js';

package/build-tsc/mnemonic/bip39.d.ts

@@ -0,0 +1,5 @@
+export declare function mnemonicToSeedSync(mnemonic: string, password?: string): Uint8Array;
+export declare function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): Uint8Array;
+export declare function entropyToMnemonic(entropy: Uint8Array, wordlist?: string[]): string;
+export declare function generateMnemonic(numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string;
+export declare function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;

package/build-tsc/mnemonic/generate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name mnemonicGenerate
+ * @summary Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * ```
+ */
+export declare function mnemonicGenerate(numWords?: 12 | 15 | 18 | 21 | 24, wordlist?: string[], onlyJs?: boolean): string;

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

@@ -0,0 +1,8 @@
+/**
+ * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
+ */
+export { mnemonicGenerate } from './generate.js';
+export { mnemonicToEntropy } from './toEntropy.js';
+export { mnemonicToLegacySeed } from './toLegacySeed.js';
+export { mnemonicToMiniSecret } from './toMiniSecret.js';
+export { mnemonicValidate } from './validate.js';

package/build-tsc/mnemonic/toEntropy.d.ts

@@ -0,0 +1 @@
+export declare function mnemonicToEntropy(mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array;

package/build-tsc/mnemonic/toLegacySeed.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @name mnemonicToLegacySeed
+ * @summary Creates a valid Ethereum/Bitcoin-compatible seed from a mnemonic input
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicToLegacySeed, mnemonicValidate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ *
+ * if (isValidMnemonic) {
+ *   console.log(`Seed generated from mnemonic: ${mnemonicToLegacySeed(mnemonic)}`); => u8a
+ * }
+ * ```
+ */
+export declare function mnemonicToLegacySeed(mnemonic: string, password?: string, onlyJs?: boolean, byteLength?: 32 | 64): Uint8Array;

package/build-tsc/mnemonic/toMiniSecret.d.ts

@@ -0,0 +1 @@
+export declare function mnemonicToMiniSecret(mnemonic: string, password?: string, wordlist?: string[], onlyJs?: boolean): Uint8Array;

package/build-tsc/mnemonic/validate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @name mnemonicValidate
+ * @summary Validates a mnemonic input using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicValidate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ * ```
+ */
+export declare function mnemonicValidate(mnemonic: string, wordlist?: string[], onlyJs?: boolean): boolean;

package/build-tsc/mnemonic/wordlists/en.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/es.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/fr.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/index.d.ts

@@ -0,0 +1,8 @@
+export { default as english } from './en.js';
+export { default as spanish } from './es.js';
+export { default as french } from './fr.js';
+export { default as italian } from './it.js';
+export { default as japanese } from './jp.js';
+export { default as korean } from './ko.js';
+export { default as chineseSimplified } from './zh-s.js';
+export { default as chineseTraditional } from './zh-t.js';

package/build-tsc/mnemonic/wordlists/it.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/jp.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/ko.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/zh-s.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/mnemonic/wordlists/zh-t.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/build-tsc/nacl/decrypt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name naclDecrypt
+ * @summary Decrypts a message using the supplied secretKey and nonce
+ * @description
+ * Returns an decrypted message, using the `secret` and `nonce`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { naclDecrypt } from '@pezkuwi/util-crypto';
+ *
+ * naclDecrypt([...], [...], [...]); // => [...]
+ * ```
+ */
+export declare function naclDecrypt(encrypted: Uint8Array, nonce: Uint8Array, secret: Uint8Array): Uint8Array | null;

package/build-tsc/nacl/encrypt.d.ts

@@ -0,0 +1,20 @@
+interface Encrypted {
+    encrypted: Uint8Array;
+    nonce: Uint8Array;
+}
+/**
+ * @name naclEncrypt
+ * @summary Encrypts a message using the supplied secretKey and nonce
+ * @description
+ * Returns an encrypted message, using the `secretKey` and `nonce`. If the `nonce` was not supplied, a random value is generated.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { naclEncrypt } from '@pezkuwi/util-crypto';
+ *
+ * naclEncrypt([...], [...]); // => [...]
+ * ```
+ */
+export declare function naclEncrypt(message: Uint8Array, secret: Uint8Array, nonce?: Uint8Array): Encrypted;
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * @summary Implements [NaCl](http://nacl.cr.yp.to/) secret-key authenticated encryption, public-key authenticated encryption
+ */
+export { naclDecrypt } from './decrypt.js';
+export { naclEncrypt } from './encrypt.js';

package/build-tsc/nacl/tweetnacl.d.ts

@@ -0,0 +1,2 @@
+export declare function naclSecretbox(msg: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array;
+export declare function naclSecretboxOpen(box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array | null;

package/build-tsc/networks.d.ts

@@ -0,0 +1 @@
+export { allNetworks, availableNetworks, selectableNetworks } from '@pezkuwi/networks';

package/build-tsc/packageDetect.d.ts

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

package/build-tsc/packageInfo.d.ts

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

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

@@ -0,0 +1,7 @@
+interface Result {
+    password: Uint8Array;
+    rounds: number;
+    salt: Uint8Array;
+}
+export declare function pbkdf2Encode(passphrase?: string | Uint8Array, salt?: Uint8Array, rounds?: number, onlyJs?: boolean): Result;
+export {};

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

@@ -0,0 +1 @@
+export { pbkdf2Encode } from './encode.js';

package/build-tsc/random/asNumber.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name randomAsNumber
+ * @summary Creates a random number from random bytes.
+ * @description
+ * Returns a random number generated from the secure bytes.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { randomAsNumber } from '@pezkuwi/util-crypto';
+ *
+ * randomAsNumber(); // => <random number>
+ * ```
+ */
+export declare function randomAsNumber(): number;

package/build-tsc/random/asU8a.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @name randomAsU8a
+ * @summary Creates a Uint8Array filled with random bytes.
+ * @description
+ * Returns a `Uint8Array` with the specified (optional) length filled with random bytes.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { randomAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * randomAsU8a(); // => Uint8Array([...])
+ * ```
+ */
+export declare function randomAsU8a(length?: number): Uint8Array;
+/**
+ * @name randomAsHex
+ * @description Creates a hex string filled with random bytes.
+ */
+export declare const randomAsHex: (length?: number | undefined) => import("@pezkuwi/util/types").HexString;

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

@@ -0,0 +1,5 @@
+/**
+ * @summary Returns a sequence of secure random bytes in a variety of formats
+ */
+export { randomAsNumber } from './asNumber.js';
+export { randomAsHex, randomAsU8a } from './asU8a.js';

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

@@ -0,0 +1,3 @@
+import type { ScryptParams } from './types.js';
+export declare const ALLOWED_PARAMS: ScryptParams[];
+export declare const DEFAULT_PARAMS: ScryptParams;

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

@@ -0,0 +1,8 @@
+import type { ScryptParams } from './types.js';
+interface Result {
+    params: ScryptParams;
+    password: Uint8Array;
+    salt: Uint8Array;
+}
+export declare function scryptEncode(passphrase?: string | Uint8Array, salt?: Uint8Array<ArrayBufferLike>, params?: ScryptParams, onlyJs?: boolean): Result;
+export {};

package/build-tsc/scrypt/fromU8a.d.ts

@@ -0,0 +1,7 @@
+import type { ScryptParams } from './types.js';
+interface Result {
+    params: ScryptParams;
+    salt: Uint8Array;
+}
+export declare function scryptFromU8a(data: Uint8Array): Result;
+export {};

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

@@ -0,0 +1,3 @@
+export { scryptEncode } from './encode.js';
+export { scryptFromU8a } from './fromU8a.js';
+export { scryptToU8a } from './toU8a.js';

package/build-tsc/scrypt/toU8a.d.ts

@@ -0,0 +1,2 @@
+import type { ScryptParams } from './types.js';
+export declare function scryptToU8a(salt: Uint8Array, { N, p, r }: ScryptParams): Uint8Array;

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

@@ -0,0 +1,6 @@
+/** The params that control scrypt generation */
+export interface ScryptParams {
+    N: number;
+    p: number;
+    r: number;
+}

package/build-tsc/secp256k1/compress.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1Compress(publicKey: Uint8Array, onlyJs?: boolean): Uint8Array;

package/build-tsc/secp256k1/deriveHard.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1DeriveHard(seed: Uint8Array, chainCode: Uint8Array): Uint8Array;

package/build-tsc/secp256k1/expand.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1Expand(publicKey: Uint8Array, onlyJs?: boolean): Uint8Array;

package/build-tsc/secp256k1/hasher.d.ts

@@ -0,0 +1,2 @@
+import type { HashType } from './types.js';
+export declare function hasher(hashType: HashType, data: Uint8Array | string, onlyJs?: boolean): Uint8Array;

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

@@ -0,0 +1,7 @@
+export { secp256k1Compress } from './compress.js';
+export { secp256k1Expand } from './expand.js';
+export { secp256k1PairFromSeed } from './pair/fromSeed.js';
+export { secp256k1Recover } from './recover.js';
+export { secp256k1Sign } from './sign.js';
+export { secp256k1PrivateKeyTweakAdd } from './tweakAdd.js';
+export { secp256k1Verify } from './verify.js';

package/build-tsc/secp256k1/pair/fromSeed.d.ts

@@ -0,0 +1,6 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name secp256k1PairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+export declare function secp256k1PairFromSeed(seed: Uint8Array, onlyJs?: boolean): Keypair;

package/build-tsc/secp256k1/recover.d.ts

@@ -0,0 +1,6 @@
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Recover
+ * @description Recovers a publicKey from the supplied signature
+ */
+export declare function secp256k1Recover(msgHash: string | Uint8Array, signature: string | Uint8Array, recovery: number, hashType?: HashType, onlyJs?: boolean): Uint8Array;

package/build-tsc/secp256k1/sign.d.ts

@@ -0,0 +1,7 @@
+import type { Keypair } from '../types.js';
+import type { HashType } from './types.js';
+/**
+ * @name secp256k1Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+export declare function secp256k1Sign(message: Uint8Array | string, { secretKey }: Partial<Keypair>, hashType?: HashType, onlyJs?: boolean): Uint8Array;

package/build-tsc/secp256k1/tweakAdd.d.ts

@@ -0,0 +1 @@
+export declare function secp256k1PrivateKeyTweakAdd(seckey: Uint8Array, tweak: Uint8Array, onlyBn?: boolean): Uint8Array;