dcrlnd

README

dcrlnd

Lightning Network Daemon

The Decred Lightning Network Daemon (dcrlnd) - is a complete implementation of a Lightning Network node and currently deployed on testnet3 - the Decred Test Network.

dcrlnd currently requires a dcrd backing full node to perform the required chain services. The project's codebase uses the existing set of decred libraries, and also exports a large set of isolated re-usable Lightning Network related libraries within it. In the current state dcrlnd is capable of:

• Creating channels.
• Closing channels.
• Completely managing all channel states (including the exceptional ones!).
• Maintaining a fully authenticated+validated channel graph.
• Performing path finding within the network, passively forwarding incoming payments.
• Sending outgoing onion-encrypted payments through the network.
• Updating advertised fee schedules.
• Automatic channel management (autopilot).

LND Porting Status

dcrlnd is currently developed as a port of the original lnd lightning network daemon with the changes required to make it work on the Decred network and with Decred software.

Some of the most important (though by no means exhaustive) diffrences between lnd and dcrlnd include:

• Import Paths
• Full node integration API
• Transaction serialization layout
• Transaction witness format and signature process
• Wallet integration API

Lightning Network Specification Compliance

dcrlnd aims to conform to the Lightning Network specification (BOLTs). BOLT stands for: Basis of Lightning Technology. The specifications are currently being drafted by several groups of implementers based around the world including the developers of dcrlnd. The set of specification documents as well as our implementation of the specification are still a work-in-progress. With that said, the current status of dcrlnd's BOLT compliance is:

• BOLT 1: Base Protocol
• BOLT 2: Peer Protocol for Channel Management
• BOLT 3: Bitcoin Transaction and Script Formats
• BOLT 4: Onion Routing Protocol
• BOLT 5: Recommendations for On-chain Transaction Handling
• BOLT 7: P2P Node and Channel Discovery
• BOLT 8: Encrypted and Authenticated Transport
• BOLT 9: Assigned Feature Flags
• BOLT 10: DNS Bootstrap and Assisted Node Location
• BOLT 11: Invoice Protocol for Lightning Payments

Developer Resources

The daemon has been designed to be as developer friendly as possible in order to facilitate application development on top of dcrlnd. Two primary RPC interfaces are exported: an HTTP REST API, and a gRPC service. The exported API's are not yet stable, so be warned: they may change drastically in the near future.

Most of the automatically generated documentation for the LND RPC APIs is applicable to dcrlnd and can be found at api.lightning.community. The developer resources including talks, articles, and example applications are also relevant to dcrlnd and can be found at: dev.lightning.community.

For questions and discussions, all Decred communities can be found at:

https://decred.org/community

Installation

Knowledgeable users may use the quickstart guide.

For more detailed instructions, please see the installation instructions.

And a sample config file with annotated options is also available here.

Docker

To run lnd from Docker, please see the main Docker instructions

Safety

When operating a mainnet dcrlnd node, please refer to our operational safety guildelines. It is important to note that dcrlnd is still beta software and that ignoring these operational guidelines can lead to loss of funds.

Security

dcrlnd is now part of Decred's Bug Bounty Program on an experimental basis while we haven't yet deployed into mainnet.

Additionally, given the current nature of this work as a fork from the original lnd code, bugs that have been submitted to the upstream lnd project are not eligible for the bug bounty program unless the following points apply:

• The bug affects a mainnet worthy release of dcrlnd;
• The fix for the bug was not merged from the upstream repo while a substantial amount of upstream commits that are newer than the relevant one were merged;
• The bug is not critical to lnd but it is to dcrlnd.

To submit dcrlnd bugs eligible for inclusion in the program, please visit the Bug Bounty Website and follow the instructions there.

Further reading

• Step-by-step send payment guide with docker
• Contribution guide

Documentation

Index

• Constants
• Variables
• func AddSubLogger(root *build.RotatingLogWriter, subsystem string, ...)
• func AdminAuthOptions(cfg *Config) ([]grpc.DialOption, error)
• func CleanAndExpandPath(path string) string
• func GetChanPointFundingTxid(chanPoint *lnrpc.ChannelPoint) (*chainhash.Hash, error)
• func Main(cfg *Config, lisCfg ListenerCfg, shutdownChan <-chan struct{}) error
• func MainRPCServerPermissions() map[string][]bakery.Op
• func SetSubLogger(root *build.RotatingLogWriter, subsystem string, logger slog.Logger, ...)
• func SetupLoggers(root *build.RotatingLogWriter)
• func WalletUnlockerAuthOptions(cfg *Config) ([]grpc.DialOption, error)
• type BreachConfig
• type Config
  • func DefaultConfig() Config
  • func LoadConfig() (*Config, error)
  • func ValidateConfig(cfg Config, usageMessage string) (*Config, error)
