rpcwallet

package
v0.0.20 Latest Latest
Warning

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

 Go to latest Published: Sep 9, 2023 License: MIT Imports: 30 Imported by: 0

Documentation

Index

Constants

View Source 
const Subsystem = "RPWL"

Subsystem defines the logging code for this subsystem.

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

func DisableLog 

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.

func HealthCheck 

func HealthCheck(cfg *lncfg.RemoteSigner, timeout time.Duration) func() error

HealthCheck returns a health check function for the given remote signing configuration.

func UseLogger 

func UseLogger(logger btclog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using btclog.

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, coinType uint32) (*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, _ 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.

NOTE: This is a part of the WalletController interface.

NOTE: We need to overwrite this method because we need to redirect the call to ComputeInputScript to the RPC key ring's implementation. If we forward the call to the default WalletController implementation, we get an error since that wallet is watch-only. If we forward the call to the remote signer, we get an error because the signer doesn't know the UTXO information required in ComputeInputScript.

TODO(guggero): Refactor btcwallet to accept ComputeInputScript as a function parameter in FinalizePsbt so we can get rid of this code duplication.

func (*RPCKeyRing) NewAddress 

func (r *RPCKeyRing) NewAddress(addrType lnwallet.AddressType, change bool,
	account string) (ltcutil.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.

NOTE: This is a part of the WalletController interface.

NOTE: This method only signs with BIP49/84 keys.

func (*RPCKeyRing) SignMessage 

func (r *RPCKeyRing) SignMessage(keyLoc keychain.KeyLocator,
	msg []byte, doubleHash bool) (*ecdsa.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.

NOTE: This method only signs with BIP1017 (internal) keys!

func (*RPCKeyRing) SignPsbt 

func (r *RPCKeyRing) SignPsbt(packet *psbt.Packet) error

SignPsbt expects a partial transaction with all inputs and outputs fully declared and tries to sign all unsigned inputs that have all required fields (UTXO information, BIP32 derivation information, witness or sig scripts) set. If no error is returned, the PSBT is ready to be given to the next signer or to be finalized if lnd was the last signer.

NOTE: This RPC only signs inputs (and only those it can sign), it does not perform any other tasks (such as coin selection, UTXO locking or input/output/fee value validation, PSBT finalization). Any input that is incomplete will be skipped.

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.