lncfg

package
v0.12.1-beta.rc2 Latest Latest
Warning

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

 Go to latest Published: Feb 11, 2021 License: MIT Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// MinRejectCacheSize is a floor on the maximum capacity allowed for
	// channeldb's reject cache. This amounts to roughly 125 KB when full.
	MinRejectCacheSize = 5000

	// MinChannelCacheSize is a floor on the maximum capacity allowed for
	// channeldb's channel cache. This amounts to roughly 2 MB when full.
	MinChannelCacheSize = 1000
)
View Source 
const (
	// DefaultConfigFilename is the default configuration file name lnd
	// tries to load.
	DefaultConfigFilename = "lnd.conf"

	// DefaultMaxPendingChannels is the default maximum number of incoming
	// pending channels permitted per peer.
	DefaultMaxPendingChannels = 1

	// DefaultIncomingBroadcastDelta defines the number of blocks before the
	// expiry of an incoming htlc at which we force close the channel. We
	// only go to chain if we also have the preimage to actually pull in the
	// htlc. BOLT #2 suggests 7 blocks. We use a few more for extra safety.
	// Within this window we need to get our sweep or 2nd level success tx
	// confirmed, because after that the remote party is also able to claim
	// the htlc using the timeout path.
	DefaultIncomingBroadcastDelta = 10

	// DefaultFinalCltvRejectDelta defines the number of blocks before the
	// expiry of an incoming exit hop htlc at which we cancel it back
	// immediately. It is an extra safety measure over the final cltv
	// requirement as it is defined in the invoice. It ensures that we
	// cancel back htlcs that, when held on to, may cause us to force close
	// the channel because we enter the incoming broadcast window. Bolt #11
	// suggests 9 blocks here. We use a few more for additional safety.
	//
	// There is still a small gap that remains between receiving the
	// RevokeAndAck and canceling back. If a new block arrives within that
	// window, we may still force close the channel. There is currently no
	// way to reject an UpdateAddHtlc of which we already know that it will
	// push us in the broadcast window.
	DefaultFinalCltvRejectDelta = DefaultIncomingBroadcastDelta + 3

	// DefaultOutgoingBroadcastDelta defines the number of blocks before the
	// expiry of an outgoing htlc at which we force close the channel. We
	// are not in a hurry to force close, because there is nothing to claim
	// for us. We do need to time the htlc out, because there may be an
	// incoming htlc that will time out too (albeit later). Bolt #2 suggests
	// a value of -1 here, but we allow one block less to prevent potential
	// confusion around the negative value. It means we force close the
	// channel at exactly the htlc expiry height.
	DefaultOutgoingBroadcastDelta = 0

	// DefaultOutgoingCltvRejectDelta defines the number of blocks before
	// the expiry of an outgoing htlc at which we don't want to offer it to
	// the next peer anymore. If that happens, we cancel back the incoming
	// htlc. This is to prevent the situation where we have an outstanding
	// htlc that brings or will soon bring us inside the outgoing broadcast
	// window and trigger us to force close the channel. Bolt #2 suggests a
	// value of 0. We pad it a bit, to prevent a slow round trip to the next
	// peer and a block arriving during that round trip to trigger force
	// closure.
	DefaultOutgoingCltvRejectDelta = DefaultOutgoingBroadcastDelta + 3
)
View Source 
const (
	BoltBackend                = "bolt"
	EtcdBackend                = "etcd"
	DefaultBatchCommitInterval = 500 * time.Millisecond
)
View Source 
const (
	// DefaultReadWorkers is the default maximum number of concurrent
	// workers used by the daemon's read pool.
	DefaultReadWorkers = 100

	// DefaultWriteWorkers is the default maximum number of concurrent
	// workers used by the daemon's write pool.
	DefaultWriteWorkers = 8

	// DefaultSigWorkers is the default maximum number of concurrent workers
	// used by the daemon's sig pool.
	DefaultSigWorkers = 8
)

Variables

View Source 
var (
	// MinHealthCheckInterval is the minimum interval we allow between
	// health checks.
	MinHealthCheckInterval = time.Minute

	// MinHealthCheckTimeout is the minimum timeout we allow for health
	// check calls.
	MinHealthCheckTimeout = time.Second

	// MinHealthCheckBackoff is the minimum back off we allow between health
	// check retries.
	MinHealthCheckBackoff = time.Second
)

Functions

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/btcsuite/btcd

func ClientAddressDialer 

func ClientAddressDialer(defaultPort string) func(context.Context,
	string) (net.Conn, error)