• type ContractBreachEvent
• type GrpcRegistrar
• type ListenerCfg
• type ListenerWithSignal
• type NurseryConfig
• type NurseryStore
• type RPCSubserverConfig
• type RestRegistrar
• type RetributionStore
• type WalletUnlockParams

Constants

const (

	// DefaultDecredBaseFeeMAtoms is the default forwarding base fee.
	DefaultDecredBaseFeeMAtoms = lnwire.MilliAtom(1000)

	// DefaultDecredFeeRate is the default forwarding fee rate.
	DefaultDecredFeeRate = lnwire.MilliAtom(1)

	// DefaultDecredTimeLockDelta is the default forwarding time lock
	// delta.
	DefaultDecredTimeLockDelta = 80
)

const (

	// maxDecredFundingAmount is a soft-limit of the maximum channel size
	// currently accepted on the Decred chain within the Lightning
	// Protocol. This limit is defined in BOLT-0002, and serves as an
	// initial precautionary limit while implementations are battle tested
	// in the real world.
	MaxDecredFundingAmount = dcrutil.Amount(1<<30) - 1

	// MaxDecredFundingAmountWumbo is a soft-limit on the maximum size of
	// wumbo channels. This limit is 500 DCR and is the only thing standing
	// between you and limitless channel size (apart from 21 million cap)
	MaxDecredFundingAmountWumbo = dcrutil.Amount(500 * 1e8)
)

const UnassignedConnID uint64 = 0

UnassignedConnID is the default connection ID that a request can have before it actually is submitted to the connmgr. TODO(conner): move into connmgr package, or better, add connmgr method for generating atomic IDs

Variables

var (
	// DefaultLndDir is the default directory where lnd tries to find its
	// configuration file and store its data. This is a directory in the
	// user's application data, for example:
	// C:\Users\<username>\AppData\Local\Lnd on Windows ~/.lnd on Linux
	// ~/Library/Application Support/Lnd on MacOS
	DefaultLndDir = dcrutil.AppDataDir("dcrlnd", false)

	// DefaultConfigFile is the default full path of lnd's configuration
	// file.
	DefaultConfigFile = filepath.Join(DefaultLndDir, lncfg.DefaultConfigFilename)
)

var (
	// MaxFundingAmount is a soft-limit of the maximum channel size
	// currently accepted within the Lightning Protocol. This limit is
	// defined in BOLT-0002, and serves as an initial precautionary limit
	// while implementations are battle tested in the real world.
	//
	// TODO(roasbeef): add command line param to modify
	MaxFundingAmount = MaxDecredFundingAmount

	// ErrFundingManagerShuttingDown is an error returned when attempting to
	// process a funding request/message but the funding manager has already
	// been signaled to shut down.
	ErrFundingManagerShuttingDown = errors.New("funding manager shutting " +
		"down")

	// ErrConfirmationTimeout is an error returned when we as a responder
	// are waiting for a funding transaction to confirm, but too many
	// blocks pass without confirmation.
	ErrConfirmationTimeout = errors.New("timeout waiting for funding " +
		"confirmation")
)

var (
	// ErrPeerNotConnected signals that the server has no connection to the
	// given peer.
	ErrPeerNotConnected = errors.New("peer is not connected")

	// ErrServerNotActive indicates that the server has started but hasn't
	// fully finished the startup process.
	ErrServerNotActive = errors.New("server is still in the process of " +
		"starting")

	// ErrServerShuttingDown indicates that the server is in the process of
	// gracefully exiting.
	ErrServerShuttingDown = errors.New("server is shutting down")
)

var (

	// ErrChannelNotFound is an error returned when a channel is not known
	// to us. In this case of the fundingManager, this error is returned
	// when the channel in question is not considered being in an opening
	// state.
	ErrChannelNotFound = fmt.Errorf("channel not found")
)

var (
	// ErrContractNotFound is returned when the nursery is unable to
	// retrieve information about a queried contract.
	ErrContractNotFound = fmt.Errorf("unable to locate contract")
)

var ErrImmatureChannel = errors.New("cannot remove immature channel, " +
	"still has ungraduated outputs")

