13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.98

/contractcourt/commit_sweep_resolver.go

package contractcourt

import (
        "encoding/binary"
        "fmt"
        "io"
        "math"
        "sync"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/txscript"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/chainntnfs"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/sweep"
)

// commitSweepResolver is a resolver that will attempt to sweep the commitment
// output paying to us (local channel balance). In the case that the local
// party (we) broadcasts their version of the commitment transaction, we have
// to wait before sweeping it, as it has a CSV delay. For anchor channel
// type, even if the remote party broadcasts the commitment transaction,
// we have to wait one block after commitment transaction is confirmed,
// because CSV 1 is put into the script of UTXO representing local balance.
// Additionally, if the channel is a channel lease, we have to wait for
// CLTV to expire.
// https://docs.lightning.engineering/lightning-network-tools/pool/overview
type commitSweepResolver struct {
        // localChanCfg is used to provide the resolver with the keys required
        // to identify whether the commitment transaction was broadcast by the
        // local or remote party.
        localChanCfg channeldb.ChannelConfig

        // commitResolution contains all data required to successfully sweep
        // this HTLC on-chain.
        commitResolution lnwallet.CommitOutputResolution

        // broadcastHeight is the height that the original contract was
        // broadcast to the main-chain at. We'll use this value to bound any
        // historical queries to the chain for spends/confirmations.
        broadcastHeight uint32

        // chanPoint is the channel point of the original contract.
        chanPoint wire.OutPoint

        // channelInitiator denotes whether the party responsible for resolving
        // the contract initiated the channel.
        channelInitiator bool

        // leaseExpiry denotes the additional waiting period the contract must
        // hold until it can be resolved. This waiting period is known as the
        // expiration of a script-enforced leased channel and only applies to
        // the channel initiator.
        //
        // NOTE: This value should only be set when the contract belongs to a
        // leased channel.
        leaseExpiry uint32

        // chanType denotes the type of channel the contract belongs to.
        chanType channeldb.ChannelType

        // currentReport stores the current state of the resolver for reporting
        // over the rpc interface.
        currentReport ContractReport

        // reportLock prevents concurrent access to the resolver report.
        reportLock sync.Mutex

        contractResolverKit
}

// newCommitSweepResolver instantiates a new direct commit output resolver.
func newCommitSweepResolver(res lnwallet.CommitOutputResolution,
        broadcastHeight uint32, chanPoint wire.OutPoint,
        resCfg ResolverConfig) *commitSweepResolver {

        r := &commitSweepResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                commitResolution:    res,
                broadcastHeight:     broadcastHeight,
                chanPoint:           chanPoint,
        }

        r.initLogger(fmt.Sprintf("%T(%v)", r, r.commitResolution.SelfOutPoint))
        r.initReport()

        return r
}

// ResolverKey returns an identifier which should be globally unique for this
// particular resolver within the chain the original contract resides within.
func (c *commitSweepResolver) ResolverKey() []byte {
        key := newResolverID(c.commitResolution.SelfOutPoint)
        return key[:]
}

// waitForSpend waits for the given outpoint to be spent, and returns the
// details of the spending tx.
func waitForSpend(op *wire.OutPoint, pkScript []byte, heightHint uint32,
        notifier chainntnfs.ChainNotifier, quit <-chan struct{}) (
        *chainntnfs.SpendDetail, error) {

        spendNtfn, err := notifier.RegisterSpendNtfn(
                op, pkScript, heightHint,
        )
        if err != nil {
                return nil, err
        }

        select {
        case spendDetail, ok := <-spendNtfn.Spend:
                if !ok {
                        return nil, errResolverShuttingDown
                }

                return spendDetail, nil

        case <-quit:
                return nil, errResolverShuttingDown
        }
}

// getCommitTxConfHeight waits for confirmation of the commitment tx and
// returns the confirmation height.
func (c *commitSweepResolver) getCommitTxConfHeight() (uint32, error) {
        txID := c.commitResolution.SelfOutPoint.Hash
        signDesc := c.commitResolution.SelfOutputSignDesc
        pkScript := signDesc.Output.PkScript

        const confDepth = 1

        confChan, err := c.Notifier.RegisterConfirmationsNtfn(
                &txID, pkScript, confDepth, c.broadcastHeight,
        )
        if err != nil {
                return 0, err
        }
        defer confChan.Cancel()

        select {
        case txConfirmation, ok := <-confChan.Confirmed:
                if !ok {
                        return 0, fmt.Errorf("cannot get confirmation "+
                                "for commit tx %v", txID)
                }

                return txConfirmation.BlockHeight, nil

        case <-c.quit:
                return 0, errResolverShuttingDown
        }
}

// 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.

