fa46db9c48
To allow us to write the outcome of our resolver to disk, we add optional resolver reports to the CheckPoint function. Variadic params are used because some checkpoints may have no reports (when the resolver is not yet complete) and some may have two (in the case of a two stage resolution).
125 lines
4.0 KiB
Go
125 lines
4.0 KiB
Go
package contractcourt
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/btcsuite/btclog"
|
|
"github.com/lightningnetwork/lnd/build"
|
|
"github.com/lightningnetwork/lnd/channeldb"
|
|
)
|
|
|
|
var (
|
|
endian = binary.BigEndian
|
|
)
|
|
|
|
const (
|
|
// sweepConfTarget is the default number of blocks that we'll use as a
|
|
// confirmation target when sweeping.
|
|
sweepConfTarget = 6
|
|
)
|
|
|
|
// ContractResolver is an interface which packages a state machine which is
|
|
// able to carry out the necessary steps required to fully resolve a Bitcoin
|
|
// contract on-chain. Resolvers are fully encodable to ensure callers are able
|
|
// to persist them properly. A resolver may produce another resolver in the
|
|
// case that claiming an HTLC is a multi-stage process. In this case, we may
|
|
// partially resolve the contract, then persist, and set up for an additional
|
|
// resolution.
|
|
type ContractResolver interface {
|
|
// ResolverKey returns an identifier which should be globally unique
|
|
// for this particular resolver within the chain the original contract
|
|
// resides within.
|
|
ResolverKey() []byte
|
|
|
|
// Resolve instructs the contract resolver to resolve the output
|
|
// on-chain. Once the output has been *fully* resolved, the function
|
|
// should return immediately with a nil ContractResolver value for the
|
|
// first return value. In the case that the contract requires further
|
|
// resolution, then another resolve is returned.
|
|
//
|
|
// NOTE: This function MUST be run as a goroutine.
|
|
Resolve() (ContractResolver, error)
|
|
|
|
// IsResolved returns true if the stored state in the resolve is fully
|
|
// resolved. In this case the target output can be forgotten.
|
|
IsResolved() bool
|
|
|
|
// Encode writes an encoded version of the ContractResolver into the
|
|
// passed Writer.
|
|
Encode(w io.Writer) error
|
|
|
|
// Stop signals the resolver to cancel any current resolution
|
|
// processes, and suspend.
|
|
Stop()
|
|
}
|
|
|
|
// htlcContractResolver is the required interface for htlc resolvers.
|
|
type htlcContractResolver interface {
|
|
ContractResolver
|
|
|
|
// HtlcPoint returns the htlc's outpoint on the commitment tx.
|
|
HtlcPoint() wire.OutPoint
|
|
|
|
// Supplement adds additional information to the resolver that is
|
|
// required before Resolve() is called.
|
|
Supplement(htlc channeldb.HTLC)
|
|
}
|
|
|
|
// reportingContractResolver is a ContractResolver that also exposes a report on
|
|
// the resolution state of the contract.
|
|
type reportingContractResolver interface {
|
|
ContractResolver
|
|
|
|
report() *ContractReport
|
|
}
|
|
|
|
// ResolverConfig contains the externally supplied configuration items that are
|
|
// required by a ContractResolver implementation.
|
|
type ResolverConfig struct {
|
|
// ChannelArbitratorConfig contains all the interfaces and closures
|
|
// required for the resolver to interact with outside sub-systems.
|
|
ChannelArbitratorConfig
|
|
|
|
// Checkpoint allows a resolver to check point its state. This function
|
|
// should write the state of the resolver to persistent storage, and
|
|
// return a non-nil error upon success. It takes a resolver report,
|
|
// which contains information about the outcome and should be written
|
|
// to disk if non-nil.
|
|
Checkpoint func(ContractResolver, ...*channeldb.ResolverReport) error
|
|
}
|
|
|
|
// contractResolverKit is meant to be used as a mix-in struct to be embedded within a
|
|
// given ContractResolver implementation. It contains all the common items that
|
|
// a resolver requires to carry out its duties.
|
|
type contractResolverKit struct {
|
|
ResolverConfig
|
|
|
|
log btclog.Logger
|
|
|
|
quit chan struct{}
|
|
}
|
|
|
|
// newContractResolverKit instantiates the mix-in struct.
|
|
func newContractResolverKit(cfg ResolverConfig) *contractResolverKit {
|
|
return &contractResolverKit{
|
|
ResolverConfig: cfg,
|
|
quit: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
// initLogger initializes the resolver-specific logger.
|
|
func (r *contractResolverKit) initLogger(resolver ContractResolver) {
|
|
logPrefix := fmt.Sprintf("%T(%v):", resolver, r.ChanPoint)
|
|
r.log = build.NewPrefixLog(logPrefix, log)
|
|
}
|
|
|
|
var (
|
|
// errResolverShuttingDown is returned when the resolver stops
|
|
// progressing because it received the quit signal.
|
|
errResolverShuttingDown = errors.New("resolver shutting down")
|
|
)
|