ErrImmatureChannel signals a channel cannot be removed because not all of its outputs have graduated.

var (
	// MaxPaymentMAtoms is the maximum allowed payment currently permitted
	// as defined in BOLT-002. This value depends on which chain is active.
	// It is set to the value under the Decred chain as default.
	MaxPaymentMAtoms = maxDcrPaymentMAtoms
)

Functions

func AddSubLogger

func AddSubLogger(root *build.RotatingLogWriter, subsystem string,
	useLoggers ...func(slog.Logger))

AddSubLogger is a helper method to conveniently create and register the logger of one or more sub systems.

func AdminAuthOptions

func AdminAuthOptions(cfg *Config) ([]grpc.DialOption, error)

AdminAuthOptions returns a list of DialOptions that can be used to authenticate with the RPC server with admin capabilities.

NOTE: This should only be called after the RPCListener has signaled it is ready.

func CleanAndExpandPath

func CleanAndExpandPath(path string) string

CleanAndExpandPath expands environment variables and leading ~ in the passed path, cleans the result, and returns it. This function is taken from https://github.com/decred/dcrd

func GetChanPointFundingTxid

func GetChanPointFundingTxid(chanPoint *lnrpc.ChannelPoint) (*chainhash.Hash, error)

GetChanPointFundingTxid returns the given channel point's funding txid in raw bytes.

func Main

func Main(cfg *Config, lisCfg ListenerCfg, shutdownChan <-chan struct{}) error

Main is the true entry point for lnd. It accepts a fully populated and validated main configuration struct and an optional listener config struct. This function starts all main system components then blocks until a signal is received on the shutdownChan at which point everything is shut down again.

func MainRPCServerPermissions

func MainRPCServerPermissions() map[string][]bakery.Op

MainRPCServerPermissions returns a mapping of the main RPC server calls to the permissions they require.

func SetSubLogger

func SetSubLogger(root *build.RotatingLogWriter, subsystem string,
	logger slog.Logger, useLoggers ...func(slog.Logger))

SetSubLogger is a helper method to conveniently register the logger of a sub system.

func SetupLoggers

func SetupLoggers(root *build.RotatingLogWriter)

SetupLoggers initializes all package-global logger variables.

func WalletUnlockerAuthOptions

func WalletUnlockerAuthOptions(cfg *Config) ([]grpc.DialOption, error)

WalletUnlockerAuthOptions returns a list of DialOptions that can be used to authenticate with the wallet unlocker service.

NOTE: This should only be called after the WalletUnlocker listener has signaled it is ready.

Types

type BreachConfig

type BreachConfig struct {
	// CloseLink allows the breach arbiter to shutdown any channel links for
	// which it detects a breach, ensuring now further activity will
	// continue across the link. The method accepts link's channel point and
	// a close type to be included in the channel close summary.
	CloseLink func(*wire.OutPoint, htlcswitch.ChannelCloseType)

	// DB provides access to the user's channels, allowing the breach
	// arbiter to determine the current state of a user's channels, and how
	// it should respond to channel closure.
	DB *channeldb.DB

	// Estimator is used by the breach arbiter to determine an appropriate
	// fee level when generating, signing, and broadcasting sweep
	// transactions.
	Estimator chainfee.Estimator

	// GenSweepScript generates the receiving scripts for swept outputs.
	GenSweepScript func() ([]byte, error)

	// Notifier provides a publish/subscribe interface for event driven
	// notifications regarding the confirmation of txids.
	Notifier chainntnfs.ChainNotifier

	// PublishTransaction facilitates the process of broadcasting a
	// transaction to the network.
	PublishTransaction func(*wire.MsgTx, string) error

	// ContractBreaches is a channel where the breachArbiter will receive
	// notifications in the event of a contract breach being observed. A
	// ContractBreachEvent must be ACKed by the breachArbiter, such that
	// the sending subsystem knows that the event is properly handed off.
	ContractBreaches <-chan *ContractBreachEvent

	// Signer is used by the breach arbiter to generate sweep transactions,
	// which move coins from previously open channels back to the user's
	// wallet.
	Signer input.Signer

	// Store is a persistent resource that maintains information regarding
	// breached channels. This is used in conjunction with DB to recover
	// from crashes, restarts, or other failures.
	Store RetributionStore

	// NetParams is a reference to the network parameters for the chain this
	// breach arbiter runs on.
	NetParams *chaincfg.Params
}