// TODO(yy): fix the funlen in the next PR.
//
//nolint:funlen
func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
        // If we're already resolved, then we can exit early.
        if c.IsResolved() {
                c.log.Errorf("already resolved")
                return nil, nil
        }

        var sweepTxID chainhash.Hash

        // Sweeper is going to join this input with other inputs if possible
        // and publish the sweep tx. When the sweep tx confirms, it signals us
        // through the result channel with the outcome. Wait for this to
        // happen.
        outcome := channeldb.ResolverOutcomeClaimed
        select {
        case sweepResult := <-c.sweepResultChan:
                switch sweepResult.Err {
                // If the remote party was able to sweep this output it's
                // likely what we sent was actually a revoked commitment.
                // Report the error and continue to wrap up the contract.
                case sweep.ErrRemoteSpend:
                        c.log.Warnf("local commitment output was swept by "+
                                "remote party via %v", sweepResult.Tx.TxHash())
                        outcome = channeldb.ResolverOutcomeUnclaimed

                // No errors, therefore continue processing.
                case nil:
                        c.log.Infof("local commitment output fully resolved by "+
                                "sweep tx: %v", sweepResult.Tx.TxHash())
                // Unknown errors.
                default:
                        c.log.Errorf("unable to sweep input: %v",
                                sweepResult.Err)

                        return nil, sweepResult.Err
                }

                sweepTxID = sweepResult.Tx.TxHash()

        case <-c.quit:
                return nil, errResolverShuttingDown
        }

        // Funds have been swept and balance is no longer in limbo.
        c.reportLock.Lock()
        if outcome == channeldb.ResolverOutcomeClaimed {
                // We only record the balance as recovered if it actually came
                // back to us.
                c.currentReport.RecoveredBalance = c.currentReport.LimboBalance
        }
        c.currentReport.LimboBalance = 0
        c.reportLock.Unlock()
        report := c.currentReport.resolverReport(
                &sweepTxID, channeldb.ResolverTypeCommit, outcome,
        )
        c.markResolved()

        // Checkpoint the resolver with a closure that will write the outcome
        // of the resolver and its sweep transaction to disk.
        return nil, c.Checkpoint(c, report)
}

// Stop signals the resolver to cancel any current resolution processes, and
// suspend.
//
// NOTE: Part of the ContractResolver interface.
func (c *commitSweepResolver) Stop() {
        c.log.Debugf("stopping...")
        defer c.log.Debugf("stopped")
        close(c.quit)
}

// SupplementState allows the user of a ContractResolver to supplement it with
// state required for the proper resolution of a contract.
//
// NOTE: Part of the ContractResolver interface.
func (c *commitSweepResolver) SupplementState(state *channeldb.OpenChannel) {
        if state.ChanType.HasLeaseExpiration() {
                c.leaseExpiry = state.ThawHeight
        }
        c.localChanCfg = state.LocalChanCfg
        c.channelInitiator = state.IsInitiator
        c.chanType = state.ChanType
}

// hasCLTV denotes whether the resolver must wait for an additional CLTV to
// expire before resolving the contract.
func (c *commitSweepResolver) hasCLTV() bool {
        return c.channelInitiator && c.leaseExpiry > 0
}

// Encode writes an encoded version of the ContractResolver into the passed
// Writer.
//
// NOTE: Part of the ContractResolver interface.
func (c *commitSweepResolver) Encode(w io.Writer) error {
        if err := encodeCommitResolution(w, &c.commitResolution); err != nil {
                return err
        }

        if err := binary.Write(w, endian, c.IsResolved()); err != nil {
                return err
        }
        if err := binary.Write(w, endian, c.broadcastHeight); err != nil {
                return err
        }
        if _, err := w.Write(c.chanPoint.Hash[:]); err != nil {
                return err
        }
        err := binary.Write(w, endian, c.chanPoint.Index)
        if err != nil {
                return err
        }

        // Previously a sweep tx was serialized at this point. Refactoring
        // removed this, but keep in mind that this data may still be present in
        // the database.

        return nil
}

// newCommitSweepResolverFromReader attempts to decode an encoded
// ContractResolver from the passed Reader instance, returning an active
// ContractResolver instance.
func newCommitSweepResolverFromReader(r io.Reader, resCfg ResolverConfig) (
        *commitSweepResolver, error) {

        c := &commitSweepResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
        }

        if err := decodeCommitResolution(r, &c.commitResolution); err != nil {
                return nil, err
        }

        var resolved bool
        if err := binary.Read(r, endian, &resolved); err != nil {
                return nil, err
        }
        if resolved {
                c.markResolved()
        }

        if err := binary.Read(r, endian, &c.broadcastHeight); err != nil {
                return nil, err
        }
        _, err := io.ReadFull(r, c.chanPoint.Hash[:])
        if err != nil {
                return nil, err
        }
        err = binary.Read(r, endian, &c.chanPoint.Index)
        if err != nil {
                return nil, err
        }

        // Previously a sweep tx was deserialized at this point. Refactoring
        // removed this, but keep in mind that this data may still be present in
        // the database.

        c.initLogger(fmt.Sprintf("%T(%v)", c, c.commitResolution.SelfOutPoint))
        c.initReport()

        return c, nil
}

// report returns a report on the resolution state of the contract.
func (c *commitSweepResolver) report() *ContractReport {
        c.reportLock.Lock()
        defer c.reportLock.Unlock()

        cpy := c.currentReport
        return &cpy
}

