rpcwallet

package
v0.14.0-beta.rc2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 5, 2021 License: MIT Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// DefaultRPCTimeout is the default timeout that is used when forwarding
	// a request to the remote signer through RPC.
	DefaultRPCTimeout = 5 * time.Second
)

Variables

View Source 
var (
	// ErrRemoteSigningPrivateKeyNotAvailable is the error that is returned
	// if an operation is requested from the RPC wallet that is not
	// supported in remote signing mode.
	ErrRemoteSigningPrivateKeyNotAvailable = errors.New("deriving " +
		"private key is not supported by RPC based key ring")
)

Functions

This section is empty.

Types

type RPCKeyRing 

type RPCKeyRing struct {
	// WalletController is the embedded wallet controller of the watch-only
	// base wallet. We need to overwrite/shadow certain of the implemented
	// methods to make sure we can mirror them to the remote wallet.
	lnwallet.WalletController
	// contains filtered or unexported fields
}

RPCKeyRing is an implementation of the SecretKeyRing interface that uses a local watch-only wallet for keeping track of addresses and transactions but delegates any signing or ECDH operations to a remote node through RPC.

func NewRPCKeyRing 

func NewRPCKeyRing(watchOnlyKeyRing keychain.SecretKeyRing,
	watchOnlyWalletController lnwallet.WalletController,
	remoteSigner *lncfg.RemoteSigner,
	rpcTimeout time.Duration) (*RPCKeyRing, error)

NewRPCKeyRing creates a new remote signing secret key ring that uses the given watch-only base wallet to keep track of addresses and transactions but delegates any signing or ECDH operations to the remove signer through RPC.

func (*RPCKeyRing) ComputeInputScript 

func (r *RPCKeyRing) ComputeInputScript(tx *wire.MsgTx,
	signDesc *input.SignDescriptor) (*input.Script, error)

ComputeInputScript generates a complete InputIndex for the passed transaction with the signature as defined within the passed SignDescriptor. This method should be capable of generating the proper input script for both regular p2wkh output and p2wkh outputs nested within a regular p2sh output.

NOTE: This method will ignore any tweak parameters set within the passed SignDescriptor as it assumes a set of typical script templates (p2wkh, np2wkh, etc).

NOTE: This method is part of the input.Signer interface.

func (*RPCKeyRing) DeriveKey 

