chainreg

package
v0.12.0-beta Latest Latest
Warning

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

 Go to latest Published: Feb 2, 2021 License: MIT Imports: 37 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// DefaultBitcoinMinHTLCInMSat is the default smallest value htlc this
	// node will accept. This value is proposed in the channel open sequence
	// and cannot be changed during the life of the channel. It is 1 msat by
	// default to allow maximum flexibility in deciding what size payments
	// to forward.
	//
	// All forwarded payments are subjected to the min htlc constraint of
	// the routing policy of the outgoing channel. This implicitly controls
	// the minimum htlc value on the incoming channel too.
	DefaultBitcoinMinHTLCInMSat = lnwire.MilliSatoshi(1)

	// DefaultBitcoinMinHTLCOutMSat is the default minimum htlc value that
	// we require for sending out htlcs. Our channel peer may have a lower
	// min htlc channel parameter, but we - by default - don't forward
	// anything under the value defined here.
	DefaultBitcoinMinHTLCOutMSat = lnwire.MilliSatoshi(1000)

	// DefaultBitcoinBaseFeeMSat is the default forwarding base fee.
	DefaultBitcoinBaseFeeMSat = lnwire.MilliSatoshi(1000)

	// DefaultBitcoinFeeRate is the default forwarding fee rate.
	DefaultBitcoinFeeRate = lnwire.MilliSatoshi(1)

	// DefaultBitcoinTimeLockDelta is the default forwarding time lock
	// delta.
	DefaultBitcoinTimeLockDelta = 40

	DefaultMonacoinMinHTLCInMSat  = lnwire.MilliSatoshi(1)
	DefaultMonacoinMinHTLCOutMSat = lnwire.MilliSatoshi(1000)
	DefaultMonacoinBaseFeeMSat    = lnwire.MilliSatoshi(1000)
	DefaultMonacoinFeeRate        = lnwire.MilliSatoshi(1)
	DefaultMonacoinTimeLockDelta  = 960
	DefaultMonacoinDustLimit      = btcutil.Amount(54600)

	// DefaultBitcoinStaticFeePerKW is the fee rate of 50 sat/vbyte
	// expressed in sat/kw.
	DefaultBitcoinStaticFeePerKW = chainfee.SatPerKWeight(12500)

	// DefaultBitcoinStaticMinRelayFeeRate is the min relay fee used for
	// static estimators.
	DefaultBitcoinStaticMinRelayFeeRate = chainfee.FeePerKwFloor

	// defaultMonacoinStaticFeePerKW is the fee rate of 200 sat/vbyte
	// expressed in sat/kw.
	DefaultMonacoinStaticFeePerKW = chainfee.SatPerKWeight(50000)

	// BtcToMonaConversionRate is a fixed ratio used in order to scale up
	// payments when running on the Monacoin chain.
	BtcToMonaConversionRate = 600
)
View Source 
const Subsystem = "CHRE"

Subsystem defines the logging code for this subsystem.

Variables

