hdkeychain

Documentation

Index

• Constants
• Variables
• func GenerateSeed(length uint8) ([]byte, error)
• type ExtendedKey
  • func NewKeyFromString(str string) (*ExtendedKey, error)
  • func NewMaster(seed []byte, pubOnG1 bool) (*ExtendedKey, error)
  • func (k *ExtendedKey) Derive(index uint32) (*ExtendedKey, error)
  • func (k *ExtendedKey) DerivePath(path []uint32) (*ExtendedKey, error)
  • func (k *ExtendedKey) IsPrivate() bool
  • func (k *ExtendedKey) Neuter() *ExtendedKey
  • func (k *ExtendedKey) Path() []uint32
  • func (k *ExtendedKey) RawPrivateKey() ([]byte, error)
  • func (k *ExtendedKey) RawPublicKey() []byte
  • func (k *ExtendedKey) String() string

Constants

const (
	// HardenedKeyStart is the index at which a hardened key starts.  Each
	// extended key has 2^31 normal child keys and 2^31 hardened child keys.
	// Thus the range for normal child keys is [0, 2^31 - 1] and the range
	// for hardened child keys is [2^31, 2^32 - 1].
	HardenedKeyStart = uint32(0x80000000) // 2^31

	// MinSeedBytes is the minimum number of bytes allowed for a seed to
	// a master node.
	MinSeedBytes = 16 // 128 bits

	// MaxSeedBytes is the maximum number of bytes allowed for a seed to
	// a master node.
	MaxSeedBytes = 64 // 512 bits
)

Variables

var (
	// ErrDeriveHardFromPublic describes an error in which the caller
	// attempted to derive a hardened extended key from a public key.
	ErrDeriveHardFromPublic = errors.New("cannot derive a hardened key " +
		"from a public key")

	// ErrNotPrivExtKey describes an error in which the caller attempted
	// to extract a private key from a public extended key.
	ErrNotPrivExtKey = errors.New("unable to create private keys from a " +
		"public extended key")

	// ErrUnusableSeed describes an error in which the provided seed is not
	// usable due to the derived key falling outside of the valid range for
	// BLS private keys.  This error indicates the caller must choose
	// another seed.
	ErrUnusableSeed = errors.New("unusable seed")

	// ErrInvalidSeedLen describes an error in which the provided seed or
	// seed length is not in the allowed range.
	ErrInvalidSeedLen = fmt.Errorf("seed length must be between %d and %d "+
		"bits", MinSeedBytes*8, MaxSeedBytes*8)

	// ErrInvalidKeyData describes an error in which the provided key is
	// not valid.
	ErrInvalidKeyData = errors.New("key data is invalid")
)

Functions

func GenerateSeed

func GenerateSeed(length uint8) ([]byte, error)

GenerateSeed returns a cryptographically secure random seed that can be used as the input for the NewMaster function to generate a new master node.

The length is in bytes and it must be between 16 and 64 (128 to 512 bits). The recommended length is 32 (256 bits) as defined by the RecommendedSeedLen constant.

Types

type ExtendedKey

type ExtendedKey struct {
	// contains filtered or unexported fields
}

ExtendedKey houses all the information needed to support a hierarchical deterministic extended key.

func NewKeyFromString

func NewKeyFromString(str string) (*ExtendedKey, error)

NewKeyFromString returns a new extended key instance from a bech32-encoded string.

func NewMaster

func NewMaster(seed []byte, pubOnG1 bool) (*ExtendedKey, error)

NewMaster creates a new master node for use in creating a hierarchical deterministic key chain. The seed must be between 128 and 512 bits and should be generated by a cryptographically secure random generation source.

func (*ExtendedKey) Derive

func (k *ExtendedKey) Derive(index uint32) (*ExtendedKey, error)

Derive returns a derived child extended key at the given index.

When this extended key is a private extended key (as determined by the IsPrivate function), a private extended key will be derived. Otherwise, the derived extended key will be a public extended key.

When the index is greater to or equal than the HardenedKeyStart constant, the derived extended key will be a hardened extended key. It is only possible to derive a hardened extended key from a private extended key. Consequently, this function will return ErrDeriveHardFromPublic if a hardened child extended key is requested from a public extended key.

A hardened extended key is useful since, as previously mentioned, it requires a parent private extended key to derive. In other words, normal child extended public keys can be derived from a parent public extended key (no knowledge of the parent private key) whereas hardened extended keys may not be.

func (*ExtendedKey) DerivePath

func (k *ExtendedKey) DerivePath(path []uint32) (*ExtendedKey, error)

DerivePath returns a derived child extended key from this master key at the given path.

func (*ExtendedKey) IsPrivate

func (k *ExtendedKey) IsPrivate() bool

IsPrivate returns whether or not the extended key is a private extended key.

A private extended key can be used to derive both hardened and non-hardened child private and public extended keys. A public extended key can only be used to derive non-hardened child public extended keys.

func (*ExtendedKey) Neuter

func (k *ExtendedKey) Neuter() *ExtendedKey

Neuter returns a new extended public key from this extended private key. The same extended key will be returned unaltered if it is already an extended public key.

As the name implies, an extended public key does not have access to the private key, so it is not capable of signing transactions or deriving child extended private keys. However, it is capable of deriving further child extended public keys.

func (*ExtendedKey) Path

func (k *ExtendedKey) Path() []uint32

Path returns the path of derived key.

Path with values between 0 and 2^31-1 are normal child keys, and those values between 2^31 and 2^32-1 are hardened keys.

func (*ExtendedKey) RawPrivateKey

func (k *ExtendedKey) RawPrivateKey() ([]byte, error)

RawPrivateKey returns the raw bytes of the private key. As you might imagine this is only possible if the extended key is a private extended key (as determined by the IsPrivate function). The ErrNotPrivExtKey error will be returned if this function is called on a public extended key.

func (*ExtendedKey) RawPublicKey

func (k *ExtendedKey) RawPublicKey() []byte

RawPublicKey returns the raw bytes of the public key.

func (*ExtendedKey) String

func (k *ExtendedKey) String() string

String returns the extended key as a bech32-encoded string.