// initReport initializes the pending channels report for this resolver.
func (c *commitSweepResolver) initReport() {
        amt := btcutil.Amount(
                c.commitResolution.SelfOutputSignDesc.Output.Value,
        )

        // Set the initial report. All fields are filled in, except for the
        // maturity height which remains 0 until Resolve() is executed.
        //
        // TODO(joostjager): Resolvers only activate after the commit tx
        // confirms. With more refactoring in channel arbitrator, it would be
        // possible to make the confirmation height part of ResolverConfig and
        // populate MaturityHeight here.
        c.currentReport = ContractReport{
                Outpoint:         c.commitResolution.SelfOutPoint,
                Type:             ReportOutputUnencumbered,
                Amount:           amt,
                LimboBalance:     amt,
                RecoveredBalance: 0,
        }
}

// A compile time assertion to ensure commitSweepResolver meets the
// ContractResolver interface.
var _ reportingContractResolver = (*commitSweepResolver)(nil)

// Launch constructs a commit input and offers it to the sweeper.
func (c *commitSweepResolver) Launch() error {
        if c.isLaunched() {
                c.log.Tracef("already launched")
                return nil
        }

        c.log.Debugf("launching resolver...")
        c.markLaunched()

        // If we're already resolved, then we can exit early.
        if c.IsResolved() {
                c.log.Errorf("already resolved")
                return nil
        }

        confHeight, err := c.getCommitTxConfHeight()
        if err != nil {
                return err
        }

        // Wait up until the CSV expires, unless we also have a CLTV that
        // expires after.
        unlockHeight := confHeight + c.commitResolution.MaturityDelay
        if c.hasCLTV() {
                unlockHeight = uint32(math.Max(
                        float64(unlockHeight), float64(c.leaseExpiry),
                ))
        }

        // Update report now that we learned the confirmation height.
        c.reportLock.Lock()
        c.currentReport.MaturityHeight = unlockHeight
        c.reportLock.Unlock()

        // Derive the witness type for this input.
        witnessType, err := c.decideWitnessType()
        if err != nil {
                return err
        }

        // We'll craft an input with all the information required for the
        // sweeper to create a fully valid sweeping transaction to recover
        // these coins.
        var inp *input.BaseInput
        if c.hasCLTV() {
                inp = input.NewCsvInputWithCltv(
                        &c.commitResolution.SelfOutPoint, witnessType,
                        &c.commitResolution.SelfOutputSignDesc,
                        c.broadcastHeight, c.commitResolution.MaturityDelay,
                        c.leaseExpiry,
                )
        } else {
                inp = input.NewCsvInput(
                        &c.commitResolution.SelfOutPoint, witnessType,
                        &c.commitResolution.SelfOutputSignDesc,
                        c.broadcastHeight, c.commitResolution.MaturityDelay,
                )
        }

        // TODO(roasbeef): instead of ading ctrl block to the sign desc, make
        // new input type, have sweeper set it?

        // Calculate the budget for the sweeping this input.
        budget := calculateBudget(
                btcutil.Amount(inp.SignDesc().Output.Value),
                c.Budget.ToLocalRatio, c.Budget.ToLocal,
        )
        c.log.Infof("sweeping commit output %v using budget=%v", witnessType,
                budget)

        // With our input constructed, we'll now offer it to the sweeper.
        resultChan, err := c.Sweeper.SweepInput(
                inp, sweep.Params{
                        Budget: budget,

                        // Specify a nil deadline here as there's no time
                        // pressure.
                        DeadlineHeight: fn.None[int32](),
                },
        )
        if err != nil {
                c.log.Errorf("unable to sweep input: %v", err)

                return err
        }

        c.sweepResultChan = resultChan

        return nil
}