View Source 
var (
	// BitcoinSignetGenesis is the genesis hash of Bitcoin's testnet
	// chain.
	BitcoinSignetGenesis = chainhash.Hash([chainhash.HashSize]byte{
		0xf6, 0x1e, 0xee, 0x3b, 0x63, 0xa3, 0x80, 0xa4,
		0x77, 0xa0, 0x63, 0xaf, 0x32, 0xb2, 0xbb, 0xc9,
		0x7c, 0x9f, 0xf9, 0xf0, 0x1f, 0x2c, 0x42, 0x25,
		0xe9, 0x73, 0x98, 0x81, 0x08, 0x00, 0x00, 0x00,
	})

	// BitcoinTestnetGenesis is the genesis hash of Bitcoin's testnet
	// chain.
	BitcoinTestnetGenesis = chainhash.Hash([chainhash.HashSize]byte{
		0x43, 0x49, 0x7f, 0xd7, 0xf8, 0x26, 0x95, 0x71,
		0x08, 0xf4, 0xa3, 0x0f, 0xd9, 0xce, 0xc3, 0xae,
		0xba, 0x79, 0x97, 0x20, 0x84, 0xe9, 0x0e, 0xad,
		0x01, 0xea, 0x33, 0x09, 0x00, 0x00, 0x00, 0x00,
	})

	// BitcoinMainnetGenesis is the genesis hash of Bitcoin's main chain.
	BitcoinMainnetGenesis = chainhash.Hash([chainhash.HashSize]byte{
		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
	})

	// MonacoinTestnetGenesis is the genesis hash of Monacoin's testnet4
	// chain.
	MonacoinTestnetGenesis = chainhash.Hash([chainhash.HashSize]byte{
		0xb2, 0xe0, 0x61, 0x10, 0x32, 0x9c, 0x44, 0x8f,
		0x15, 0x78, 0xe4, 0x8a, 0x25, 0xa8, 0x8b, 0x63,
		0x9d, 0xcf, 0xaa, 0xa6, 0xa6, 0xb2, 0x97, 0xd0,
		0xc6, 0xe0, 0x3b, 0xba, 0xce, 0x06, 0xb1, 0xa2,
	})

	// MonacoinMainnetGenesis is the genesis hash of Monacoin's main chain.
	MonacoinMainnetGenesis = chainhash.Hash([chainhash.HashSize]byte{
		0xb6, 0x8b, 0x8c, 0x41, 0x0d, 0x2e, 0xa4, 0xaf,
		0xd7, 0x4f, 0xb5, 0x6e, 0x37, 0x0b, 0xfc, 0x1b,
		0xed, 0xf9, 0x29, 0xe1, 0x45, 0x38, 0x96, 0xc9,
		0xe7, 0x9d, 0xd1, 0x16, 0x01, 0x1c, 0x9f, 0xff,
	})

	// ChainDNSSeeds is a map of a chain's hash to the set of DNS seeds
	// that will be use to bootstrap peers upon first startup.
	//
	// The first item in the array is the primary host we'll use to attempt
	// the SRV lookup we require. If we're unable to receive a response
	// over UDP, then we'll fall back to manual TCP resolution. The second
	// item in the array is a special A record that we'll query in order to
	// receive the IP address of the current authoritative DNS server for
	// the network seed.
	//
	// TODO(roasbeef): extend and collapse these and chainparams.go into
	// struct like chaincfg.Params
	ChainDNSSeeds = map[chainhash.Hash][][2]string{
		BitcoinMainnetGenesis: {
			{
				"nodes.lightning.directory",
				"soa.nodes.lightning.directory",
			},
			{
				"lseed.bitcoinstats.com",
			},
		},

		BitcoinSignetGenesis: {
			{
				"lseed.wakiyamap.dev",
			},
		},

		BitcoinTestnetGenesis: {
			{
				"test.nodes.lightning.directory",
				"soa.nodes.lightning.directory",
			},
		},

		MonacoinMainnetGenesis: {
			{
				"lnd.nodes.directory",
				"soa.lnd.nodes.directory",
			},
		},

		MonacoinTestnetGenesis: {
			{
				"testlnd.nodes.directory",
			},
		},
	}
)
View Source 
var BitcoinMainNetParams = BitcoinNetParams{
	Params:   &bitcoinCfg.MainNetParams,
	RPCPort:  "8334",
	CoinType: keychain.CoinTypeBitcoin,
}

BitcoinMainNetParams contains parameters specific to the current Bitcoin mainnet.

View Source 
var BitcoinRegTestNetParams = BitcoinNetParams{
	Params:   &bitcoinCfg.RegressionNetParams,
	RPCPort:  "18334",
	CoinType: keychain.CoinTypeTestnet,
}

BitcoinRegTestNetParams contains parameters specific to a local bitcoin regtest network.

View Source 
var BitcoinSigNetParams = BitcoinNetParams{
	Params:   &bitcoinCfg.TestNet3Params,
	RPCPort:  "38334",
	CoinType: keychain.CoinTypeTestnet,
}

BitcoinSigNetParams contains parameters specific to the signature version of the test network.

View Source 
var BitcoinSimNetParams = BitcoinNetParams{
	Params:   &bitcoinCfg.SimNetParams,
	RPCPort:  "18556",
	CoinType: keychain.CoinTypeTestnet,
}