ClientAddressDialer creates a gRPC dialer that can also dial unix socket addresses instead of just TCP addresses.

func EnforceSafeAuthentication 

func EnforceSafeAuthentication(addrs []net.Addr, macaroonsActive,
	tlsActive bool) error

EnforceSafeAuthentication enforces "safe" authentication taking into account the interfaces that the RPC servers are listening on, and if macaroons and TLS is activated or not. To protect users from using dangerous config combinations, we'll prevent disabling authentication if the server is listening on a public interface.

func IsLoopback 

func IsLoopback(addr string) bool

IsLoopback returns true if an address describes a loopback interface.

func IsPrivate 

func IsPrivate(addr net.Addr) bool

IsPrivate returns true if the address is private. The definitions are, 

https://en.wikipedia.org/wiki/Link-local_address
https://en.wikipedia.org/wiki/Multicast_address
Local IPv4 addresses, https://tools.ietf.org/html/rfc1918
Local IPv6 addresses, https://tools.ietf.org/html/rfc4193

func IsUnix 

func IsUnix(addr net.Addr) bool

IsUnix returns true if an address describes an Unix socket address.

func ListenOnAddress 

func ListenOnAddress(addr net.Addr) (net.Listener, error)

ListenOnAddress creates a listener that listens on the given address.

func NormalizeAddresses 

func NormalizeAddresses(addrs []string, defaultPort string,
	tcpResolver TCPResolver) ([]net.Addr, error)

NormalizeAddresses returns a new slice with all the passed addresses normalized with the given default port and all duplicates removed.

func NormalizeNetwork 

func NormalizeNetwork(network string) string

NormalizeNetwork returns the common name of a network type used to create file paths. This allows differently versioned networks to use the same path.

func ParseAddressString 

func ParseAddressString(strAddress string, defaultPort string,
	tcpResolver TCPResolver) (net.Addr, error)

ParseAddressString converts an address in string format to a net.Addr that is compatible with lnd. UDP is not supported because lnd needs reliable connections. We accept a custom function to resolve any TCP addresses so that caller is able control exactly how resolution is performed.

func ParseLNAddressString 

func ParseLNAddressString(strAddress string, defaultPort string,
	tcpResolver TCPResolver) (*lnwire.NetAddress, error)

ParseLNAddressString converts a string of the form <pubkey>@<addr> into an lnwire.NetAddress. The <pubkey> must be presented in hex, and result in a 33-byte, compressed public key that lies on the secp256k1 curve. The <addr> may be any address supported by ParseAddressString. If no port is specified, the defaultPort will be used. Any tcp addresses that need resolving will be resolved using the custom TCPResolver.

func TLSListenOnAddress 

func TLSListenOnAddress(addr net.Addr,
	config *tls.Config) (net.Listener, error)

TLSListenOnAddress creates a TLS listener that listens on the given address.

func Validate 

func Validate(validators ...Validator) error

Validate accepts a variadic list of Validators and checks that each one passes its Validate method. An error is returned from the first Validator that fails.

Types

type AutoPilot 

type AutoPilot struct {
	Active         bool               `long:"active" description:"If the autopilot agent should be active or not."`
	Heuristic      map[string]float64 `long:"heuristic" description:"Heuristic to activate, and the weight to give it during scoring."`
	MaxChannels    int                `long:"maxchannels" description:"The maximum number of channels that should be created"`
	Allocation     float64            `long:"allocation" description:"The percentage of total funds that should be committed to automatic channel establishment"`
	MinChannelSize int64              `long:"minchansize" description:"The smallest channel that the autopilot agent should create"`
	MaxChannelSize int64              `long:"maxchansize" description:"The largest channel that the autopilot agent should create"`
	Private        bool               `` /* 158-byte string literal not displayed */
	MinConfs       int32              `` /* 151-byte string literal not displayed */
	ConfTarget     uint32             `long:"conftarget" description:"The confirmation target (in blocks) for channels opened by autopilot."`
}

AutoPilot holds the configuration options for the daemon's autopilot.

type Bitcoind 

type Bitcoind struct {
	Dir            string `long:"dir" description:"The base directory that contains the node's data, logs, configuration file, etc."`
	RPCHost        string `` /* 156-byte string literal not displayed */
	RPCUser        string `long:"rpcuser" description:"Username for RPC connections"`
	RPCPass        string `long:"rpcpass" default-mask:"-" description:"Password for RPC connections"`
	ZMQPubRawBlock string `long:"zmqpubrawblock" description:"The address listening for ZMQ connections to deliver raw block notifications"`
	ZMQPubRawTx    string `long:"zmqpubrawtx" description:"The address listening for ZMQ connections to deliver raw transaction notifications"`
	EstimateMode   string `long:"estimatemode" description:"The fee estimate mode. Must be either ECONOMICAL or CONSERVATIVE."`
}