BreachConfig bundles the required subsystems used by the breach arbiter. An instance of BreachConfig is passed to newBreachArbiter during instantiation.

type Config

type Config struct {
	ShowVersion bool `short:"V" long:"version" description:"Display version information and exit"`

	LndDir       string `long:"lnddir" description:"The base directory that contains lnd's data, logs, configuration file, etc."`
	ConfigFile   string `short:"C" long:"configfile" description:"Path to configuration file"`
	DataDir      string `short:"b" long:"datadir" description:"The directory to store lnd's data within"`
	SyncFreelist bool   `` /* 233-byte string literal not displayed */

	TLSCertPath        string   `long:"tlscertpath" description:"Path to write the TLS certificate for lnd's RPC and REST services"`
	TLSKeyPath         string   `long:"tlskeypath" description:"Path to write the TLS private key for lnd's RPC and REST services"`
	TLSExtraIPs        []string `long:"tlsextraip" description:"Adds an extra ip to the generated certificate"`
	TLSExtraDomains    []string `long:"tlsextradomain" description:"Adds an extra domain to the generated certificate"`
	TLSAutoRefresh     bool     `long:"tlsautorefresh" description:"Re-generate TLS certificate and key if the IPs or domains are changed"`
	TLSDisableAutofill bool     `` /* 173-byte string literal not displayed */

	NoMacaroons     bool          `long:"no-macaroons" description:"Disable macaroon authentication"`
	AdminMacPath    string        `long:"adminmacaroonpath" description:"Path to write the admin macaroon for lnd's RPC and REST services if it doesn't exist"`
	ReadMacPath     string        `` /* 130-byte string literal not displayed */
	InvoiceMacPath  string        `` /* 126-byte string literal not displayed */
	LogDir          string        `long:"logdir" description:"Directory to log output."`
	MaxLogFiles     int           `long:"maxlogfiles" description:"Maximum logfiles to keep (0 for no rotation)"`
	MaxLogFileSize  int           `long:"maxlogfilesize" description:"Maximum logfile size in MB"`
	AcceptorTimeout time.Duration `` /* 136-byte string literal not displayed */

	// IPC options
	PipeTx            *uint `long:"pipetx" description:"File descriptor or handle of write end pipe to enable child -> parent process communication"`
	PipeRx            *uint `long:"piperx" description:"File descriptor or handle of read end pipe to enable parent -> child process communication"`
	RPCListenerEvents bool  `long:"rpclistenerevents" description:"Notify JSON-RPC and gRPC listener addresses over the TX pipe"`

	// We'll parse these 'raw' string arguments into real net.Addrs in the
	// loadConfig function. We need to expose the 'raw' strings so the
	// command line library can access them.
	// Only the parsed net.Addrs should be used!
	RawRPCListeners  []string `long:"rpclisten" description:"Add an interface/port/socket to listen for RPC connections"`
	RawRESTListeners []string `long:"restlisten" description:"Add an interface/port/socket to listen for REST connections"`
	RawListeners     []string `long:"listen" description:"Add an interface/port to listen for peer connections"`
	RawExternalIPs   []string `` /* 200-byte string literal not displayed */
	ExternalHosts    []string `long:"externalhosts" description:"A set of hosts that should be periodically resolved to announce IPs for"`
	RPCListeners     []net.Addr
	RESTListeners    []net.Addr
	RestCORS         []string `long:"restcors" description:"Add an ip:port/hostname to allow cross origin access from. To allow all origins, set as \"*\"."`
	Listeners        []net.Addr
	ExternalIPs      []net.Addr
	DisableListen    bool          `long:"nolisten" description:"Disable listening for incoming peer connections"`
	DisableRest      bool          `long:"norest" description:"Disable REST API"`
	NAT              bool          `` /* 210-byte string literal not displayed */
	MinBackoff       time.Duration `long:"minbackoff" description:"Shortest backoff when reconnecting to persistent peers. Valid time units are {s, m, h}."`
	MaxBackoff       time.Duration `long:"maxbackoff" description:"Longest backoff when reconnecting to persistent peers. Valid time units are {s, m, h}."`

	DebugLevel string `` /* 275-byte string literal not displayed */

	CPUProfile string `long:"cpuprofile" description:"Write CPU profile to the specified file"`

	Profile string `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65535"`

	UnsafeDisconnect   bool   `` /* 170-byte string literal not displayed */
	UnsafeReplay       bool   `` /* 157-byte string literal not displayed */
	MaxPendingChannels int    `long:"maxpendingchannels" description:"The maximum number of incoming pending channels permitted per peer."`
	BackupFilePath     string `long:"backupfilepath" description:"The target location of the channel backup file"`

	ChainDir            string           `long:"chaindir" description:"The directory to store the chain's data within."`
	Node                string           `long:"node" description:"The blockchain interface to use." choice:"dcrd" choice:"dcrw"`
	TestNet3            bool             `long:"testnet" description:"Use the test network"`
	SimNet              bool             `long:"simnet" description:"Use the simulation test network"`
	RegTest             bool             `long:"regtest" description:"Use the regression test network"`
	DefaultNumChanConfs int              `` /* 197-byte string literal not displayed */
	DefaultRemoteDelay  int              `` /* 248-byte string literal not displayed */
	MinHTLCIn           lnwire.MilliAtom `long:"minhtlc" description:"The smallest HTLC we are willing to accept on our channels, in MilliAtoms"`
	MinHTLCOut          lnwire.MilliAtom `long:"minhtlcout" description:"The smallest HTLC we are willing to send out on our channels, in MilliAtoms"`
	BaseFee             lnwire.MilliAtom `long:"basefee" description:"The base fee in MilliAtom we will charge for forwarding payments on our channels"`
	FeeRate             lnwire.MilliAtom `` /* 191-byte string literal not displayed */
	TimeLockDelta       uint32           `long:"timelockdelta" description:"The CLTV delta we will subtract from a forwarded HTLC's timelock value"`

	DcrdMode  *lncfg.DcrdConfig      `group:"dcrd" namespace:"dcrd"`
	Dcrwallet *lncfg.DcrwalletConfig `group:"dcrwallet" namespace:"dcrwallet"`

	Autopilot *lncfg.AutoPilot `group:"Autopilot" namespace:"autopilot"`

	Tor *lncfg.Tor `group:"Tor" namespace:"tor"`

	SubRPCServers *subRPCServerConfigs `group:"subrpc"`

	Hodl *hodl.Config `group:"hodl" namespace:"hodl"`

	NoNetBootstrap bool `long:"nobootstrap" description:"If true, then automatic network bootstrapping will not be attempted."`

	NoSeedBackup bool `` /* 205-byte string literal not displayed */

	PaymentsExpirationGracePeriod time.Duration `` /* 190-byte string literal not displayed */
	TrickleDelay                  int           `long:"trickledelay" description:"Time in milliseconds between each release of announcements to the network"`
	ChanEnableTimeout             time.Duration `` /* 214-byte string literal not displayed */
	ChanDisableTimeout            time.Duration `` /* 338-byte string literal not displayed */
	ChanStatusSampleInterval      time.Duration `` /* 168-byte string literal not displayed */

	HeightHintCacheQueryDisable bool   `` /* 329-byte string literal not displayed */
	Alias                       string `long:"alias" description:"The node alias. Used as a moniker by peers and intelligence services"`
	Color                       string `` /* 139-byte string literal not displayed */
	MinChanSize                 int64  `` /* 145-byte string literal not displayed */
	MaxChanSize                 int64  `` /* 143-byte string literal not displayed */

	DefaultRemoteMaxHtlcs uint16 `` /* 243-byte string literal not displayed */

	NumGraphSyncPeers      int           `` /* 184-byte string literal not displayed */
	HistoricalSyncInterval time.Duration `` /* 213-byte string literal not displayed */

	IgnoreHistoricalGossipFilters bool `` /* 240-byte string literal not displayed */

	RejectPush bool `` /* 170-byte string literal not displayed */

	RejectHTLC bool `` /* 203-byte string literal not displayed */

	StaggerInitialReconnect bool `` /* 246-byte string literal not displayed */

	MaxOutgoingCltvExpiry uint32 `long:"max-cltv-expiry" description:"The maximum number of blocks funds could be locked up for when forwarding payments."`

	MaxChannelFeeAllocation float64 `` /* 224-byte string literal not displayed */

	DryRunMigration bool `` /* 230-byte string literal not displayed */

	EnableUpfrontShutdown bool `` /* 397-byte string literal not displayed */

	AcceptKeySend bool `long:"accept-keysend" description:"If true, spontaneous payments through keysend will be accepted. [experimental]"`

	KeysendHoldTime time.Duration `` /* 219-byte string literal not displayed */

	Routing *routing.Conf `group:"routing" namespace:"routing"`

	Workers *lncfg.Workers `group:"workers" namespace:"workers"`

	Caches *lncfg.Caches `group:"caches" namespace:"caches"`

	Prometheus lncfg.Prometheus `group:"prometheus" namespace:"prometheus"`

	WtClient *lncfg.WtClient `group:"wtclient" namespace:"wtclient"`

	Watchtower *lncfg.Watchtower `group:"watchtower" namespace:"watchtower"`

	ProtocolOptions *lncfg.ProtocolOptions `group:"protocol" namespace:"protocol"`

	AllowCircularRoute bool `` /* 128-byte string literal not displayed */

	HealthChecks *lncfg.HealthCheckConfig `group:"healthcheck" namespace:"healthcheck"`

	DB *lncfg.DB `group:"db" namespace:"db"`

	// LogWriter is the root logger that all of the daemon's subloggers are
	// hooked up to.
	LogWriter *build.RotatingLogWriter
	// contains filtered or unexported fields
}

