- HdNodeBase
- HdPrivateNodeInvalid

chainCode: Uint8Array

32 bytes of additional entropy that can be used to derive HD child nodes.

childIndex: number

The child index at which this node is derived from its parent node
(identified via `parentFingerprint`

). Indexes less than `0x80000000`

(`2147483648`

) use standard derivation, while indexes equal to or greater
than `0x80000000`

use the "hardened" derivation algorithm. The maximum
index is `0xffffffff`

(`4294967295`

).

In BIP32 HD derivation paths, hardened indexes are usually represented by
subtracting the hardened index offset (`2147483648`

) and appending `'`

to
the child index number. E.g. `0'`

is a `childIndex`

of `2147483648`

, and
`2'`

is a `childIndex`

of `2147483650`

.

depth: number

The depth of this node, between `0`

(for master nodes) and `255`

. E.g. for
a path of `m/0/0`

, `depth`

is `2`

.

invalidPrivateKey: Uint8Array

The 32-byte derivation result that is not a valid Secp256k1 private key. This is almost impossibly rare in a securely-random 32-byte Uint8Array, with a probability less than 1 in 2^127.

See validateSecp256k1PrivateKey for details.

parentFingerprint: Uint8Array

The first 4 bytes of the parent node's identifier. This is used to quickly identify the parent node in data structures, but collisions can occur. To resolve collisions, use the full parent identifier. (See deriveHdPublicNodeIdentifier for details.)

`Optional`

parentparentIdentifier?: Uint8Array

The full identifier of the parent node. This can be used to resolve
collisions where two possible parent nodes share a `parentFingerprint`

.
Since the full `parentIdentifier`

is not encoded in BIP32 HD keys, it
might be unknown.

valid: false

Generated using TypeDoc

An invalid private node in a Hierarchical Deterministic (HD) key tree. This is almost impossibly rare in a securely-random 32-byte Uint8Array, with a probability less than 1 in 2^127.

If this occurs during derivation from a seed, the error should be handled and a different seed should be used. If this occurs during HD derivation, BIP32 standardizes the procedure for skipping the offending key material by using the next child index. I.e. the node ultimately derived at the invalid child index is a duplicate of the node derived at

`index + 1`

.