BitcoinSimNetParams contains parameters specific to the simulation test network.

View Source 
var BitcoinTestNetParams = BitcoinNetParams{
	Params:   &bitcoinCfg.TestNet3Params,
	RPCPort:  "18334",
	CoinType: keychain.CoinTypeTestnet,
}

BitcoinTestNetParams contains parameters specific to the 3rd version of the test network.

View Source 
var DefaultBtcChannelConstraints = channeldb.ChannelConstraints{
	DustLimit:        lnwallet.DefaultDustLimit(),
	MaxAcceptedHtlcs: input.MaxHTLCNumber / 2,
}

DefaultBtcChannelConstraints is the default set of channel constraints that are meant to be used when initially funding a Bitcoin channel.

TODO(halseth): make configurable at startup?

View Source 
var DefaultMonaChannelConstraints = channeldb.ChannelConstraints{
	DustLimit:        DefaultMonacoinDustLimit,
	MaxAcceptedHtlcs: input.MaxHTLCNumber / 2,
}

DefaultMonaChannelConstraints is the default set of channel constraints that are meant to be used when initially funding a Monacoin channel.

View Source 
var MonacoinMainNetParams = MonacoinNetParams{
	Params:   &monacoinCfg.MainNetParams,
	RPCPort:  "9400",
	CoinType: keychain.CoinTypeMonacoin,
}

MonacoinMainNetParams contains the parameters specific to the current Monacoin mainnet.

View Source 
var MonacoinRegTestNetParams = MonacoinNetParams{
	Params:   &monacoinCfg.RegressionNetParams,
	RPCPort:  "18334",
	CoinType: keychain.CoinTypeTestnet,
}

MonacoinRegTestNetParams contains parameters specific to a local monacoin regtest network.

View Source 
var MonacoinSimNetParams = MonacoinNetParams{
	Params:   &monacoinCfg.SimNetParams,
	RPCPort:  "18556",
	CoinType: keychain.CoinTypeTestnet,
}

MonacoinSimNetParams contains parameters specific to the simulation test network.

View Source 
var MonacoinTestNetParams = MonacoinNetParams{
	Params:   &monacoinCfg.TestNet4Params,
	RPCPort:  "19400",
	CoinType: keychain.CoinTypeTestnet,
}

MonacoinTestNetParams contains parameters specific to the 4th version of the test network.

View Source 
var SignetParam = SignetParamStruct{
	Name:        "signet",
	Net:         0x6a70c7f0,
	Checkpoints: nil,
	DefaultPort: "38333",
	DNSSeeds: []DNSSeed{
		{"178.128.221.177", false},
		{"2a01:7c8:d005:390::5", false},
	},
	GenesisHash: chainhash.Hash([chainhash.HashSize]byte{
		0xf6, 0x1e, 0xee, 0x3b, 0x63, 0xa3, 0x80, 0xa4,
		0x77, 0xa0, 0x63, 0xaf, 0x32, 0xb2, 0xbb, 0xc9,
		0x7c, 0x9f, 0xf9, 0xf0, 0x1f, 0x2c, 0x42, 0x25,
		0xe9, 0x73, 0x98, 0x81, 0x08, 0x00, 0x00, 0x00,
	}),
}

SignetParam values !!temp!!

Functions

func ApplyMonacoinParams 

func ApplyMonacoinParams(params *BitcoinNetParams,
	monacoinParams *MonacoinNetParams)

applyMonacoinParams applies the relevant chain configuration parameters that differ for monacoin to the chain parameters typed for btcsuite derivation. This function is used in place of using something like interface{} to abstract over _which_ chain (or fork) the parameters are for.

func ApplySignetParams 

func ApplySignetParams(params *BitcoinNetParams,
	signetParams *BitcoinNetParams)

!! temp !! ApplySignetParams applies the relevant chain configuration parameters that differ for signet to the chain parameters typed for btcsuite derivation. This function is used in place of using something like interface{} to abstract over _which_ chain (or fork) the parameters are for.

func DisableLog 

func DisableLog()

DisableLog disables all logging output.

func IsTestnet 

func IsTestnet(params *BitcoinNetParams) bool