Config defines the configuration options for lnd.

See LoadConfig for further details regarding the configuration loading+parsing process.

func DefaultConfig

func DefaultConfig() Config

DefaultConfig returns all default values for the Config struct.

func LoadConfig

func LoadConfig() (*Config, error)

LoadConfig initializes and parses the config using a config file and command line options.

The configuration proceeds as follows:

1. Start with a default config with sane settings
2. Pre-parse the command line to check for an alternative config file
3. Load configuration file overwriting defaults with any specified options
4. Parse CLI options and overwrite/add any specified options

func ValidateConfig

func ValidateConfig(cfg Config, usageMessage string) (*Config, error)

ValidateConfig check the given configuration to be sane. This makes sure no illegal values or combination of values are set. All file system paths are normalized. The cleaned up config is returned on success.

type ContractBreachEvent

type ContractBreachEvent struct {
	// ChanPoint is the channel point of the breached channel.
	ChanPoint wire.OutPoint

	// ProcessACK is an error channel where a nil error should be sent
	// iff the breach retribution info is safely stored in the retribution
	// store. In case storing the information to the store fails, a non-nil
	// error should be sent.
	ProcessACK chan error

	// BreachRetribution is the information needed to act on this contract
	// breach.
	BreachRetribution *lnwallet.BreachRetribution
}