Bitcoind holds the configuration options for the daemon's connection to bitcoind.

type Btcd 

type Btcd struct {
	Dir        string `long:"dir" description:"The base directory that contains the node's data, logs, configuration file, etc."`
	RPCHost    string `` /* 156-byte string literal not displayed */
	RPCUser    string `long:"rpcuser" description:"Username for RPC connections"`
	RPCPass    string `long:"rpcpass" default-mask:"-" description:"Password for RPC connections"`
	RPCCert    string `long:"rpccert" description:"File containing the daemon's certificate file"`
	RawRPCCert string `` /* 146-byte string literal not displayed */
}

Btcd holds the configuration options for the daemon's connection to btcd.

type Caches 

type Caches struct {
	// RejectCacheSize is the maximum number of entries stored in lnd's
	// reject cache, which is used for efficiently rejecting gossip updates.
	// Memory usage is roughly 25b per entry.
	RejectCacheSize int `` /* 222-byte string literal not displayed */

	// ChannelCacheSize is the maximum number of entries stored in lnd's
	// channel cache, which is used reduce memory allocations in reply to
	// peers querying for gossip traffic. Memory usage is roughly 2Kb per
	// entry.
	ChannelCacheSize int `` /* 205-byte string literal not displayed */
}

Caches holds the configuration for various caches within lnd.

func (*Caches) Validate 

func (c *Caches) Validate() error

Validate checks the Caches configuration for values that are too small to be sane.

type Chain 

type Chain struct {
	Active   bool   `long:"active" description:"If the chain should be active or not."`
	ChainDir string `long:"chaindir" description:"The directory to store the chain's data within."`

	Node string `` /* 141-byte string literal not displayed */

	MainNet  bool `long:"mainnet" description:"Use the main network"`
	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 */
	MaxLocalDelay       uint16              `` /* 224-byte string literal not displayed */
	MinHTLCIn           lnwire.MilliSatoshi `long:"minhtlc" description:"The smallest HTLC we are willing to accept on our channels, in millisatoshi"`
	MinHTLCOut          lnwire.MilliSatoshi `long:"minhtlcout" description:"The smallest HTLC we are willing to send out on our channels, in millisatoshi"`
	BaseFee             lnwire.MilliSatoshi `long:"basefee" description:"The base fee in millisatoshi we will charge for forwarding payments on our channels"`
	FeeRate             lnwire.MilliSatoshi `` /* 191-byte string literal not displayed */
	TimeLockDelta       uint32              `long:"timelockdelta" description:"The CLTV delta we will subtract from a forwarded HTLC's timelock value"`
	DNSSeeds            []string            `` /* 325-byte string literal not displayed */
}

Chain holds the configuration options for the daemon's chain settings.

func (*Chain) Validate 

func (c *Chain) Validate(minTimeLockDelta uint32, minDelay uint16) error

Validate performs validation on our chain config.

type CheckConfig 

type CheckConfig struct {
	Interval time.Duration `long:"interval" description:"How often to run a health check."`

	Attempts int `` /* 132-byte string literal not displayed */

	Timeout time.Duration `long:"timeout" description:"The amount of time we allow the health check to take before failing due to timeout."`

	Backoff time.Duration `long:"backoff" description:"The amount of time to back-off between failed health checks."`
}

type DB 

type DB struct {
	Backend string `long:"backend" description:"The selected database backend."`

	BatchCommitInterval time.Duration `` /* 224-byte string literal not displayed */

	Etcd *kvdb.EtcdConfig `group:"etcd" namespace:"etcd" description:"Etcd settings."`

	Bolt *kvdb.BoltConfig `group:"bolt" namespace:"bolt" description:"Bolt settings."`
}

DB holds database configuration for LND.

func DefaultDB 

func DefaultDB() *DB

NewDB creates and returns a new default DB config.

func (*DB) GetBackends 

func (db *DB) GetBackends(ctx context.Context, dbPath string,
	networkName string) (*DatabaseBackends, error)

GetBackends returns a set of kvdb.Backends as set in the DB config. The local database will ALWAYS be non-nil, while the remote database will only be populated if etcd is specified.

func (*DB) Validate 