IsTestnet tests if the givern params correspond to a testnet parameter configuration.

func UseLogger 

func UseLogger(logger btclog.Logger)

UseLogger uses a specified Logger to output package logging info.

Types

type BitcoinNetParams 

type BitcoinNetParams struct {
	*bitcoinCfg.Params
	RPCPort  string
	CoinType uint32
}

BitcoinNetParams couples the p2p parameters of a network with the corresponding RPC port of a daemon running on the particular network.

type ChainCode 

type ChainCode uint32

ChainCode is an enum-like structure for keeping track of the chains currently supported within lnd. 

const (
	// BitcoinChain is Bitcoin's chain.
	BitcoinChain ChainCode = iota

	// MonacoinChain is Monacoin's chain.
	MonacoinChain
)

func (ChainCode) String 

func (c ChainCode) String() string

String returns a string representation of the target ChainCode.

type ChainControl 

type ChainControl struct {
	// ChainIO represents an abstraction over a source that can query the blockchain.
	ChainIO lnwallet.BlockChainIO

	// HealthCheck is a function which can be used to send a low-cost, fast
	// query to the chain backend to ensure we still have access to our
	// node.
	HealthCheck func() error

	// FeeEstimator is used to estimate an optimal fee for transactions important to us.
	FeeEstimator chainfee.Estimator

	// Signer is used to provide signatures over things like transactions.
	Signer input.Signer

	// KeyRing represents a set of keys that we have the private keys to.
	KeyRing keychain.SecretKeyRing

	// Wc is an abstraction over some basic wallet commands. This base set of commands
	// will be provided to the Wallet *LightningWallet raw pointer below.
	Wc lnwallet.WalletController

	// MsgSigner is used to sign arbitrary messages.
	MsgSigner lnwallet.MessageSigner

	// ChainNotifier is used to receive blockchain events that we are interested in.
	ChainNotifier chainntnfs.ChainNotifier

	// ChainView is used in the router for maintaining an up-to-date graph.
	ChainView chainview.FilteredChainView

	// Wallet is our LightningWallet that also contains the abstract Wc above. This wallet
	// handles all of the lightning operations.
	Wallet *lnwallet.LightningWallet

	// RoutingPolicy is the routing policy we have decided to use.
	RoutingPolicy htlcswitch.ForwardingPolicy

	// MinHtlcIn is the minimum HTLC we will accept.
	MinHtlcIn lnwire.MilliSatoshi
}

ChainControl couples the three primary interfaces lnd utilizes for a particular chain together. A single ChainControl instance will exist for all the chains lnd is currently active on.

func NewChainControl 

func NewChainControl(cfg *Config) (*ChainControl, error)

NewChainControl attempts to create a ChainControl instance according to the parameters in the passed configuration. Currently three branches of ChainControl instances exist: one backed by a running btcd full-node, another backed by a running bitcoind full-node, and the other backed by a running neutrino light client instance. When running with a neutrino light client instance, `neutrinoCS` must be non-nil.

type ChainRegistry 

type ChainRegistry struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

ChainRegistry keeps track of the current chains

func NewChainRegistry 

func NewChainRegistry() *ChainRegistry

NewChainRegistry creates a new ChainRegistry.

func (*ChainRegistry) ActiveChains 

func (c *ChainRegistry) ActiveChains() []ChainCode

ActiveChains returns a slice containing the active chains.

func (*ChainRegistry) LookupChain 

func (c *ChainRegistry) LookupChain(targetChain ChainCode) (
	*ChainControl, bool)

LookupChain attempts to lookup an active ChainControl instance for the target chain.

func (*ChainRegistry) LookupChainByHash 

func (c *ChainRegistry) LookupChainByHash(chainHash chainhash.Hash) (*ChainControl, bool)

LookupChainByHash attempts to look up an active ChainControl which corresponds to the passed genesis hash.

func (*ChainRegistry) NumActiveChains 

func (c *ChainRegistry) NumActiveChains() uint32

NumActiveChains returns the total number of active chains.

func (*ChainRegistry) PrimaryChain 

func (c *ChainRegistry) PrimaryChain() ChainCode