ContractBreachEvent is an event the breachArbiter will receive in case a contract breach is observed on-chain. It contains the necessary information to handle the breach, and a ProcessACK channel we will use to ACK the event when we have safely stored all the necessary information.

type GrpcRegistrar

type GrpcRegistrar interface {
	// RegisterGrpcSubserver is called for each net.Listener on which lnd
	// creates a grpc.Server instance. External subservers implementing this
	// method can then register their own gRPC server structs to the main
	// server instance.
	RegisterGrpcSubserver(*grpc.Server) error
}

GrpcRegistrar is an interface that must be satisfied by an external subserver that wants to be able to register its own gRPC server onto lnd's main grpc.Server instance.

type ListenerCfg

type ListenerCfg struct {
	// WalletUnlocker can be set to the listener to use for the wallet
	// unlocker. If nil a regular network listener will be created.
	WalletUnlocker *ListenerWithSignal

	// RPCListener can be set to the listener to use for the RPC server. If
	// nil a regular network listener will be created.
	RPCListener *ListenerWithSignal
}

ListenerCfg is a wrapper around custom listeners that can be passed to lnd when calling its main method.

type ListenerWithSignal

type ListenerWithSignal struct {
	net.Listener

	// Ready will be closed by the server listening on Listener.
	Ready chan struct{}

	// ExternalRPCSubserverCfg is optional and specifies the registration
	// callback and permissions to register external gRPC subservers.
	ExternalRPCSubserverCfg *RPCSubserverConfig

	// ExternalRestRegistrar is optional and specifies the registration
	// callback to register external REST subservers.
	ExternalRestRegistrar RestRegistrar
}

ListenerWithSignal is a net.Listener that has an additional Ready channel that will be closed when a server starts listening.

type NurseryConfig