func (r *RPCKeyRing) DeriveKey(
	keyLoc keychain.KeyLocator) (keychain.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 method is part of the keychain.KeyRing interface.

func (*RPCKeyRing) DeriveNextKey 

func (r *RPCKeyRing) DeriveNextKey(
	keyFam keychain.KeyFamily) (keychain.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 method is part of the keychain.KeyRing interface.

func (*RPCKeyRing) DerivePrivKey 

func (r *RPCKeyRing) DerivePrivKey(_ keychain.KeyDescriptor) (*btcec.PrivateKey,
	error)

DerivePrivKey attempts to derive the private key that corresponds to the passed key descriptor. If the public key is set, then this method will perform an in-order scan over the key set, with a max of MaxKeyRangeScan keys. In order for this to work, the caller MUST set the KeyFamily within the partially populated KeyLocator.

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

func (*RPCKeyRing) ECDH 

func (r *RPCKeyRing) ECDH(keyDesc keychain.KeyDescriptor,
	pubKey *btcec.PublicKey) ([32]byte, error)

ECDH 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 method is part of the keychain.ECDHRing interface.

func (*RPCKeyRing) FinalizePsbt 

func (r *RPCKeyRing) FinalizePsbt(packet *psbt.Packet, accountName string) error

FinalizePsbt expects a partial transaction with all inputs and outputs fully declared and tries to sign all inputs that belong to the specified account. Lnd must be the last signer of the transaction. That means, if there are any unsigned non-witness inputs or inputs without UTXO information attached or inputs without witness data that do not belong to lnd's wallet, this method will fail. If no error is returned, the PSBT is ready to be extracted and the final TX within to be broadcast.

NOTE: This method does NOT publish the transaction after it's been finalized successfully.

This is a part of the WalletController interface.

func (*RPCKeyRing) ImportAccount 

func (r *RPCKeyRing) ImportAccount(name string,
	accountPubKey *hdkeychain.ExtendedKey, masterKeyFingerprint uint32,
	addrType *waddrmgr.AddressType,
	dryRun bool) (*waddrmgr.AccountProperties, []btcutil.Address,
	[]btcutil.Address, error)

ImportAccount imports an account backed by an account extended public key. The master key fingerprint denotes the fingerprint of the root key corresponding to the account public key (also known as the key with derivation path m/). This may be required by some hardware wallets for proper identification and signing.

The address type can usually be inferred from the key's version, but may be required for certain keys to map them into the proper scope.

For BIP-0044 keys, an address type must be specified as we intend to not support importing BIP-0044 keys into the wallet using the legacy pay-to-pubkey-hash (P2PKH) scheme. A nested witness address type will force the standard BIP-0049 derivation scheme, while a witness address type will force the standard BIP-0084 derivation scheme.

For BIP-0049 keys, an address type must also be specified to make a distinction between the standard BIP-0049 address schema (nested witness pubkeys everywhere) and our own BIP-0049Plus address schema (nested pubkeys externally, witness pubkeys internally).

func (*RPCKeyRing) ImportPublicKey 

func (r *RPCKeyRing) ImportPublicKey(pubKey *btcec.PublicKey,
	addrType waddrmgr.AddressType) error

ImportPublicKey imports a single derived public key into the wallet. The address type can usually be inferred from the key's version, but in the case of legacy versions (xpub, tpub), an address type must be specified as we intend to not support importing BIP-44 keys into the wallet using the legacy pay-to-pubkey-hash (P2PKH) scheme.

func (*RPCKeyRing) LastUnusedAddress 

func (r *RPCKeyRing) LastUnusedAddress(lnwallet.AddressType,
	string) (btcutil.Address, error)

LastUnusedAddress returns the last *unused* address known by the wallet. An address is unused if it hasn't received any payments. This can be useful in UIs in order to continually show the "freshest" address without having to worry about "address inflation" caused by continual refreshing. Similar to NewAddress it can derive a specified address type, and also optionally a change address. The account parameter must be non-empty as it determines which account the address should be generated from.

func (*RPCKeyRing) NewAddress 

func (r *RPCKeyRing) NewAddress(addrType lnwallet.AddressType, change bool,
	account string) (btcutil.Address, error)

NewAddress returns the next external or internal address for the wallet dictated by the value of the `change` parameter. If change is true, then an internal address should be used, otherwise an external address should be returned. The type of address returned is dictated by the wallet's capabilities, and may be of type: p2sh, p2wkh, p2wsh, etc. The account parameter must be non-empty as it determines which account the address should be generated from.

func (*RPCKeyRing) SendOutputs 

func (r *RPCKeyRing) SendOutputs(outputs []*wire.TxOut,
	feeRate chainfee.SatPerKWeight, minConfs int32,
	label string) (*wire.MsgTx, error)

SendOutputs funds, signs, and broadcasts a Bitcoin transaction paying out to the specified outputs. In the case the wallet has insufficient funds, or the outputs are non-standard, a non-nil error will be returned.

NOTE: This method requires the global coin selection lock to be held.

This is a part of the WalletController interface.

func (*RPCKeyRing) SignMessage 

func (r *RPCKeyRing) SignMessage(keyLoc keychain.KeyLocator,
	msg []byte, doubleHash bool) (*btcec.Signature, error)

SignMessage attempts to sign a target message with the private key described in the key locator. If the target private key is unable to be found, then an error will be returned. The actual digest signed is the single or double SHA-256 of the passed message.

NOTE: This method is part of the keychain.MessageSignerRing interface.

func (*RPCKeyRing) SignMessageCompact 

func (r *RPCKeyRing) SignMessageCompact(keyLoc keychain.KeyLocator,
	msg []byte, doubleHash bool) ([]byte, error)

SignMessageCompact signs the given message, single or double SHA256 hashing it first, with the private key described in the key locator and returns the signature in the compact, public key recoverable format.

NOTE: This method is part of the keychain.MessageSignerRing interface.

func (*RPCKeyRing) SignOutputRaw 

func (r *RPCKeyRing) SignOutputRaw(tx *wire.MsgTx,
	signDesc *input.SignDescriptor) (input.Signature, error)

SignOutputRaw generates a signature for the passed transaction according to the data within the passed SignDescriptor.

NOTE: The resulting signature should be void of a sighash byte.

NOTE: This method is part of the input.Signer interface.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.