@gibme/crypto-browser 7.0.2

package/dist/types/index.d.ts

@@ -0,0 +1,806 @@
+import { crypto_borromean_signature_t, crypto_bulletproof_plus_t, crypto_bulletproof_t, crypto_clsag_signature_t, crypto_entropy_t, crypto_triptych_signature_t, key_pair_t, Language, ICryptoLibrary, LibraryType, ModuleSettings } from './types';
+export * from './types';
+export * from './helpers';
+/**
+ * @ignore
+ */
+export declare abstract class CryptoModule {
+    private static _external_library;
+    protected static runtime_configuration: ModuleSettings;
+    /**
+     * We cannot create a new instance using this method as we need to await the
+     * loading of an underlying module, hence, we need to await the static
+     * init() method on this class to receive an instance of the class
+     *
+     * @protected
+     */
+    protected constructor();
+    /**
+     * Gets the external library calls that replace our cryptographic method calls
+     */
+    static get external_library(): Partial<ICryptoLibrary>;
+    /**
+     * Sets external library calls that replace our cryptographic method calls
+     *
+     * @param config
+     */
+    static set external_library(config: Partial<ICryptoLibrary>);
+    /**
+     * Returns the underlying cryptographic library name
+     */
+    static get library_name(): string;
+    /**
+     * Returns the underlying cryptographic library type
+     */
+    static get library_type(): LibraryType;
+    /**
+     * Returns if the underlying cryptographic library is of the
+     * Node.js C++ Addon type
+     */
+    static get is_native(): boolean;
+    /**
+     * Sets external library calls that replace our cryptographic method calls
+     *
+     * @param config
+     */
+    set external_library(config: Partial<ICryptoLibrary>);
+    /**
+     * Gets the external library calls that replace our cryptographic method calls
+     */
+    get external_library(): Partial<ICryptoLibrary>;
+    /**
+     * Returns the underlying cryptographic library name
+     */
+    get library_name(): string;
+    /**
+     * Returns the underlying cryptographic library type
+     */
+    get library_type(): LibraryType;
+    /**
+     * Returns if the underlying cryptographic library is of the
+     * Node.js C++ Addon type
+     */
+    get is_native(): boolean;
+    /**
+     * Encodes an address into Base58
+     *
+     * @param prefix
+     * @param public_spend
+     * @param public_view
+     */
+    base58_address_encode(prefix: number, public_spend: string, public_view?: string): Promise<string>;
+    /**
+     * Encodes an address into CryptoNote Base58
+     *
+     * @param prefix
+     * @param public_spend
+     * @param public_view
+     */
+    cn_base58_address_encode(prefix: number, public_spend: string, public_view?: string): Promise<string>;
+    /**
+     * Decodes an address from Base58
+     *
+     * @param base58
+     */
+    base58_address_decode(base58: string): Promise<{
+        prefix: number;
+        public_spend: string;
+        public_view?: string;
+    }>;
+    /**
+     * Decodes an address from CryptoNote Base58
+     *
+     * @param base58
+     */
+    cn_base58_address_decode(base58: string): Promise<{
+        prefix: number;
+        public_spend: string;
+        public_view?: string;
+    }>;
+    /**
+     * Generates a random entropy value
+     *
+     * @param entropy
+     * @param bits
+     * @param encode_timestamp
+     */
+    random_entropy(entropy?: string, bits?: 128 | 256, encode_timestamp?: boolean): Promise<crypto_entropy_t>;
+    /**
+     * Generates a random hash value
+     */
+    random_hash(): Promise<string>;
+    /**
+     * Generates a list of random hashes
+     *
+     * @param count
+     */
+    random_hashes(count?: number): Promise<string[]>;
+    /**
+     * Generates a random ED25519 scalar value
+     */
+    random_scalar(): Promise<string>;
+    /**
+     * Generates a list of random ED25519 scalars
+     *
+     * @param count
+     */
+    random_scalars(count?: number): Promise<string[]>;
+    /**
+     * Generates a random ED25519 point value
+     */
+    random_point(): Promise<string>;
+    /**
+     * Generates a list of random ED25519 points
+     *
+     * @param count
+     */
+    random_points(count?: number): Promise<string[]>;
+    /**
+     * Hashes the input data using sha256 and returns the resulting hash value
+     *
+     * @param input
+     */
+    sha256(input: any): Promise<string>;
+    /**
+     * Hashes the input data using sha384 and returns the resulting hash value
+     *
+     * @param input
+     */
+    sha384(input: any): Promise<string>;
+    /**
+     * Hashes the input data using sha512 and returns the resulting hash value
+     *
+     * @param input
+     */
+    sha512(input: any): Promise<string>;
+    /**
+     * Hashes the input data using sha3 and returns the resulting hash value
+     *
+     * @param input
+     */
+    sha3(input: any): Promise<string>;
+    /**
+     * Hashes the input data using a simple SHA3 KDF function and returns
+     * the resulting hash value
+     *
+     * @param input
+     * @param iterations
+     */
+    sha3_slow(input: string, iterations?: number): Promise<string>;
+    /**
+     * Hashes the input data using Blake2b and returns the resulting
+     * hash value
+     *
+     * @param input
+     */
+    blake2b(input: any): Promise<string>;
+    /**
+     * Hashes the input data using Argon2i and returns the resulting hash value
+     *
+     * @param input
+     * @param iterations
+     * @param memory
+     * @param threads
+     */
+    argon2i(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
+    /**
+     * Hashes the input data using Argon2d and returns the resulting hash value
+     *
+     * @param input
+     * @param iterations
+     * @param memory
+     * @param threads
+     */
+    argon2d(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
+    /**
+     * Hashes the input data using Argon2id and returns the resulting hash value
+     *
+     * @param input
+     * @param iterations
+     * @param memory
+     * @param threads
+     */
+    argon2id(input: any, iterations?: number, memory?: number, threads?: number): Promise<string>;
+    /**
+     * Recovers entropy from a mnemonic phrase or a list of mnemonic phrase words
+     *
+     * @param mnenomic_phrase
+     * @param language
+     */
+    entropy_recover(mnenomic_phrase: string | string[], language?: Language): Promise<crypto_entropy_t>;
+    /**
+     * Generates a key derivation
+     *
+     * Note: D = (a * B) mod l
+     *
+     * @param public_key
+     * @param secret_key
+     */
+    generate_derivation(public_key: string, secret_key: string): Promise<string>;
+    /**
+     * Generates a key derivation scalar value
+     *
+     * Note: Ds = H(D || output_index) mod l
+     *
+     * @param derivation
+     * @param output_index
+     */
+    generate_derivation_scalar(derivation: string, output_index?: number): Promise<string>;
+    /**
+     * Derives a public ephemeral from a derivation scalar and a public key
+     *
+     * Note: P = [(Ds * G) + B] mod l
+     *
+     * @param derivation_scalar
+     * @param public_key
+     */
+    derive_public_key(derivation_scalar: string, public_key: string): Promise<string>;
+    /**
+     * Derives a secret ephemeral from a derivation scalar and a secret key
+     *
+     * Note: p = (Ds + b) mod l
+     *
+     * @param derivation_scalar
+     * @param secret_key
+     */
+    derive_secret_key(derivation_scalar: string, secret_key: string): Promise<string>;
+    /**
+     * Generates a key image from the public and secret ephemeral
+     *
+     * @param public_ephemeral
+     * @param secret_ephemeral
+     */
+    generate_key_image(public_ephemeral: string, secret_ephemeral: string): Promise<string>;
+    /**
+     * Generates a V2 key image from the secret ephemeral
+     *
+     * @param secret_ephemeral
+     */
+    generate_key_image_v2(secret_ephemeral: string): Promise<string>;
+    /**
+     * Generates a secret & public key pair
+     */
+    generate_keys(): Promise<key_pair_t>;
+    /**
+     * Generates a list pf secret & public keys
+     *
+     * @param count
+     */
+    generate_keys_m(count?: number): Promise<{
+        public_keys: string[];
+        secret_keys: string[];
+    }>;
+    /**
+     * Much like derive_public_key() but calculates the public_key used from the public ephemeral
+     *
+     * Note: B = P - [H(D || output_index) mod l]
+     *
+     * @param derivation
+     * @param public_ephemeral
+     * @param output_index
+     */
+    underive_public_key(derivation: string, public_ephemeral: string, output_index?: number): Promise<string>;
+    /**
+     * Calculates the public key of the given secret key
+     *
+     * @param secret_key
+     */
+    secret_key_to_public_key(secret_key: string): Promise<string>;
+    /**
+     * Calculates the secret scalar and public key for the provided ED25519 private key (aka seed)
+     *
+     * @param private_key
+     */
+    private_key_to_keys(private_key: string): Promise<key_pair_t>;
+    /**
+     * Generates an ED25519 point by hashing the provided data and turning
+     * it into a point on the ED25519 curve
+     *
+     * @param input
+     */
+    hash_to_point(input: any): Promise<string>;
+    /**
+     * Generates an ED25519 scalar by hashing the provided data and
+     * reducing it to an ED25519 scalar value
+     *
+     * @param input
+     */
+    hash_to_scalar(input: any): Promise<string>;
+    /**
+     * Reduces the input value to an ED25519 scalar value
+     *
+     * @param input
+     */
+    scalar_reduce(input: string | Buffer): Promise<string>;
+    /**
+     * Calculates the depth of the Merkle tree based upon how many hashes
+     * the tree contains
+     *
+     * @param value
+     */
+    tree_depth(value: number): Promise<number>;
+    /**
+     * Generates the root Merkle tree hash using the list of hashes
+     *
+     * @param hashes
+     */
+    root_hash(hashes: string[]): Promise<string>;
+    /**
+     * Generates a Merkle tree root hash value from the supplied input values
+     *
+     * @param branches
+     * @param leaf
+     * @param depth
+     * @param path
+     */
+    root_hash_from_branch(branches: string[], leaf: string, depth?: number, path?: 0 | 1): Promise<string>;
+    /**
+     * Generates Merkle tree branch from the list of hashes
+     *
+     * @param hashes
+     */
+    tree_branch(hashes: string[]): Promise<string[]>;
+    /**
+     * Generates an ED25519 RFC8032 signature for the message using
+     * the secret key specified
+     * @param message
+     * @param secret_key
+     */
+    generate_rfc8032_signature(message: string, secret_key: string): Promise<string>;
+    /**
+     * Checks an ED25519 RFC8032 signature to verify that it was created
+     * with the secret key of the public key specified
+     * @param message
+     * @param public_key
+     * @param signature
+     */
+    check_rfc8032_signature(message: string, public_key: string, signature: string): Promise<boolean>;
+    /**
+     * Generates a simple ED25519 signature for the message digest using
+     * the secret key specified
+     *
+     * @param message_digest
+     * @param secret_key
+     */
+    generate_signature(message_digest: string, secret_key: string): Promise<string>;
+    /**
+     * Prepares a signature for the message digest such that it
+     * can be completed in later stages of the signature construction
+     *
+     * @param message_digest
+     * @param public_key
+     */
+    prepare_signature(message_digest: string, public_key: string): Promise<string>;
+    /**
+     * Completes a previously prepared signature
+     *
+     * @param secret_key
+     * @param signature
+     */
+    complete_signature(secret_key: string, signature: string): Promise<string>;
+    /**
+     * Checks a simple ED25519 signature to verify that it was created
+     * with the secret key of the public key specified
+     *
+     * @param message_digest
+     * @param public_key
+     * @param signature
+     */
+    check_signature(message_digest: string, public_key: string, signature: string): Promise<boolean>;
+    /**
+     * Generates a borromean ring signature for the message digest using
+     * the secret key specified and the list of all possible public key
+     * signing candidates
+     *
+     * @param message_digest
+     * @param secret_ephemeral
+     * @param public_keys
+     */
+    generate_borromean_signature(message_digest: string, secret_ephemeral: string, public_keys: string[]): Promise<crypto_borromean_signature_t>;
+    /**
+     * Prepares a borromean ring signature for the message digest such
+     * that it can be completed in later stages of signature construction
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param real_output_index
+     */
+    prepare_borromean_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number): Promise<crypto_borromean_signature_t>;
+    /**
+     * Completes a previously prepared borromean ring signature
+     *
+     * @param secret_ephemeral
+     * @param real_output_index
+     * @param signature
+     */
+    complete_borromean_signature(secret_ephemeral: string, real_output_index: number, signature: crypto_borromean_signature_t): Promise<crypto_borromean_signature_t>;
+    /**
+     * Checks a borromean ring signature to verify that it was created
+     * by one of the candidate public keys
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param signature
+     */
+    check_borromean_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_borromean_signature_t): Promise<boolean>;
+    /**
+     * Generates a CLSAG ring signature for the message digest using
+     * the secret key specified and the list of all possible public
+     * key signing candidates.
+     *
+     * Optionally, we also include proof that we have the real values
+     * of the values hidden within pedersen commitments
+     *
+     * @param message_digest
+     * @param secret_ephemeral
+     * @param public_keys
+     * @param input_blinding_factor
+     * @param public_commitments
+     * @param pseudo_blinding_factor
+     * @param pseudo_commitment
+     */
+    generate_clsag_signature(message_digest: string, secret_ephemeral: string, public_keys: string[], input_blinding_factor?: string, public_commitments?: string[], pseudo_blinding_factor?: string, pseudo_commitment?: string): Promise<crypto_clsag_signature_t>;
+    /**
+     * Prepares a CLSAG ring signature for the message digest such
+     * that it can be completed in later stages of signature
+     * construction
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param real_output_index
+     * @param input_blinding_factor
+     * @param public_commitments
+     * @param pseudo_blinding_factor
+     * @param pseudo_commitment
+     */
+    prepare_clsag_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number, input_blinding_factor?: string, public_commitments?: string[], pseudo_blinding_factor?: string, pseudo_commitment?: string): Promise<{
+        signature: crypto_clsag_signature_t;
+        h: string[];
+        mu_P: string;
+    }>;
+    /**
+     * Completes a previously prepared CLSAG ring signature
+     *
+     * @param secret_ephemeral
+     * @param real_output_index
+     * @param signature
+     * @param h
+     * @param mu_P
+     */
+    complete_clsag_signature(secret_ephemeral: string, real_output_index: number, signature: crypto_clsag_signature_t, h: string[], mu_P: string): Promise<crypto_clsag_signature_t>;
+    /**
+     * Checks a CLSAG ring signature to verify that it was created
+     * by one of the candidate public keys.
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param signature
+     * @param commitments
+     */
+    check_clsag_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_clsag_signature_t, commitments?: string[]): Promise<boolean>;
+    /**
+     * Generates a Triptych ring signature for the message digest using
+     * the secret key specified and the list of all possible public
+     * key signing candidates.
+     *
+     * Optionally, we also include proof that we have the real values
+     * of the values hidden within pedersen commitments
+     *
+     * @param message_digest
+     * @param secret_ephemeral
+     * @param public_keys
+     * @param input_blinding_factor
+     * @param public_commitments
+     * @param pseudo_blinding_factor
+     * @param pseudo_commitment
+     */
+    generate_triptych_signature(message_digest: string, secret_ephemeral: string, public_keys: string[], input_blinding_factor: string, public_commitments: string[], pseudo_blinding_factor: string, pseudo_commitment: string): Promise<crypto_triptych_signature_t>;
+    /**
+     * Prepares a Triptych ring signature for the message digest such
+     * that it can be completed in later stages of signature
+     * construction
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param real_output_index
+     * @param input_blinding_factor
+     * @param public_commitments
+     * @param pseudo_blinding_factor
+     * @param pseudo_commitment
+     */
+    prepare_triptych_signature(message_digest: string, key_image: string, public_keys: string[], real_output_index: number, input_blinding_factor: string, public_commitments: string[], pseudo_blinding_factor: string, pseudo_commitment: string): Promise<{
+        signature: crypto_triptych_signature_t;
+        xpow: string;
+    }>;
+    /**
+     * Completes a previously prepared Triptych ring signature
+     *
+     * @param secret_ephemeral
+     * @param signature
+     * @param xpow
+     */
+    complete_triptych_signature(secret_ephemeral: string, signature: crypto_triptych_signature_t, xpow: string): Promise<crypto_triptych_signature_t>;
+    /**
+     * Checks a Triptych ring signature to verify that it was created
+     * by one of the candidate public keys.
+     *
+     * @param message_digest
+     * @param key_image
+     * @param public_keys
+     * @param signature
+     * @param commitments
+     */
+    check_triptych_signature(message_digest: string, key_image: string, public_keys: string[], signature: crypto_triptych_signature_t, commitments: string[]): Promise<boolean>;
+    /**
+     * Generates a Bulletproof Zero-Knowledge proof of the amount(s) specified
+     *
+     * @param amounts
+     * @param blinding_factors
+     * @param N
+     */
+    generate_bulletproof(amounts: number[], blinding_factors: string[], N?: number): Promise<{
+        proof: crypto_bulletproof_t;
+        commitments: string[];
+    }>;
+    /**
+     * Checks that a Bulletproof proof is valid
+     *
+     * @param proof
+     * @param commitments
+     * @param N
+     */
+    check_bulletproof(proof: crypto_bulletproof_t | crypto_bulletproof_t[], commitments: string[] | string[][], N?: number): Promise<boolean>;
+    /**
+     * Generates a Bulletproof+ Zero-Knowledge proof of the amount(s) specified
+     *
+     * @param amounts
+     * @param blinding_factors
+     * @param N
+     */
+    generate_bulletproof_plus(amounts: number[], blinding_factors: string[], N?: number): Promise<{
+        proof: crypto_bulletproof_plus_t;
+        commitments: string[];
+    }>;
+    /**
+     * Checks that a Bulletproof+ proof is valid
+     *
+     * @param proof
+     * @param commitments
+     * @param N
+     */
+    check_bulletproof_plus(proof: crypto_bulletproof_plus_t | crypto_bulletproof_plus_t[], commitments: string[] | string[][], N?: number): Promise<boolean>;
+    /**
+     * Verifies that the sum of output pedersen commitments plus a pedersen
+     * commitment of the transaction fee are equal to the sum of pseudo
+     * pedersen commitments
+     *
+     * @param pseudo_commitments
+     * @param output_commitments
+     * @param transaction_fee
+     */
+    check_commitments_parity(pseudo_commitments: string[], output_commitments: string[], transaction_fee: number): Promise<boolean>;
+    /**
+     * Generates the amount mask for the given deriviation scalar
+     *
+     * @param derivation_scalar
+     */
+    generate_amount_mask(derivation_scalar: string): Promise<string>;
+    /**
+     * Generates the commitment blinding factor for the given derivation scalar
+     *
+     * @param derivation_scalar
+     */
+    generate_commitment_blinding_factor(derivation_scalar: string): Promise<string>;
+    /**
+     * Generates a pedersen commitment for the supplied blinding factor and amount
+     *
+     * Note: C = (y * G) + (a * H) mod l
+     *
+     * @param blinding_factor
+     * @param amount
+     */
+    generate_pedersen_commitment(blinding_factor: string, amount: number): Promise<string>;
+    /**
+     * Generates a list of random blinding factors and pseudo output commitments from
+     * the list of input amounts and the output commitments while proving them to a zero-sum
+     *
+     * @param amounts
+     * @param output_blinding_factors
+     */
+    generate_pseudo_commitments(amounts: number[], output_blinding_factors: string[]): Promise<{
+        blinding_factors: string[];
+        commitments: string[];
+    }>;
+    /**
+     * Toggles an amount from unmasked/masked to the inverse state of masked/unmasked using the
+     * provided amount mask
+     *
+     * @param amount_mask
+     * @param amount
+     */
+    toggle_masked_amount(amount_mask: string, amount: string | number | bigint): Promise<bigint>;
+    /**
+     * Generates proof of having the secret ephemerals specified by generating the
+     * relevant public keys, key_images, and signature for each and encoding the
+     * necessary information into a Base58 encoded string that can be provided
+     * to a verified that already has the public ephemerals
+     *
+     * @param secret_ephemerals
+     */
+    generate_outputs_proof(secret_ephemerals: string[]): Promise<string>;
+    /**
+     * Verifies the proof provides using the public ephemerals by decoding the Base58 proof,
+     * extracting the key images, the signatures, and then verifying if those signatures
+     * are all valid, in which case, the key images are returned
+     *
+     * @param public_ephemerals
+     * @param proof
+     */
+    check_outputs_proof(public_ephemerals: string[], proof: string): Promise<string[]>;
+    /**
+     * Encodes the value specified into Base58
+     *
+     * @param value
+     */
+    base58_encode(value: string | Buffer): Promise<string>;
+    /**
+     * Encodes the value specified into Base58 and appends a checksum to the result
+     *
+     * @param value
+     */
+    base58_encode_check(value: string | Buffer): Promise<string>;
+    /**
+     * Decodes a Base58 encoded string
+     *
+     * @param base58
+     */
+    base58_decode(base58: string): Promise<Buffer>;
+    /**
+     * Decodes a Base58 encoded string after verifying the checksum value included
+     *
+     * @param base58
+     */
+    base58_decode_check(base58: string): Promise<Buffer>;
+    /**
+     * Encodes the specified value into CryptoNote Base58
+     * @param value
+     */
+    cn_base58_encode(value: string | Buffer): Promise<string>;
+    /**
+     * Encodes the value specified into CryptoNote Base58 and appends a checksum to the result
+     *
+     * @param value
+     */
+    cn_base58_encode_check(value: string | Buffer): Promise<string>;
+    /**
+     * Decodes a CryptoNote Base58 string
+     *
+     * @param base58
+     */
+    cn_base58_decode(base58: string): Promise<Buffer>;
+    /**
+     * Decodes a CryptoNote Base58 encoded string after verifying the checkvalue value included
+     *
+     * @param base58
+     */
+    cn_base58_decode_check(base58: string): Promise<Buffer>;
+    /**
+     * Generates a pedersen commitment for a transaction fee
+     *
+     * @param amount
+     */
+    generate_transaction_fee_commitment(amount: number): Promise<string>;
+    /**
+     * Checks if the value provided is a valid ED25519 scalar
+     *
+     * @param value
+     */
+    check_scalar(value: string): Promise<boolean>;
+    /**
+     * Checks if the value provided is a valid ED25519 point
+     * @param value
+     */
+    check_point(value: string): Promise<boolean>;
+    /**
+     * Encodes the supplied seed into a list of mnemonic words
+     *
+     * @param entropy
+     * @param language
+     */
+    mnemonics_encode(entropy: string, language?: Language): Promise<string[]>;
+    /**
+     * Decodes a mnemonic phrase or list of mnenomic words into as seed value
+     *
+     * @param mnemonic
+     * @param language
+     */
+    mnemonics_decode(mnemonic: string | string[], language?: Language): Promise<crypto_entropy_t>;
+    /**
+     * Returns the index number of the specified mnemonic word
+     *
+     * @param word
+     * @param language
+     */
+    mnemonics_word_index(word: string, language?: Language): Promise<number>;
+    /**
+     * Returns the list of mnemonic words
+     *
+     * @param language
+     */
+    word_list(language?: Language): Promise<string[]>;
+    /**
+     * Returns the list of mnemonic words that have been trimmed to
+     * the minimum number of characters per word
+     *
+     * @param language
+     */
+    word_list_trimmed(language?: Language): Promise<string[]>;
+    /**
+     * Calculates the exponent of 2^e that matches the target value
+     *
+     * @param value
+     */
+    calculate_base2_exponent(value: number): Promise<number>;
+    /**
+     * Encrypts the provides string using the supplied password into a hexadecimal encoded string
+     *
+     * @param input
+     * @param password
+     * @param iterations
+     */
+    aes_encrypt<InputType = string>(input: InputType, password: string, iterations?: number): Promise<string>;
+    /**
+     * Decrypts the data from the provided hexidecimal encoded encrypted string using the supplied password
+     *
+     * @param input
+     * @param password
+     * @param iterations
+     */
+    aes_decrypt<OutputType = string>(input: string, password: string, iterations?: number): Promise<OutputType>;
+    /**
+     * Returns a list of the supported languages
+     */
+    languages(): Promise<Language[]>;
+    /**
+     * Generates a BIP-39 seed from the provided entropy
+     *
+     * @param entropy
+     * @param passphrase
+     */
+    generate_seed(entropy: string, passphrase?: string): Promise<string>;
+    /**
+     * Generates a Hierarchical Deterministic Key Pair using the provided path
+     *
+     * @param seed
+     * @param purpose
+     * @param coin_type
+     * @param account
+     * @param change
+     * @param address_index
+     * @param hmac_key
+     */
+    generate_child_key(seed: string, purpose?: number, coin_type?: number, account?: number, change?: number, address_index?: number, hmac_key?: string): Promise<key_pair_t>;
+    /**
+     * Generates a hardened Hierarchical Deterministic Key path
+     *
+     * @param purpose
+     * @param coin_type
+     * @param account
+     * @param change
+     * @param address_index
+     */
+    make_path(purpose?: number, coin_type?: number, account?: number, change?: number, address_index?: number): string;
+    /**
+     * Executes the method call using the underlying library
+     *
+     * @param method
+     * @param argument
+     * @private
+     */
+    private execute;
+}