Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var ( // ErrOutputNotFound signals that the breached output could not be found // on the commitment transaction. ErrOutputNotFound = errors.New("unable to find output on commit tx") // ErrUnknownSweepAddrType signals that client provided an output that // was not p2wkh or p2wsh. ErrUnknownSweepAddrType = errors.New("sweep addr is not p2wkh or p2wsh") )
Functions ¶
func DisableLog ¶
func DisableLog()
DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.
Types ¶
type BlockFetcher ¶
type BlockFetcher interface {
// GetBlock fetches the block given the target block hash.
GetBlock(*chainhash.Hash) (*wire.MsgBlock, error)
}
BlockFetcher supports the ability to fetch blocks from the backend or network.
type BreachPunisher ¶
type BreachPunisher struct {
// contains filtered or unexported fields
}
BreachPunisher handles the responsibility of constructing and broadcasting justice transactions. Justice transactions are constructed from previously accepted state updates uploaded by the watchtower's clients.
func NewBreachPunisher ¶
func NewBreachPunisher(cfg *PunisherConfig) *BreachPunisher
NewBreachPunisher constructs a new BreachPunisher given a PunisherConfig.
func (*BreachPunisher) Punish ¶
func (p *BreachPunisher) Punish(desc *JusticeDescriptor, quit <-chan struct{}) error
Punish constructs a justice transaction given a JusticeDescriptor and publishes is it to the network.
type Config ¶
type Config struct {
// DB provides persistent access to the watchtower's accepted state
// updates such that they can be queried as new blocks arrive from the
// network.
DB DB
// EpochRegistrar supports the ability to register for events corresponding to
// newly created blocks.
EpochRegistrar EpochRegistrar
// BlockFetcher supports the ability to fetch blocks from the backend or
// network.
BlockFetcher BlockFetcher
// Punisher handles the responsibility of crafting and broadcasting
// justice transaction for any breached transactions.
Punisher Punisher
}
Config houses the Lookout's required resources to properly fulfill it's duty, including block fetching, querying accepted state updates, and construction and publication of justice transactions.
type DB ¶
type DB interface {
// GetLookoutTip returns the last block epoch at which the tower
// performed a match. If no match has been done, a nil epoch will be
// returned.
GetLookoutTip() (*chainntnfs.BlockEpoch, error)
// QueryMatches searches its database for any state updates matching the
// provided breach hints. If any matches are found, they will be
// returned along with encrypted blobs so that justice can be exacted.
QueryMatches([]blob.BreachHint) ([]wtdb.Match, error)
// SetLookoutTip writes the best epoch for which the watchtower has
// queried for breach hints.
SetLookoutTip(*chainntnfs.BlockEpoch) error
}
DB abstracts the required persistent calls expected by the lookout. DB provides the ability to search for state updates that correspond to breach transactions confirmed in a particular block.
type EpochRegistrar ¶
type EpochRegistrar interface {
// RegisterBlockEpochNtfn registers for a new block epoch subscription.
// The implementation must support historical dispatch, starting from
// the provided chainntnfs.BlockEpoch when it is non-nil. The
// notifications should be delivered in-order, and deliver reorged
// blocks.
RegisterBlockEpochNtfn(
*chainntnfs.BlockEpoch) (*chainntnfs.BlockEpochEvent, error)
}
EpochRegistrar supports the ability to register for events corresponding to newly created blocks.
type JusticeDescriptor ¶
type JusticeDescriptor struct {
// BreachedCommitTx is the commitment transaction that caused the breach
// to be detected.
BreachedCommitTx *wire.MsgTx
// SessionInfo contains the contract with the watchtower client and
// the prenegotiated terms they agreed to.
SessionInfo *wtdb.SessionInfo
// JusticeKit contains the decrypted blob and information required to
// construct the transaction scripts and witnesses.
JusticeKit blob.JusticeKit
}
JusticeDescriptor contains the information required to sweep a breached channel on behalf of a victim. It supports the ability to create the justice transaction that sweeps the commitments and recover a cut of the channel for the watcher's eternal vigilance.
func (*JusticeDescriptor) CreateJusticeTxn ¶
func (p *JusticeDescriptor) CreateJusticeTxn() (*wire.MsgTx, error)
CreateJusticeTxn computes the justice transaction that sweeps a breaching commitment transaction. The justice transaction is constructed by assembling the witnesses using data provided by the client in a prior state update.
NOTE: An older version of ToLocalPenaltyWitnessSize underestimated the size of the witness by one byte, which could cause the signature(s) to break if the tower is reconstructing with the newer constant because the output values might differ. This method retains that original behavior to not invalidate historical signatures.
type Lookout ¶
type Lookout struct {
// contains filtered or unexported fields
}
Lookout will check any incoming blocks against the transactions found in the database, and in case of matches send the information needed to create a penalty transaction to the punisher.
type MockBackend ¶
type MockBackend struct {
// contains filtered or unexported fields
}
func NewMockBackend ¶
func NewMockBackend() *MockBackend
func (*MockBackend) ConnectEpoch ¶
func (m *MockBackend) ConnectEpoch(epoch *chainntnfs.BlockEpoch, block *wire.MsgBlock)
func (*MockBackend) RegisterBlockEpochNtfn ¶
func (m *MockBackend) RegisterBlockEpochNtfn(*chainntnfs.BlockEpoch) ( *chainntnfs.BlockEpochEvent, error)
type Punisher ¶
type Punisher interface {
// Punish accepts a JusticeDescriptor, constructs the justice
// transaction, and publishes the transaction to the network so it can
// be mined. The second parameter is a quit channel so that long-running
// operations required to track the confirmation of the transaction can
// be canceled on shutdown.
Punish(*JusticeDescriptor, <-chan struct{}) error
}
Punisher handles the construction and publication of justice transactions once they have been detected by the Service.
type PunisherConfig ¶
type PunisherConfig struct {
// PublishTx provides the ability to send a signed transaction to the
// network.
PublishTx func(*wire.MsgTx, string) error
}
PunisherConfig houses the resources required by the Punisher.
type Service ¶
type Service interface {
// Start safely starts up the Interface.
Start() error
// Stop safely stops the Interface.
Stop() error
}
Service abstracts the lookout functionality, supporting the ability to start and stop. All communication and actions are driven via the database or chain events.
Source Files