@hashgraph/sdk/lib/PrivateKey.d.ts

Hiero SDK

/**
 * @typedef {import("./transaction/Transaction.js").default} Transaction
 */
/**
 * @namespace proto
 * @typedef {import("@hashgraph/proto").proto.IKey} HieroProto.proto.IKey
 * @typedef {import("@hashgraph/proto").proto.ITransaction} HieroProto.proto.ITransaction
 * @typedef {import("@hashgraph/proto").proto.ISignaturePair} HieroProto.proto.ISignaturePair
 * @typedef {import("@hashgraph/proto").proto.ISignedTransaction} HieroProto.proto.ISignedTransaction
 * @typedef {import("@hashgraph/proto").proto.TransactionBody} HieroProto.proto.TransactionBody
 */
export default class PrivateKey extends Key {
    /**
     * Generate a random Ed25519 private key.
     *
     * @returns {PrivateKey}
     */
    static generateED25519(): PrivateKey;
    /**
     * Generate a random EDSA private key.
     *
     * @returns {PrivateKey}
     */
    static generateECDSA(): PrivateKey;
    /**
     * Depredated - Use `generateED25519()` instead
     * Generate a random Ed25519 private key.
     *
     * @returns {PrivateKey}
     */
    static generate(): PrivateKey;
    /**
     * Depredated - Use `generateED25519Async()` instead
     * Generate a random Ed25519 private key.
     *
     * @returns {Promise<PrivateKey>}
     */
    static generateAsync(): Promise<PrivateKey>;
    /**
     * Generate a random Ed25519 private key.
     *
     * @returns {Promise<PrivateKey>}
     */
    static generateED25519Async(): Promise<PrivateKey>;
    /**
     * Generate a random ECDSA private key.
     *
     * @returns {Promise<PrivateKey>}
     */
    static generateECDSAAsync(): Promise<PrivateKey>;
    /**
     * Construct a private key from bytes. Requires DER header.
     *
     * @param {Uint8Array} data
     * @returns {PrivateKey}
     */
    static fromBytes(data: Uint8Array): PrivateKey;
    /**
     * Construct a ECDSA private key from bytes.
     *
     * @param {Uint8Array} data
     * @returns {PrivateKey}
     */
    static fromBytesECDSA(data: Uint8Array): PrivateKey;
    /**
     * Construct a ED25519 private key from bytes.
     *
     * @param {Uint8Array} data
     * @returns {PrivateKey}
     */
    static fromBytesED25519(data: Uint8Array): PrivateKey;
    /**
     * @deprecated - Use fromStringECDSA() or fromStringED2551() on a HEX-encoded string
     * and fromStringDer() on a HEX-encoded string with DER prefix instead.
     * Construct a private key from a hex-encoded string. Requires DER header.
     * @param {string} text
     * @returns {PrivateKey}
     */
    static fromString(text: string): PrivateKey;
    /**
     * Construct a private key from a HEX-encoded string with a der prefix
     *
     * @param {string} text
     * @returns {PrivateKey}
     */
    static fromStringDer(text: string): PrivateKey;
    /**
     * Construct a ECDSA private key from a hex-encoded string.
     *
     * @param {string} text
     * @returns {PrivateKey}
     */
    static fromStringECDSA(text: string): PrivateKey;
    /**
     * Construct a Ed25519 private key from a hex-encoded string.
     *
     * @param {string} text
     * @returns {PrivateKey}
     */
    static fromStringED25519(text: string): PrivateKey;
    /**
     * Construct a Ed25519 private key from a Uint8Array seed.
     *
     * @param {Uint8Array} seed
     * @returns {Promise<PrivateKey>}
     */
    static fromSeedED25519(seed: Uint8Array): Promise<PrivateKey>;
    /**
     * Construct a Ed25519 private key from a Uint8Array seed.
     *
     * @param {Uint8Array} seed
     * @returns {Promise<PrivateKey>}
     */
    static fromSeedECDSAsecp256k1(seed: Uint8Array): Promise<PrivateKey>;
    /**
     * @deprecated - Use `Mnemonic.from[Words|String]().to[Ed25519|Ecdsa]PrivateKey()` instead
     *
     * Recover a private key from a mnemonic phrase (and optionally a password).
     * @param {Mnemonic  | string} mnemonic
     * @param {string} [passphrase]
     * @returns {Promise<PrivateKey>}
     */
    static fromMnemonic(mnemonic: Mnemonic | string, passphrase?: string): Promise<PrivateKey>;
    /**
     * Recover a private key from a keystore, previously created by `.toKeystore()`.
     *
     * This key will _not_ support child key derivation.
     *
     * @param {Uint8Array} data
     * @param {string} [passphrase]
     * @returns {Promise<PrivateKey>}
     * @throws {cryptography.BadKeyError} If the passphrase is incorrect or the hash fails to validate.
     */
    static fromKeystore(data: Uint8Array, passphrase?: string): Promise<PrivateKey>;
    /**
     * Recover a private key from a pem string; the private key may be encrypted.
     *
     * This method assumes the .pem file has been converted to a string already.
     *
     * If `passphrase` is not null or empty, this looks for the first `ENCRYPTED PRIVATE KEY`
     * section and uses `passphrase` to decrypt it; otherwise, it looks for the first `PRIVATE KEY`
     * section and decodes that as a DER-encoded  private key.
     *
     * @param {string} data
     * @param {string} [passphrase]
     * @returns {Promise<PrivateKey>}
     */
    static fromPem(data: string, passphrase?: string): Promise<PrivateKey>;
    /**
     * @param {string} privateKey
     * @returns { "ecdsa" | "ed25519"}
     */
    static getAlgorithm(privateKey: string): "ecdsa" | "ed25519";
    /**
     * @internal
     * @param {string} key
     * @returns {boolean}
     */
    static isDerKey(key: string): boolean;
    /**
     * @internal
     * @hideconstructor
     * @param {PrivateKeyCrypto} key
     */
    constructor(key: PrivateKeyCrypto);
    _key: PrivateKeyCrypto;
    /**
     * Derive a new private key at the given wallet index.
     *
     * Only currently supported for keys created with `fromMnemonic()`; other keys will throw
     * an error.
     *
     * You can check if a key supports derivation with `.supportsDerivation()`
     *
     * @param {number} index
     * @returns {Promise<PrivateKey>}
     * @throws If this key does not support derivation.
     */
    derive(index: number): Promise<PrivateKey>;
    /**
     * @param {number} index
     * @returns {Promise<PrivateKey>}
     * @throws If this key does not support derivation.
     */
    legacyDerive(index: number): Promise<PrivateKey>;
    /**
     * Get the public key associated with this private key.
     *
     * The public key can be freely given and used by other parties to verify
     * the signatures generated by this private key.
     *
     * @returns {PublicKey}
     */
    get publicKey(): PublicKey;
    /**
     * Get the public key associated with this private key.
     *
     * The public key can be freely given and used by other parties to verify
     * the signatures generated by this private key.
     *
     * @returns {?Uint8Array}
     */
    get chainCode(): Uint8Array | null;
    /**
     * Sign a message with this private key.
     *
     * @param {Uint8Array} bytes
     * @returns {Uint8Array} - The signature bytes without the message
     */
    sign(bytes: Uint8Array): Uint8Array;
    /**
     * @deprecated - Use legacy=false flag to use the modern approach
     * or don't pass it at all.
     * @overload
     * @param {Transaction} transaction
     * @param {true} legacy
     * @returns {Uint8Array | Uint8Array[] }
     */
    signTransaction(transaction: Transaction, legacy: true): Uint8Array | Uint8Array[];
    /**
     * @overload
     * @param {Transaction} transaction
     * @param {false} [legacy]
     * @returns {SignatureMap}
     */
    signTransaction(transaction: Transaction, legacy?: false | undefined): SignatureMap;
    /**
     * deprecated - This method is deprecated and will be removed in future versions.
     * Use the `signTransaction` method with the `legacy=false` flag or don't
     * pass it all for the modern approach.
     * @param {Transaction} transaction
     * @returns {Uint8Array | Uint8Array[]}
     */
    _signTransactionLegacy(transaction: Transaction): Uint8Array | Uint8Array[];
    /**
     * Check if `derive` can be called on this private key.
     *
     * This is only the case if the key was created from a mnemonic.
     *
     * @returns {boolean}
     */
    isDerivable(): boolean;
    /**
     * @returns {Uint8Array}
     */
    toBytes(): Uint8Array;
    /**
     * @returns {Uint8Array}
     */
    toBytesDer(): Uint8Array;
    /**
     * @returns {Uint8Array}
     */
    toBytesRaw(): Uint8Array;
    /**
     * @returns {string}
     */
    toStringDer(): string;
    /**
     * @returns {string}
     */
    toStringRaw(): string;
    /**
     * Create a keystore with a given passphrase.
     *
     * The key can be recovered later with `fromKeystore()`.
     *
     * Note that this will not retain the ancillary data used for
     * deriving child keys, thus `.derive()` on the restored key will
     * throw even if this instance supports derivation.
     *
     * @param {string} [passphrase]
     * @returns {Promise<Uint8Array>}
     */
    toKeystore(passphrase?: string): Promise<Uint8Array>;
    /**
     * @param {Long | number} shard
     * @param {Long | number} realm
     * @returns {AccountId}
     */
    toAccountId(shard: Long | number, realm: Long | number): AccountId;
    /**
     * @returns {string}
     */
    get type(): string;
    /**
     * Recover the recovery ID used in the signature for the given message.
     *
     * **Note:** This method only works for ECDSA secp256k1 keys.
     * @param {Uint8Array} r - 32-byte `r` component of the signature
     * @param {Uint8Array} s - 32-byte `s` component of the signature
     * @param {Uint8Array} message - The original (unhashed) message
     * @returns {number} Recovery ID (0–3), or -1 if not found or not applicable
     */
    getRecoveryId(r: Uint8Array, s: Uint8Array, message: Uint8Array): number;
}
export type Transaction = import("./transaction/Transaction.js").default;
export namespace HieroProto {
    namespace proto {
        type IKey = import("@hashgraph/proto").proto.IKey;
        type ITransaction = import("@hashgraph/proto").proto.ITransaction;
        type ISignaturePair = import("@hashgraph/proto").proto.ISignaturePair;
        type ISignedTransaction = import("@hashgraph/proto").proto.ISignedTransaction;
        type TransactionBody = import("@hashgraph/proto").proto.TransactionBody;
    }
}
import Key from "./Key.js";
import { PrivateKey as PrivateKeyCrypto } from "@hashgraph/cryptography";
import PublicKey from "./PublicKey.js";
import SignatureMap from "./transaction/SignatureMap.js";
import AccountId from "./account/AccountId.js";
import Mnemonic from "./Mnemonic.js";