type NurseryConfig struct {
	// ChainIO is used by the utxo nursery to determine the current block
	// height, which drives the incubation of the nursery's outputs.
	ChainIO lnwallet.BlockChainIO

	// ConfDepth is the number of blocks the nursery store waits before
	// determining outputs in the chain as confirmed.
	ConfDepth uint32

	// FetchClosedChannels provides access to a user's channels, such that
	// they can be marked fully closed after incubation has concluded.
	FetchClosedChannels func(pendingOnly bool) (
		[]*channeldb.ChannelCloseSummary, error)

	// FetchClosedChannel provides access to the close summary to extract a
	// height hint from.
	FetchClosedChannel func(chanID *wire.OutPoint) (
		*channeldb.ChannelCloseSummary, error)

	// Notifier provides the utxo nursery the ability to subscribe to
	// transaction confirmation events, which advance outputs through their
	// persistence state transitions.
	Notifier chainntnfs.ChainNotifier

	// PublishTransaction facilitates the process of broadcasting a signed
	// transaction to the appropriate network.
	PublishTransaction func(*wire.MsgTx, string) error

	// Store provides access to and modification of the persistent state
	// maintained about the utxo nursery's incubating outputs.
	Store NurseryStore

	// Sweep sweeps an input back to the wallet.
	SweepInput func(input.Input, sweep.Params) (chan sweep.Result, error)
}

NurseryConfig abstracts the required subsystems used by the utxo nursery. An instance of NurseryConfig is passed to newUtxoNursery during instantiation.

type NurseryStore

type NurseryStore interface {
	// Incubate registers a set of CSV delayed outputs (incoming HTLC's on
	// our commitment transaction, or a commitment output), and a slice of
	// outgoing htlc outputs to be swept back into the user's wallet. The
	// event is persisted to disk, such that the nursery can resume the
	// incubation process after a potential crash.
	Incubate([]kidOutput, []babyOutput) error

	// CribToKinder atomically moves a babyOutput in the crib bucket to the
	// kindergarten bucket. Baby outputs are outgoing HTLC's which require
	// us to go to the second-layer to claim. The now mature kidOutput
	// contained in the babyOutput will be stored as it waits out the
	// kidOutput's CSV delay.
	CribToKinder(*babyOutput) error

	// PreschoolToKinder atomically moves a kidOutput from the preschool
	// bucket to the kindergarten bucket. This transition should be executed
	// after receiving confirmation of the preschool output. Incoming HTLC's
	// we need to go to the second-layer to claim, and also our commitment
	// outputs fall into this class.
	//
	// An additional parameter specifies the last graduated height. This is
	// used in case of late registration. It schedules the output for sweep
	// at the next epoch even though it has already expired earlier.
	PreschoolToKinder(kid *kidOutput, lastGradHeight uint32) error

	// GraduateKinder atomically moves an output at the provided height into
	// the graduated status. This involves removing the kindergarten entries
	// from both the height and channel indexes. The height bucket will be
	// opportunistically pruned from the height index as outputs are
	// removed.
	GraduateKinder(height uint32, output *kidOutput) error

	// FetchPreschools returns a list of all outputs currently stored in
	// the preschool bucket.
	FetchPreschools() ([]kidOutput, error)

	// FetchClass returns a list of kindergarten and crib outputs whose
	// timelocks expire at the given height.
	FetchClass(height uint32) ([]kidOutput, []babyOutput, error)

	// HeightsBelowOrEqual returns the lowest non-empty heights in the
	// height index, that exist at or below the provided upper bound.
	HeightsBelowOrEqual(height uint32) ([]uint32, error)

	// ForChanOutputs iterates over all outputs being incubated for a
	// particular channel point. This method accepts a callback that allows
	// the caller to process each key-value pair. The key will be a prefixed
	// outpoint, and the value will be the serialized bytes for an output,
	// whose type should be inferred from the key's prefix.
	ForChanOutputs(*wire.OutPoint, func([]byte, []byte) error) error

	// ListChannels returns all channels the nursery is currently tracking.
	ListChannels() ([]wire.OutPoint, error)

	// IsMatureChannel determines the whether or not all of the outputs in a
	// particular channel bucket have been marked as graduated.
	IsMatureChannel(*wire.OutPoint) (bool, error)

	// RemoveChannel channel erases all entries from the channel bucket for
	// the provided channel point, this method should only be called if
	// IsMatureChannel indicates the channel is ready for removal.
	RemoveChannel(*wire.OutPoint) error
}

NurseryStore abstracts the persistent storage layer for the utxo nursery. Concretely, it stores commitment and htlc outputs until any time-bounded constraints have fully matured. The store exposes methods for enumerating its contents, and persisting state transitions detected by the utxo nursery.

type RPCSubserverConfig