PrimaryChain returns the primary chain for this running lnd instance. The primary chain is considered the "home base" while the other registered chains are treated as secondary chains.

func (*ChainRegistry) RegisterChain 

func (c *ChainRegistry) RegisterChain(newChain ChainCode,
	cc *ChainControl)

RegisterChain assigns an active ChainControl instance to a target chain identified by its ChainCode.

func (*ChainRegistry) RegisterPrimaryChain 

func (c *ChainRegistry) RegisterPrimaryChain(cc ChainCode)

RegisterPrimaryChain sets a target chain as the "home chain" for lnd.

type Checkpoint 

type Checkpoint struct {
	Height int32
	Hash   *chainhash.Hash
}

!! temp !! Checkpoint identifies a known good point in the block chain. Using checkpoints allows a few optimizations for old blocks during initial download and also prevents forks from old blocks.

Each checkpoint is selected based upon several factors. See the documentation for blockchain.IsCheckpointCandidate for details on the selection criteria.

type Config 

type Config struct {
	// Bitcoin defines settings for the Bitcoin chain.
	Bitcoin *lncfg.Chain

	// Monacoin defines settings for the Monacoin chain.
	Monacoin *lncfg.Chain

	// PrimaryChain is a function that returns our primary chain via its
	// ChainCode.
	PrimaryChain func() ChainCode

	// HeightHintCacheQueryDisable is a boolean that disables height hint
	// queries if true.
	HeightHintCacheQueryDisable bool

	// NeutrinoMode defines settings for connecting to a neutrino light-client.
	NeutrinoMode *lncfg.Neutrino

	// BitcoindMode defines settings for connecting to a bitcoind node.
	BitcoindMode *lncfg.Bitcoind

	// MonacoindMode defines settings for connecting to a monacoind node.
	MonacoindMode *lncfg.Bitcoind

	// BtcdMode defines settings for connecting to a btcd node.
	BtcdMode *lncfg.Btcd

	// MonadMode defines settings for connecting to an monad node.
	MonadMode *lncfg.Btcd

	// LocalChanDB is a pointer to the local backing channel database.
	LocalChanDB *channeldb.DB

	// RemoteChanDB is a pointer to the remote backing channel database.
	RemoteChanDB *channeldb.DB

	// PrivateWalletPw is the private wallet password to the underlying
	// btcwallet instance.
	PrivateWalletPw []byte

	// PublicWalletPw is the public wallet password to the underlying btcwallet
	// instance.
	PublicWalletPw []byte

	// Birthday specifies the time the wallet was initially created.
	Birthday time.Time

	// RecoveryWindow specifies the address look-ahead for which to scan when
	// restoring a wallet.
	RecoveryWindow uint32

	// Wallet is a pointer to the backing wallet instance.
	Wallet *wallet.Wallet

	// NeutrinoCS is a pointer to a neutrino ChainService. Must be non-nil if
	// using neutrino.
	NeutrinoCS *neutrino.ChainService

	// ActiveNetParams details the current chain we are on.
	ActiveNetParams BitcoinNetParams

	// FeeURL defines the URL for fee estimation we will use. This field is
	// optional.
	FeeURL string

	// DBTimeOut specifies the timeout value to use when opening the wallet
	// database.
	DBTimeOut time.Duration
}

Config houses necessary fields that a chainControl instance needs to function.

type DNSSeed 

type DNSSeed struct {
	// Host defines the hostname of the seed.
	Host string

	// HasFiltering defines whether the seed supports filtering
	// by service flags (wire.ServiceFlag).
	HasFiltering bool
}

!! temp !! DNSSeed identifies a DNS seed.

type MonacoinNetParams 

type MonacoinNetParams struct {
	*monacoinCfg.Params
	RPCPort  string
	CoinType uint32
}

MonacoinNetParams couples the p2p parameters of a network with the corresponding RPC port of a daemon running on the particular network.

type SignetParamStruct 

type SignetParamStruct struct {
	Name        string
	Net         bitcoinWire.BitcoinNet
	Checkpoints []Checkpoint
	DefaultPort string
	DNSSeeds    []DNSSeed
	GenesisHash chainhash.Hash
}

SignetParam struct !!temp!!

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.