Documentation

Index

Constants

View Source
const (
	// CoinTypeBitcoin specifies the BIP44 coin type for Bitcoin key
	// derivation.
	CoinTypeBitcoin uint32 = 0

	// CoinTypeTestnet specifies the BIP44 coin type for all testnet key
	// derivation.
	CoinTypeTestnet = 1

	// CoinTypeLitecoin specifies the BIP44 coin type for Litecoin key
	// derivation.
	CoinTypeLitecoin = 2
)
View Source
const (
	// KeyDerivationVersion is the version of the key derivation schema
	// defined below. We use a version as this means that we'll be able to
	// accept new seed in the future and be able to discern if the software
	// is compatible with the version of the seed.
	KeyDerivationVersion = 0

	// BIP0043Purpose is the "purpose" value that we'll use for the first
	// version or our key derivation scheme. All keys are expected to be
	// derived from this purpose, then the particular coin type of the
	// chain where the keys are to be used.  Slightly adhering to BIP0043
	// allows us to not deviate too far from a widely used standard, and
	// also fits into existing implementations of the BIP's template.
	//
	// NOTE: BRICK SQUUUUUAD.
	BIP0043Purpose = 1017
)

Variables

This section is empty.

Functions

This section is empty.

Types

type BtcWalletKeyRing

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

    BtcWalletKeyRing is an implementation of both the KeyRing and SecretKeyRing interfaces backed by btcwallet's internal root waddrmgr. Internally, we'll be using a ScopedKeyManager to do all of our derivations, using the key scope and scope addr scehma defined above. Re-using the existing key scope construction means that all key derivation will be protected under the root seed of the wallet, making each derived key fully deterministic.

    func (*BtcWalletKeyRing) DeriveKey

    func (b *BtcWalletKeyRing) DeriveKey(keyLoc KeyLocator) (KeyDescriptor, error)

      DeriveKey attempts to derive an arbitrary key specified by the passed KeyLocator. This may be used in several recovery scenarios, or when manually rotating something like our current default node key.

      NOTE: This is part of the keychain.KeyRing interface.

      func (*BtcWalletKeyRing) DeriveNextKey

      func (b *BtcWalletKeyRing) DeriveNextKey(keyFam KeyFamily) (KeyDescriptor, error)

        DeriveNextKey attempts to derive the *next* key within the key family (account in BIP43) specified. This method should return the next external child within this branch.

        NOTE: This is part of the keychain.KeyRing interface.

        func (*BtcWalletKeyRing) DerivePrivKey

        func (b *BtcWalletKeyRing) DerivePrivKey(keyDesc KeyDescriptor) (*btcec.PrivateKey, error)

          DerivePrivKey attempts to derive the private key that corresponds to the passed key descriptor.

          NOTE: This is part of the keychain.SecretKeyRing interface.

          func (*BtcWalletKeyRing) ScalarMult

          func (b *BtcWalletKeyRing) ScalarMult(keyDesc KeyDescriptor,
          	pub *btcec.PublicKey) ([]byte, error)

            ScalarMult performs a scalar multiplication (ECDH-like operation) between the target key descriptor and remote public key. The output returned will be the sha256 of the resulting shared point serialized in compressed format. If k is our private key, and P is the public key, we perform the following operation:

            sx := k*P s := sha256(sx.SerializeCompressed())
            

            NOTE: This is part of the keychain.SecretKeyRing interface.

            type KeyDescriptor

            type KeyDescriptor struct {
            	// KeyLocator is the internal KeyLocator of the descriptor.
            	KeyLocator
            
            	// PubKey is an optional public key that fully describes a target key.
            	// If this is nil, the KeyLocator MUST NOT be empty.
            	PubKey *btcec.PublicKey
            }

              KeyDescriptor wraps a KeyLocator and also optionally includes a public key. Either the KeyLocator must be non-empty, or the public key pointer be non-nil. This will be used by the KeyRing interface to lookup arbitrary private keys, and also within the SignDescriptor struct to locate precisely which keys should be used for signing.

              type KeyFamily

              type KeyFamily uint32

                KeyFamily represents a "family" of keys that will be used within various contracts created by lnd. These families are meant to be distinct branches within the HD key chain of the backing wallet. Usage of key families within the interface below are strict in order to promote integrability and the ability to restore all keys given a user master seed backup.

                The key derivation in this file follows the following hierarchy based on BIP43:

                * m/1017'/coinType'/keyFamily/0/index
                
                const (
                	// KeyFamilyMultiSig are keys to be used within multi-sig scripts.
                	KeyFamilyMultiSig KeyFamily = 0
                
                	// KeyFamilyRevocationBase are keys that are used within channels to
                	// create revocation basepoints that the remote party will use to
                	// create revocation keys for us.
                	KeyFamilyRevocationBase = 1
                
                	// KeyFamilyHtlcBase are keys used within channels that will be
                	// combined with per-state randomness to produce public keys that will
                	// be used in HTLC scripts.
                	KeyFamilyHtlcBase KeyFamily = 2
                
                	// KeyFamilyPaymentBase are keys used within channels that will be
                	// combined with per-state randomness to produce public keys that will
                	// be used in scripts that pay directly to us without any delay.
                	KeyFamilyPaymentBase KeyFamily = 3
                
                	// KeyFamilyDelayBase are keys used within channels that will be
                	// combined with per-state randomness to produce public keys that will
                	// be used in scripts that pay to us, but require a CSV delay before we
                	// can sweep the funds.
                	KeyFamilyDelayBase KeyFamily = 4
                
                	// KeyFamilyRevocationRoot is a family of keys which will be used to
                	// derive the root of a revocation tree for a particular channel.
                	KeyFamilyRevocationRoot KeyFamily = 5
                
                	// KeyFamilyNodeKey is a family of keys that will be used to derive
                	// keys that will be advertised on the network to represent our current
                	// "identity" within the network. Peers will need our latest node key
                	// in order to establish a transport session with us on the Lightning
                	// p2p level (BOLT-0008).
                	KeyFamilyNodeKey KeyFamily = 6
                )

                type KeyLocator

                type KeyLocator struct {
                
                	// Family is the family of key being identified.
                	Family KeyFamily
                
                	// Index is the precise index of the key being identified.
                	Index uint32
                }

                  KeyLocator is a two-tuple that can be used to derive *any* key that has ever been used under the key derivation mechanisms described in this file. Version 0 of our key derivation schema uses the following BIP43-like derivation:

                  * m/201'/coinType'/keyFamily/0/index
                  

                  Our purpose is 201 (chosen arbitrary for now), and the coin type will vary based on which coin/chain the channels are being created on. The key family are actually just individual "accounts" in the nomenclature of BIP43. By default we assume a branch of 0 (external). Finally, the key index (which will vary per channel and use case) is the final element which allows us to deterministically derive keys.

                  func (KeyLocator) IsEmpty

                  func (k KeyLocator) IsEmpty() bool

                    IsEmpty returns true if a KeyLocator is "empty". This may be the case where we learn of a key from a remote party for a contract, but don't know the precise details of its derivation (as we don't know the private key!).

                    type KeyRing

                    type KeyRing interface {
                    	// DeriveNextKey attempts to derive the *next* key within the key
                    	// family (account in BIP43) specified. This method should return the
                    	// next external child within this branch.
                    	DeriveNextKey(keyFam KeyFamily) (KeyDescriptor, error)
                    
                    	// DeriveKey attempts to derive an arbitrary key specified by the
                    	// passed KeyLocator. This may be used in several recovery scenarios,
                    	// or when manually rotating something like our current default node
                    	// key.
                    	DeriveKey(keyLoc KeyLocator) (KeyDescriptor, error)
                    }

                      KeyRing is the primary interface that will be used to perform public derivation of various keys used within the peer-to-peer network, and also within any created contracts. All derivation required by the KeyRing is based off of public derivation, so a system with only an extended public key (for the particular purpose+family) can derive this set of keys.

                      type SecretKeyRing

                      type SecretKeyRing interface {
                      	KeyRing
                      
                      	// DerivePrivKey attempts to derive the private key that corresponds to
                      	// the passed key descriptor.
                      	DerivePrivKey(keyDesc KeyDescriptor) (*btcec.PrivateKey, error)
                      
                      	// ScalarMult performs a scalar multiplication (ECDH-like operation)
                      	// between the target key descriptor and remote public key. The output
                      	// returned will be the sha256 of the resulting shared point serialized
                      	// in compressed format. If k is our private key, and P is the public
                      	// key, we perform the following operation:
                      	//
                      	//  sx := k*P
                      	//  s := sha256(sx.SerializeCompressed())
                      	ScalarMult(keyDesc KeyDescriptor, pubKey *btcec.PublicKey) ([]byte, error)
                      }

                        SecretKeyRing is a similar to the regular KeyRing interface, but it is also able to derive *private keys*. As this is a super-set of the regular KeyRing, we also expect the SecretKeyRing to implement the fully KeyRing interface. The methods in this struct may be used to extract the node key in order to accept inbound network connections, or to do manual signing for recovery purposes.

                        func NewBtcWalletKeyRing

                        func NewBtcWalletKeyRing(w *wallet.Wallet, coinType uint32) SecretKeyRing

                          NewBtcWalletKeyRing creates a new implementation of the keychain.SecretKeyRing interface backed by btcwallet.

                          NOTE: The passed waddrmgr.Manager MUST be unlocked in order for the keychain to function.