type RPCSubserverConfig struct {
	// Registrar is a callback that is invoked for each net.Listener on
	// which lnd creates a grpc.Server instance.
	Registrar GrpcRegistrar

	// Permissions is the permissions required for the external subserver.
	// It is a map between the full HTTP URI of each RPC and its required
	// macaroon permissions. If multiple action/entity tuples are specified
	// per URI, they are all required. See rpcserver.go for a list of valid
	// action and entity values.
	Permissions map[string][]bakery.Op

	// MacaroonValidator is a custom macaroon validator that should be used
	// instead of the default lnd validator. If specified, the custom
	// validator is used for all URIs specified in the above Permissions
	// map.
	MacaroonValidator macaroons.MacaroonValidator
}

RPCSubserverConfig is a struct that can be used to register an external subserver with the custom permissions that map to the gRPC server that is going to be registered with the GrpcRegistrar.

type RestRegistrar

type RestRegistrar interface {
	// RegisterRestSubserver is called after lnd creates the main
	// proxy.ServeMux instance. External subservers implementing this method
	// can then register their own REST proxy stubs to the main server
	// instance.
	RegisterRestSubserver(context.Context, *proxy.ServeMux, string,
		[]grpc.DialOption) error
}

RestRegistrar is an interface that must be satisfied by an external subserver that wants to be able to register its own REST mux onto lnd's main proxy.ServeMux instance.

type RetributionStore

type RetributionStore interface {
	// Add persists the retributionInfo to disk, using the information's
	// chanPoint as the key. This method should overwrite any existing
	// entries found under the same key, and an error should be raised if
	// the addition fails.
	Add(retInfo *retributionInfo) error

	// IsBreached queries the retribution store to see if the breach arbiter
	// is aware of any breaches for the provided channel point.
	IsBreached(chanPoint *wire.OutPoint) (bool, error)

	// Finalize persists the finalized justice transaction for a particular
	// channel.
	Finalize(chanPoint *wire.OutPoint, finalTx *wire.MsgTx) error

	// GetFinalizedTxn loads the finalized justice transaction, if any, from
	// the retribution store. The finalized transaction will be nil if
	// Finalize has not yet been called for this channel point.
	GetFinalizedTxn(chanPoint *wire.OutPoint) (*wire.MsgTx, error)

	// Remove deletes the retributionInfo from disk, if any exists, under
	// the given key. An error should be re raised if the removal fails.
	Remove(key *wire.OutPoint) error

	// ForAll iterates over the existing on-disk contents and applies a
	// chosen, read-only callback to each. This method should ensure that it
	// immediately propagate any errors generated by the callback.
	ForAll(cb func(*retributionInfo) error) error
}

RetributionStore provides an interface for managing a persistent map from wire.OutPoint -> retributionInfo. Upon learning of a breach, a BreachArbiter should record the retributionInfo for the breached channel, which serves a checkpoint in the event that retribution needs to be resumed after failure. A RetributionStore provides an interface for managing the persisted set, as well as mapping user defined functions over the entire on-disk contents.

Calls to RetributionStore may occur concurrently. A concrete instance of RetributionStore should use appropriate synchronization primitives, or be otherwise safe for concurrent access.

type WalletUnlockParams

type WalletUnlockParams struct {
	// Password is the public and private wallet passphrase.
	Password []byte

	// Birthday specifies the approximate time that this wallet was created.
	// This is used to bound any rescans on startup.
	Birthday time.Time

	// RecoveryWindow specifies the address lookahead when entering recovery
	// mode. A recovery will be attempted if this value is non-zero.
	RecoveryWindow uint32

	// Wallet is the loaded and unlocked Wallet. This is returned
	// from the unlocker service to avoid it being unlocked twice (once in
	// the unlocker service to check if the password is correct and again
	// later when lnd actually uses it). Because unlocking involves scrypt
	// which is resource intensive, we want to avoid doing it twice.
	Wallet *wallet.Wallet

	// Loader is the wallet loader used to create or open the corresponding
	// wallet.
	Loader *walletloader.Loader

	// Conn is the connection to the remote wallet when that is used
	// instead of an embedded dcrwallet instance.
	Conn *grpc.ClientConn

	// ChansToRestore a set of static channel backups that should be
	// restored before the main server instance starts up.
	ChansToRestore walletunlocker.ChannelsToRecover
}

WalletUnlockParams holds the variables used to parameterize the unlocking of lnd's wallet after it has already been created.