// decideWitnessType returns the witness type for the input.
func (c *commitSweepResolver) decideWitnessType() (input.WitnessType, error) {
        var (
                isLocalCommitTx bool
                signDesc        = c.commitResolution.SelfOutputSignDesc
        )

        switch {
        // For taproot channels, we'll know if this is the local commit based
        // on the timelock value. For remote commitment transactions, the
        // witness script has a timelock of 1.
        case c.chanType.IsTaproot():
                delayKey := c.localChanCfg.DelayBasePoint.PubKey
                nonDelayKey := c.localChanCfg.PaymentBasePoint.PubKey

                signKey := c.commitResolution.SelfOutputSignDesc.KeyDesc.PubKey

                // If the key in the script is neither of these, we shouldn't
                // proceed. This should be impossible.
                if !signKey.IsEqual(delayKey) && !signKey.IsEqual(nonDelayKey) {
                        return nil, fmt.Errorf("unknown sign key %v", signKey)
                }

                // The commitment transaction is ours iff the signing key is
                // the delay key.
                isLocalCommitTx = signKey.IsEqual(delayKey)

        // The output is on our local commitment if the script starts with
        // OP_IF for the revocation clause. On the remote commitment it will
        // either be a regular P2WKH or a simple sig spend with a CSV delay.
        default:
                isLocalCommitTx = signDesc.WitnessScript[0] == txscript.OP_IF
        }

        isDelayedOutput := c.commitResolution.MaturityDelay != 0

        c.log.Debugf("isDelayedOutput=%v, isLocalCommitTx=%v", isDelayedOutput,
                isLocalCommitTx)

        // There're three types of commitments, those that have tweaks for the
        // remote key (us in this case), those that don't, and a third where
        // there is no tweak and the output is delayed. On the local commitment
        // our output will always be delayed. We'll rely on the presence of the
        // commitment tweak to discern which type of commitment this is.
        var witnessType input.WitnessType
        switch {
        // The local delayed output for a taproot channel.
        case isLocalCommitTx && c.chanType.IsTaproot():
                witnessType = input.TaprootLocalCommitSpend

        // The CSV 1 delayed output for a taproot channel.
        case !isLocalCommitTx && c.chanType.IsTaproot():
                witnessType = input.TaprootRemoteCommitSpend

        // Delayed output to us on our local commitment for a channel lease in
        // which we are the initiator.
        case isLocalCommitTx && c.hasCLTV():
                witnessType = input.LeaseCommitmentTimeLock

        // Delayed output to us on our local commitment.
        case isLocalCommitTx:
                witnessType = input.CommitmentTimeLock

        // A confirmed output to us on the remote commitment for a channel lease
        // in which we are the initiator.
        case isDelayedOutput && c.hasCLTV():
                witnessType = input.LeaseCommitmentToRemoteConfirmed

        // A confirmed output to us on the remote commitment.
        case isDelayedOutput:
                witnessType = input.CommitmentToRemoteConfirmed

        // A non-delayed output on the remote commitment where the key is
        // tweakless.
        case c.commitResolution.SelfOutputSignDesc.SingleTweak == nil:
                witnessType = input.CommitSpendNoDelayTweakless

        // A non-delayed output on the remote commitment where the key is
        // tweaked.
        default:
                witnessType = input.CommitmentNoDelay
        }

        return witnessType, nil
}