func (db *DB) Validate() error

Validate validates the DB config.

type DatabaseBackends 

type DatabaseBackends struct {
	// LocalDB points to the local non-replicated backend.
	LocalDB kvdb.Backend

	// RemoteDB points to a possibly networked replicated backend. If no
	// replicated backend is active, then this pointer will be nil.
	RemoteDB kvdb.Backend
}

DatabaseBackends is a two-tuple that holds the set of active database backends for the daemon. The two backends we expose are the local database backend, and the remote backend. The LocalDB attribute will always be populated. However, the remote DB will only be set if a replicated database is active.

type DiskCheckConfig 

type DiskCheckConfig struct {
	RequiredRemaining float64 `` /* 135-byte string literal not displayed */

	*CheckConfig
}

DiskCheckConfig contains configuration for ensuring that our node has sufficient disk space.

type ExperimentalProtocol 

type ExperimentalProtocol struct {
}

ExperimentalProtocol is a sub-config that houses any experimental protocol features that also require a build-tag to activate.

type Gossip 

type Gossip struct {
	PinnedSyncersRaw []string `` /* 380-byte string literal not displayed */

	PinnedSyncers discovery.PinnedSyncers
}

func (*Gossip) Parse 

func (g *Gossip) Parse() error

Parse the pubkeys for the pinned syncers.

type HealthCheckConfig 

type HealthCheckConfig struct {
	ChainCheck *CheckConfig `group:"chainbackend" namespace:"chainbackend"`

	DiskCheck *DiskCheckConfig `group:"diskspace" namespace:"diskspace"`

	TLSCheck *CheckConfig `group:"tls" namespace:"tls"`
}

HealthCheckConfig contains the configuration for the different health checks the lnd runs.

func (*HealthCheckConfig) Validate 

func (h *HealthCheckConfig) Validate() error

Validate checks the values configured for our health checks.

type LegacyProtocol 

type LegacyProtocol struct {
}

Legacy is a sub-config that houses all the legacy protocol options. These are mostly used for integration tests as most modern nodes shuld always run with them on by default.

func (*LegacyProtocol) LegacyOnion 

func (l *LegacyProtocol) LegacyOnion() bool

LegacyOnion returns true if the old legacy onion format should be used when we're an intermediate or final hop. This controls if we set the TLVOnionPayloadOptional bit or not.

func (*LegacyProtocol) NoStaticRemoteKey 

func (l *LegacyProtocol) NoStaticRemoteKey() bool

NoStaticRemoteKey returns true if the old commitment format with a tweaked remote key should be used for new funded channels.

type Neutrino 

type Neutrino struct {
	AddPeers           []string      `short:"a" long:"addpeer" description:"Add a peer to connect with at startup"`
	ConnectPeers       []string      `long:"connect" description:"Connect only to the specified peers at startup"`
	MaxPeers           int           `long:"maxpeers" description:"Max number of inbound and outbound peers"`
	BanDuration        time.Duration `long:"banduration" description:"How long to ban misbehaving peers.  Valid time units are {s, m, h}.  Minimum 1 second"`
	BanThreshold       uint32        `long:"banthreshold" description:"Maximum allowed ban score before disconnecting and banning misbehaving peers."`
	FeeURL             string        `` /* 171-byte string literal not displayed */
	AssertFilterHeader string        `` /* 253-byte string literal not displayed */
	UserAgentName      string        `long:"useragentname" description:"Used to help identify ourselves to other bitcoin peers"`
	UserAgentVersion   string        `long:"useragentversion" description:"Used to help identify ourselves to other bitcoin peers"`
}

Neutrino holds the configuration options for the daemon's connection to neutrino.

type Prometheus 

type Prometheus struct{}

Prometheus configures the Prometheus exporter when monitoring is enabled. Monitoring is currently disabled.

func DefaultPrometheus 

func DefaultPrometheus() Prometheus

DefaultPrometheus is the default configuration for the Prometheus metrics exporter when monitoring is enabled. Monitoring is currently disabled.

func (*Prometheus) Enabled 

func (p *Prometheus) Enabled() bool

Enabled returns whether or not Prometheus monitoring is enabled. Monitoring is currently disabled, so Enabled will always return false.

type ProtocolOptions 

type ProtocolOptions struct {
	// LegacyProtocol is a sub-config that houses all the legacy protocol
	// options.  These are mostly used for integration tests as most modern
	// nodes shuld always run with them on by default.
	LegacyProtocol `group:"legacy" namespace:"legacy"`

	// ExperimentalProtocol is a sub-config that houses any experimental
	// protocol features that also require a build-tag to activate.
	ExperimentalProtocol

	// WumboChans should be set if we want to enable support for wumbo
	// (channels larger than 0.16 BTC) channels, which is the opposite of
	// mini.
	WumboChans bool `long:"wumbo-channels" description:"if set, then lnd will create and accept requests for channels larger chan 0.16 BTC"`

	// Anchors enables anchor commitments.
	Anchors bool `long:"anchors" description:"enable support for anchor commitments"`
}

ProtocolOptions is a struct that we use to be able to test backwards compatibility of protocol additions, while defaulting to the latest within lnd, or to enable experimental protocol changes.

func (*ProtocolOptions) NoAnchorCommitments 

func (l *ProtocolOptions) NoAnchorCommitments() bool

NoAnchorCommitments returns true if we have disabled support for the anchor commitment type.

func (*ProtocolOptions) Wumbo 

func (l *ProtocolOptions) Wumbo() bool

Wumbo returns true if lnd should permit the creation and acceptance of wumbo channels.

type Routing 

type Routing struct {
	AssumeChannelValid bool `` /* 198-byte string literal not displayed */
}

Routing holds the configuration options for routing.

type TCPResolver 

type TCPResolver = func(network, addr string) (*net.TCPAddr, error)

TCPResolver is a function signature that resolves an address on a given network.

type Tor 

type Tor struct {
	Active            bool   `long:"active" description:"Allow outbound and inbound connections to be routed through Tor"`
	SOCKS             string `long:"socks" description:"The host:port that Tor's exposed SOCKS5 proxy is listening on"`
	DNS               string `` /* 126-byte string literal not displayed */
	StreamIsolation   bool   `long:"streamisolation" description:"Enable Tor stream isolation by randomizing user credentials for each connection."`
	Control           string `long:"control" description:"The host:port that Tor is listening on for Tor control connections"`
	TargetIPAddress   string `long:"targetipaddress" description:"IP address that Tor should use as the target of the hidden service"`
	Password          string `` /* 206-byte string literal not displayed */
	V2                bool   `long:"v2" description:"Automatically set up a v2 onion service to listen for inbound connections"`
	V3                bool   `long:"v3" description:"Automatically set up a v3 onion service to listen for inbound connections"`
	PrivateKeyPath    string `long:"privatekeypath" description:"The path to the private key of the onion service being created"`
	WatchtowerKeyPath string `long:"watchtowerkeypath" description:"The path to the private key of the watchtower onion service being created"`
}

Tor holds the configuration options for the daemon's connection to tor.

type Validator 

type Validator interface {
	// Validate returns an error if a particular configuration is invalid or
	// insane.
	Validate() error
}

Validator is a generic interface for validating sub configurations.

type Watchtower 

type Watchtower struct {
	Active bool `long:"active" description:"If the watchtower should be active or not"`

	TowerDir string `long:"towerdir" description:"Directory of the watchtower.db"`

	watchtower.Conf
}

Watchtower holds the daemon specific configuration parameters for running a watchtower that shares resources with the daemon.

type Workers 

type Workers struct {
	// Read is the maximum number of concurrent read pool workers.
	Read int `` /* 132-byte string literal not displayed */

	// Write is the maximum number of concurrent write pool workers.
	Write int `` /* 146-byte string literal not displayed */

	// Sig is the maximum number of concurrent sig pool workers.
	Sig int `` /* 141-byte string literal not displayed */
}

Workers exposes CLI configuration for turning resources consumed by worker pools.

func (*Workers) Validate 

func (w *Workers) Validate() error

Validate checks the Workers configuration to ensure that the input values are sane.

type WtClient 

type WtClient struct {
	// Active determines whether a watchtower client should be created to
	// back up channel states with registered watchtowers.
	Active bool `long:"active" description:"Whether the daemon should use private watchtowers to back up revoked channel states."`

	// PrivateTowerURIs specifies the lightning URIs of the towers the
	// watchtower client should send new backups to.
	PrivateTowerURIs []string `` /* 263-byte string literal not displayed */

	// SweepFeeRate specifies the fee rate in sat/byte to be used when
	// constructing justice transactions sent to the tower.
	SweepFeeRate uint64 `` /* 144-byte string literal not displayed */
}

WtClient holds the configuration options for the daemon's watchtower client.

func (*WtClient) Validate 

func (c *WtClient) Validate() error

Validate ensures the user has provided a valid configuration.

NOTE: Part of the Validator 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.