1	package contractcourt
2
3	import (
4	"encoding/binary"
5	"fmt"
6	"io"
7	"math"
8	"sync"
9
10	"github.com/btcsuite/btcd/btcutil"
11	"github.com/btcsuite/btcd/chaincfg/chainhash"
12	"github.com/btcsuite/btcd/txscript"
13	"github.com/btcsuite/btcd/wire"
14	"github.com/lightningnetwork/lnd/chainntnfs"
15	"github.com/lightningnetwork/lnd/channeldb"
16	"github.com/lightningnetwork/lnd/fn/v2"
17	"github.com/lightningnetwork/lnd/input"
18	"github.com/lightningnetwork/lnd/lnwallet"
19	"github.com/lightningnetwork/lnd/sweep"
20	)
21
22	// commitSweepResolver is a resolver that will attempt to sweep the commitment
23	// output paying to us (local channel balance). In the case that the local
24	// party (we) broadcasts their version of the commitment transaction, we have
25	// to wait before sweeping it, as it has a CSV delay. For anchor channel
26	// type, even if the remote party broadcasts the commitment transaction,
27	// we have to wait one block after commitment transaction is confirmed,
28	// because CSV 1 is put into the script of UTXO representing local balance.
29	// Additionally, if the channel is a channel lease, we have to wait for
30	// CLTV to expire.
31	// https://docs.lightning.engineering/lightning-network-tools/pool/overview
32	type commitSweepResolver struct {
33	// localChanCfg is used to provide the resolver with the keys required
34	// to identify whether the commitment transaction was broadcast by the
35	// local or remote party.
36	localChanCfg channeldb.ChannelConfig
37
38	// commitResolution contains all data required to successfully sweep
39	// this HTLC on-chain.
40	commitResolution lnwallet.CommitOutputResolution
41
42	// broadcastHeight is the height that the original contract was
43	// broadcast to the main-chain at. We'll use this value to bound any
44	// historical queries to the chain for spends/confirmations.
45	broadcastHeight uint32
46
47	// chanPoint is the channel point of the original contract.
48	chanPoint wire.OutPoint
49
50	// channelInitiator denotes whether the party responsible for resolving
51	// the contract initiated the channel.
52	channelInitiator bool
53
54	// leaseExpiry denotes the additional waiting period the contract must
55	// hold until it can be resolved. This waiting period is known as the
56	// expiration of a script-enforced leased channel and only applies to
57	// the channel initiator.
58	//
59	// NOTE: This value should only be set when the contract belongs to a
60	// leased channel.
61	leaseExpiry uint32
62
63	// chanType denotes the type of channel the contract belongs to.
64	chanType channeldb.ChannelType
65
66	// currentReport stores the current state of the resolver for reporting
67	// over the rpc interface.
68	currentReport ContractReport
69
70	// reportLock prevents concurrent access to the resolver report.
71	reportLock sync.Mutex
72
73	contractResolverKit
74	}
75
76	// newCommitSweepResolver instantiates a new direct commit output resolver.
77	func newCommitSweepResolver(res lnwallet.CommitOutputResolution,
78	broadcastHeight uint32, chanPoint wire.OutPoint,
79	resCfg ResolverConfig) *commitSweepResolver {	3✔
80		3✔
81	r := &commitSweepResolver{	3✔
82	contractResolverKit: *newContractResolverKit(resCfg),	3✔
83	commitResolution: res,	3✔
84	broadcastHeight: broadcastHeight,	3✔
85	chanPoint: chanPoint,	3✔
86	}	3✔
87		3✔
88	r.initLogger(fmt.Sprintf("%T(%v)", r, r.commitResolution.SelfOutPoint))	3✔
89	r.initReport()	3✔
90		3✔
91	return r	3✔
92	}	3✔
93
94	// ResolverKey returns an identifier which should be globally unique for this
95	// particular resolver within the chain the original contract resides within.
96	func (c *commitSweepResolver) ResolverKey() []byte {	3✔
97	key := newResolverID(c.commitResolution.SelfOutPoint)	3✔
98	return key[:]	3✔
99	}	3✔
100
101	// waitForSpend waits for the given outpoint to be spent, and returns the
102	// details of the spending tx.
103	func waitForSpend(op *wire.OutPoint, pkScript []byte, heightHint uint32,
104	notifier chainntnfs.ChainNotifier, quit <-chan struct{}) (
105	*chainntnfs.SpendDetail, error) {	30✔
106		30✔
107	spendNtfn, err := notifier.RegisterSpendNtfn(	30✔
108	op, pkScript, heightHint,	30✔
109	)	30✔
110	if err != nil {	30✔
111	return nil, err	×
112	}	×
113
114	select {	30✔
115	case spendDetail, ok := <-spendNtfn.Spend:	30✔
116	if !ok {	30✔
117	return nil, errResolverShuttingDown	×
118	}	×
119
120	return spendDetail, nil	30✔
121
UNCOV 122	case <-quit:	×
UNCOV 123	return nil, errResolverShuttingDown	×
124	}
125	}
126
127	// getCommitTxConfHeight waits for confirmation of the commitment tx and
128	// returns the confirmation height.
129	func (c *commitSweepResolver) getCommitTxConfHeight() (uint32, error) {	3✔
130	txID := c.commitResolution.SelfOutPoint.Hash	3✔
131	signDesc := c.commitResolution.SelfOutputSignDesc	3✔
132	pkScript := signDesc.Output.PkScript	3✔
133		3✔
134	const confDepth = 1	3✔
135		3✔
136	confChan, err := c.Notifier.RegisterConfirmationsNtfn(	3✔
137	&txID, pkScript, confDepth, c.broadcastHeight,	3✔
138	)	3✔
139	if err != nil {	3✔
140	return 0, err	×
141	}	×
142	defer confChan.Cancel()	3✔
143		3✔
144	select {	3✔
145	case txConfirmation, ok := <-confChan.Confirmed:	3✔
146	if !ok {	3✔
147	return 0, fmt.Errorf("cannot get confirmation "+	×
148	"for commit tx %v", txID)	×
149	}	×
150
151	return txConfirmation.BlockHeight, nil	3✔
152
153	case <-c.quit:	×
154	return 0, errResolverShuttingDown	×
155	}
156	}
157
158	// Resolve instructs the contract resolver to resolve the output on-chain. Once
159	// the output has been fully resolved, the function should return immediately
160	// with a nil ContractResolver value for the first return value. In the case
161	// that the contract requires further resolution, then another resolve is
162	// returned.
163	//
164	// NOTE: This function MUST be run as a goroutine.
165
166	// TODO(yy): fix the funlen in the next PR.
167	//
168	//nolint:funlen
169	func (c *commitSweepResolver) Resolve() (ContractResolver, error) {	3✔
170	// If we're already resolved, then we can exit early.	3✔
171	if c.IsResolved() {	3✔
172	c.log.Errorf("already resolved")	×
173	return nil, nil	×
174	}	×
175
176	var sweepTxID chainhash.Hash	3✔
177		3✔
178	// Sweeper is going to join this input with other inputs if possible	3✔
179	// and publish the sweep tx. When the sweep tx confirms, it signals us	3✔
180	// through the result channel with the outcome. Wait for this to	3✔
181	// happen.	3✔
182	outcome := channeldb.ResolverOutcomeClaimed	3✔
183	select {	3✔
184	case sweepResult := <-c.sweepResultChan:	3✔
185	switch sweepResult.Err {	3✔
186	// If the remote party was able to sweep this output it's
187	// likely what we sent was actually a revoked commitment.
188	// Report the error and continue to wrap up the contract.
189	case sweep.ErrRemoteSpend:	1✔
190	c.log.Warnf("local commitment output was swept by "+	1✔
191	"remote party via %v", sweepResult.Tx.TxHash())	1✔
192	outcome = channeldb.ResolverOutcomeUnclaimed	1✔
193
194	// No errors, therefore continue processing.
195	case nil:	2✔
196	c.log.Infof("local commitment output fully resolved by "+	2✔
197	"sweep tx: %v", sweepResult.Tx.TxHash())	2✔
198	// Unknown errors.
199	default:	×
200	c.log.Errorf("unable to sweep input: %v",	×
201	sweepResult.Err)	×
202		×
203	return nil, sweepResult.Err	×
204	}
205
206	sweepTxID = sweepResult.Tx.TxHash()	3✔
207
UNCOV 208	case <-c.quit:	×
UNCOV 209	return nil, errResolverShuttingDown	×
210	}
211
212	// Funds have been swept and balance is no longer in limbo.
213	c.reportLock.Lock()	3✔
214	if outcome == channeldb.ResolverOutcomeClaimed {	5✔
215	// We only record the balance as recovered if it actually came	2✔
216	// back to us.	2✔
217	c.currentReport.RecoveredBalance = c.currentReport.LimboBalance	2✔
218	}	2✔
219	c.currentReport.LimboBalance = 0	3✔
220	c.reportLock.Unlock()	3✔
221	report := c.currentReport.resolverReport(	3✔
222	&sweepTxID, channeldb.ResolverTypeCommit, outcome,	3✔
223	)	3✔
224	c.markResolved()	3✔
225		3✔
226	// Checkpoint the resolver with a closure that will write the outcome	3✔
227	// of the resolver and its sweep transaction to disk.	3✔
228	return nil, c.Checkpoint(c, report)	3✔
229	}
230
231	// Stop signals the resolver to cancel any current resolution processes, and
232	// suspend.
233	//
234	// NOTE: Part of the ContractResolver interface.
UNCOV 235	func (c *commitSweepResolver) Stop() {	×
UNCOV 236	c.log.Debugf("stopping...")	×
UNCOV 237	defer c.log.Debugf("stopped")	×
UNCOV 238	close(c.quit)	×
UNCOV 239	}	×
240
241	// SupplementState allows the user of a ContractResolver to supplement it with
242	// state required for the proper resolution of a contract.
243	//
244	// NOTE: Part of the ContractResolver interface.
UNCOV 245	func (c commitSweepResolver) SupplementState(state channeldb.OpenChannel) {	×
UNCOV 246	if state.ChanType.HasLeaseExpiration() {	×
UNCOV 247	c.leaseExpiry = state.ThawHeight	×
UNCOV 248	}	×
UNCOV 249	c.localChanCfg = state.LocalChanCfg	×
UNCOV 250	c.channelInitiator = state.IsInitiator	×
UNCOV 251	c.chanType = state.ChanType	×
252	}
253
254	// hasCLTV denotes whether the resolver must wait for an additional CLTV to
255	// expire before resolving the contract.
256	func (c *commitSweepResolver) hasCLTV() bool {	8✔
257	return c.channelInitiator && c.leaseExpiry > 0	8✔
258	}	8✔
259
260	// Encode writes an encoded version of the ContractResolver into the passed
261	// Writer.
262	//
263	// NOTE: Part of the ContractResolver interface.
264	func (c *commitSweepResolver) Encode(w io.Writer) error {	1✔
265	if err := encodeCommitResolution(w, &c.commitResolution); err != nil {	1✔
266	return err	×
267	}	×
268
269	if err := binary.Write(w, endian, c.IsResolved()); err != nil {	1✔
270	return err	×
271	}	×
272	if err := binary.Write(w, endian, c.broadcastHeight); err != nil {	1✔
273	return err	×
274	}	×
275	if _, err := w.Write(c.chanPoint.Hash[:]); err != nil {	1✔
276	return err	×
277	}	×
278	err := binary.Write(w, endian, c.chanPoint.Index)	1✔
279	if err != nil {	1✔
280	return err	×
281	}	×
282
283	// Previously a sweep tx was serialized at this point. Refactoring
284	// removed this, but keep in mind that this data may still be present in
285	// the database.
286
287	return nil	1✔
288	}
289
290	// newCommitSweepResolverFromReader attempts to decode an encoded
291	// ContractResolver from the passed Reader instance, returning an active
292	// ContractResolver instance.
293	func newCommitSweepResolverFromReader(r io.Reader, resCfg ResolverConfig) (
294	*commitSweepResolver, error) {	1✔
295		1✔
296	c := &commitSweepResolver{	1✔
297	contractResolverKit: *newContractResolverKit(resCfg),	1✔
298	}	1✔
299		1✔
300	if err := decodeCommitResolution(r, &c.commitResolution); err != nil {	1✔
301	return nil, err	×
302	}	×
303
304	var resolved bool	1✔
305	if err := binary.Read(r, endian, &resolved); err != nil {	1✔
306	return nil, err	×
307	}	×
308	if resolved {	1✔
309	c.markResolved()	×
310	}	×
311
312	if err := binary.Read(r, endian, &c.broadcastHeight); err != nil {	1✔
313	return nil, err	×
314	}	×
315	_, err := io.ReadFull(r, c.chanPoint.Hash[:])	1✔
316	if err != nil {	1✔
317	return nil, err	×
318	}	×
319	err = binary.Read(r, endian, &c.chanPoint.Index)	1✔
320	if err != nil {	1✔
321	return nil, err	×
322	}	×
323
324	// Previously a sweep tx was deserialized at this point. Refactoring
325	// removed this, but keep in mind that this data may still be present in
326	// the database.
327
328	c.initLogger(fmt.Sprintf("%T(%v)", c, c.commitResolution.SelfOutPoint))	1✔
329	c.initReport()	1✔
330		1✔
331	return c, nil	1✔
332	}
333
334	// report returns a report on the resolution state of the contract.
335	func (c commitSweepResolver) report() ContractReport {	6✔
336	c.reportLock.Lock()	6✔
337	defer c.reportLock.Unlock()	6✔
338		6✔
339	cpy := c.currentReport	6✔
340	return &cpy	6✔
341	}	6✔
342
343	// initReport initializes the pending channels report for this resolver.
344	func (c *commitSweepResolver) initReport() {	4✔
345	amt := btcutil.Amount(	4✔
346	c.commitResolution.SelfOutputSignDesc.Output.Value,	4✔
347	)	4✔
348		4✔
349	// Set the initial report. All fields are filled in, except for the	4✔
350	// maturity height which remains 0 until Resolve() is executed.	4✔
351	//	4✔
352	// TODO(joostjager): Resolvers only activate after the commit tx	4✔
353	// confirms. With more refactoring in channel arbitrator, it would be	4✔
354	// possible to make the confirmation height part of ResolverConfig and	4✔
355	// populate MaturityHeight here.	4✔
356	c.currentReport = ContractReport{	4✔
357	Outpoint: c.commitResolution.SelfOutPoint,	4✔
358	Type: ReportOutputUnencumbered,	4✔
359	Amount: amt,	4✔
360	LimboBalance: amt,	4✔
361	RecoveredBalance: 0,	4✔
362	}	4✔
363	}	4✔
364
365	// A compile time assertion to ensure commitSweepResolver meets the
366	// ContractResolver interface.
367	var _ reportingContractResolver = (*commitSweepResolver)(nil)
368
369	// Launch constructs a commit input and offers it to the sweeper.
370	func (c *commitSweepResolver) Launch() error {	3✔
371	if c.isLaunched() {	3✔
UNCOV 372	c.log.Tracef("already launched")	×
UNCOV 373	return nil	×
UNCOV 374	}	×
375
376	c.log.Debugf("launching resolver...")	3✔
377	c.markLaunched()	3✔
378		3✔
379	// If we're already resolved, then we can exit early.	3✔
380	if c.IsResolved() {	3✔
381	c.log.Errorf("already resolved")	×
382	return nil	×
383	}	×
384
385	confHeight, err := c.getCommitTxConfHeight()	3✔
386	if err != nil {	3✔
387	return err	×
388	}	×
389
390	// Wait up until the CSV expires, unless we also have a CLTV that
391	// expires after.
392	unlockHeight := confHeight + c.commitResolution.MaturityDelay	3✔
393	if c.hasCLTV() {	3✔
UNCOV 394	unlockHeight = uint32(math.Max(	×
UNCOV 395	float64(unlockHeight), float64(c.leaseExpiry),	×
UNCOV 396	))	×
UNCOV 397	}	×
398
399	// Update report now that we learned the confirmation height.
400	c.reportLock.Lock()	3✔
401	c.currentReport.MaturityHeight = unlockHeight	3✔
402	c.reportLock.Unlock()	3✔
403		3✔
404	// Derive the witness type for this input.	3✔
405	witnessType, err := c.decideWitnessType()	3✔
406	if err != nil {	3✔
407	return err	×
408	}	×
409
410	// We'll craft an input with all the information required for the
411	// sweeper to create a fully valid sweeping transaction to recover
412	// these coins.
413	var inp *input.BaseInput	3✔
414	if c.hasCLTV() {	3✔
UNCOV 415	inp = input.NewCsvInputWithCltv(	×
UNCOV 416	&c.commitResolution.SelfOutPoint, witnessType,	×
UNCOV 417	&c.commitResolution.SelfOutputSignDesc,	×
UNCOV 418	c.broadcastHeight, c.commitResolution.MaturityDelay,	×
UNCOV 419	c.leaseExpiry,	×
UNCOV 420	)	×
421	} else {	3✔
422	inp = input.NewCsvInput(	3✔
423	&c.commitResolution.SelfOutPoint, witnessType,	3✔
424	&c.commitResolution.SelfOutputSignDesc,	3✔
425	c.broadcastHeight, c.commitResolution.MaturityDelay,	3✔
426	)	3✔
427	}	3✔
428
429	// TODO(roasbeef): instead of ading ctrl block to the sign desc, make
430	// new input type, have sweeper set it?
431
432	// Calculate the budget for the sweeping this input.
433	budget := calculateBudget(	3✔
434	btcutil.Amount(inp.SignDesc().Output.Value),	3✔
435	c.Budget.ToLocalRatio, c.Budget.ToLocal,	3✔
436	)	3✔
437	c.log.Infof("sweeping commit output %v using budget=%v", witnessType,	3✔
438	budget)	3✔
439		3✔
440	// With our input constructed, we'll now offer it to the sweeper.	3✔
441	resultChan, err := c.Sweeper.SweepInput(	3✔
442	inp, sweep.Params{	3✔
443	Budget: budget,	3✔
444		3✔
445	// Specify a nil deadline here as there's no time	3✔
446	// pressure.	3✔
447	DeadlineHeight: fn.None[int32](),	3✔
448	},	3✔
449	)	3✔
450	if err != nil {	3✔
451	c.log.Errorf("unable to sweep input: %v", err)	×
452		×
453	return err	×
454	}	×
455
456	c.sweepResultChan = resultChan	3✔
457		3✔
458	return nil	3✔
459	}
460
461	// decideWitnessType returns the witness type for the input.
462	func (c *commitSweepResolver) decideWitnessType() (input.WitnessType, error) {	3✔
463	var (	3✔
464	isLocalCommitTx bool	3✔
465	signDesc = c.commitResolution.SelfOutputSignDesc	3✔
466	)	3✔
467		3✔
468	switch {	3✔
469	// For taproot channels, we'll know if this is the local commit based
470	// on the timelock value. For remote commitment transactions, the
471	// witness script has a timelock of 1.
UNCOV 472	case c.chanType.IsTaproot():	×
UNCOV 473	delayKey := c.localChanCfg.DelayBasePoint.PubKey	×
UNCOV 474	nonDelayKey := c.localChanCfg.PaymentBasePoint.PubKey	×
UNCOV 475		×
UNCOV 476	signKey := c.commitResolution.SelfOutputSignDesc.KeyDesc.PubKey	×
UNCOV 477		×
UNCOV 478	// If the key in the script is neither of these, we shouldn't	×
UNCOV 479	// proceed. This should be impossible.	×
UNCOV 480	if !signKey.IsEqual(delayKey) && !signKey.IsEqual(nonDelayKey) {	×
481	return nil, fmt.Errorf("unknown sign key %v", signKey)	×
482	}	×
483
484	// The commitment transaction is ours iff the signing key is
485	// the delay key.
UNCOV 486	isLocalCommitTx = signKey.IsEqual(delayKey)	×
487
488	// The output is on our local commitment if the script starts with
489	// OP_IF for the revocation clause. On the remote commitment it will
490	// either be a regular P2WKH or a simple sig spend with a CSV delay.
491	default:	3✔
492	isLocalCommitTx = signDesc.WitnessScript[0] == txscript.OP_IF	3✔
493	}
494
495	isDelayedOutput := c.commitResolution.MaturityDelay != 0	3✔
496		3✔
497	c.log.Debugf("isDelayedOutput=%v, isLocalCommitTx=%v", isDelayedOutput,	3✔
498	isLocalCommitTx)	3✔
499		3✔
500	// There're three types of commitments, those that have tweaks for the	3✔
501	// remote key (us in this case), those that don't, and a third where	3✔
502	// there is no tweak and the output is delayed. On the local commitment	3✔
503	// our output will always be delayed. We'll rely on the presence of the	3✔
504	// commitment tweak to discern which type of commitment this is.	3✔
505	var witnessType input.WitnessType	3✔
506	switch {	3✔
507	// The local delayed output for a taproot channel.
UNCOV 508	case isLocalCommitTx && c.chanType.IsTaproot():	×
UNCOV 509	witnessType = input.TaprootLocalCommitSpend	×
510
511	// The CSV 1 delayed output for a taproot channel.
UNCOV 512	case !isLocalCommitTx && c.chanType.IsTaproot():	×
UNCOV 513	witnessType = input.TaprootRemoteCommitSpend	×
514
515	// Delayed output to us on our local commitment for a channel lease in
516	// which we are the initiator.
UNCOV 517	case isLocalCommitTx && c.hasCLTV():	×
UNCOV 518	witnessType = input.LeaseCommitmentTimeLock	×
519
520	// Delayed output to us on our local commitment.
UNCOV 521	case isLocalCommitTx:	×
UNCOV 522	witnessType = input.CommitmentTimeLock	×
523
524	// A confirmed output to us on the remote commitment for a channel lease
525	// in which we are the initiator.
UNCOV 526	case isDelayedOutput && c.hasCLTV():	×
UNCOV 527	witnessType = input.LeaseCommitmentToRemoteConfirmed	×
528
529	// A confirmed output to us on the remote commitment.
530	case isDelayedOutput:	2✔
531	witnessType = input.CommitmentToRemoteConfirmed	2✔
532
533	// A non-delayed output on the remote commitment where the key is
534	// tweakless.
535	case c.commitResolution.SelfOutputSignDesc.SingleTweak == nil:	1✔
536	witnessType = input.CommitSpendNoDelayTweakless	1✔
537
538	// A non-delayed output on the remote commitment where the key is
539	// tweaked.
540	default:	×
541	witnessType = input.CommitmentNoDelay	×
542	}
543
544	return witnessType, nil	3✔
545	}

lightningnetwork / lnd / 13236757158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous