12312390362

Committed 13 Dec 2024 08:44AM UTC coverage: 57.458% (+8.5%) from 48.92%

Build # 12312390362

Build Type

Pull #9343

github

Committed by

ellemouton

Commit Message

fn: rework the ContextGuard and add tests

In this commit, the ContextGuard struct is re-worked such that the
context that its new main WithCtx method provides is cancelled in sync
with a parent context being cancelled or with it's quit channel being
cancelled. Tests are added to assert the behaviour. In order for the
close of the quit channel to be consistent with the cancelling of the
derived context, the quit channel _must_ be contained internal to the
ContextGuard so that callers are only able to close the channel via the
exposed Quit method which will then take care to first cancel any
derived context that depend on the quit channel before returning.

Pull Request Pull Request #9343: fn: expand the ContextGuard and add tests

Run Details

101853 of 177264 relevant lines covered (57.46%)

24972.93 hits per line

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

76.91

/contractcourt/htlc_success_resolver.go

package contractcourt

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

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/txscript"
        "github.com/btcsuite/btcd/wire"
        "github.com/davecgh/go-spew/spew"
        "github.com/lightningnetwork/lnd/chainntnfs"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/labels"
        "github.com/lightningnetwork/lnd/lnutils"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/sweep"
)

// htlcSuccessResolver is a resolver that's capable of sweeping an incoming
// HTLC output on-chain. If this is the remote party's commitment, we'll sweep
// it directly from the commitment output *immediately*. If this is our
// commitment, we'll first broadcast the success transaction, then send it to
// the incubator for sweeping. That's it, no need to send any clean up
// messages.
//
// TODO(roasbeef): don't need to broadcast?
type htlcSuccessResolver struct {
        // htlcResolution is the incoming HTLC resolution for this HTLC. It
        // contains everything we need to properly resolve this HTLC.
        htlcResolution lnwallet.IncomingHtlcResolution

        // outputIncubating returns true if we've sent the output to the output
        // incubator (utxo nursery). In case the htlcResolution has non-nil
        // SignDetails, it means we will let the Sweeper handle broadcasting
        // the secondd-level transaction, and sweeping its output. In this case
        // we let this field indicate whether we need to broadcast the
        // second-level tx (false) or if it has confirmed and we must sweep the
        // second-level output (true).
        outputIncubating bool

        // resolved reflects if the contract has been fully resolved or not.
        resolved bool

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

        // htlc contains information on the htlc that we are resolving on-chain.
        htlc channeldb.HTLC

        // currentReport stores the current state of the resolver for reporting
        // over the rpc interface. This should only be reported in case we have
        // a non-nil SignDetails on the htlcResolution, otherwise the nursery
        // will produce reports.
        currentReport ContractReport

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

        contractResolverKit

        htlcLeaseResolver
}

// newSuccessResolver instanties a new htlc success resolver.
func newSuccessResolver(res lnwallet.IncomingHtlcResolution,
        broadcastHeight uint32, htlc channeldb.HTLC,
        resCfg ResolverConfig) *htlcSuccessResolver {

        h := &htlcSuccessResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                htlcResolution:      res,
                broadcastHeight:     broadcastHeight,
                htlc:                htlc,
        }

        h.initReport()

        return h
}

// ResolverKey returns an identifier which should be globally unique for this
// particular resolver within the chain the original contract resides within.
//
// NOTE: Part of the ContractResolver interface.
func (h *htlcSuccessResolver) ResolverKey() []byte {
        // The primary key for this resolver will be the outpoint of the HTLC
        // on the commitment transaction itself. If this is our commitment,
        // then the output can be found within the signed success tx,
        // otherwise, it's just the ClaimOutpoint.
        var op wire.OutPoint
        if h.htlcResolution.SignedSuccessTx != nil {
                op = h.htlcResolution.SignedSuccessTx.TxIn[0].PreviousOutPoint
        } else {
                op = h.htlcResolution.ClaimOutpoint
        }

        key := newResolverID(op)
        return key[:]
}

// Resolve attempts to resolve an unresolved incoming HTLC that we know the
// preimage to. If the HTLC is on the commitment of the remote party, then we'll
// simply sweep it directly. Otherwise, we'll hand this off to the utxo nursery
// to do its duty. There is no need to make a call to the invoice registry
// anymore. Every HTLC has already passed through the incoming contest resolver
// and in there the invoice was already marked as settled.
//
// TODO(roasbeef): create multi to batch
//
// NOTE: Part of the ContractResolver interface.
func (h *htlcSuccessResolver) Resolve(
        immediate bool) (ContractResolver, error) {

        // If we're already resolved, then we can exit early.
        if h.resolved {
                return nil, nil
        }

        // If we don't have a success transaction, then this means that this is
        // an output on the remote party's commitment transaction.
        if h.htlcResolution.SignedSuccessTx == nil {
                return h.resolveRemoteCommitOutput(immediate)
        }

        // Otherwise this an output on our own commitment, and we must start by
        // broadcasting the second-level success transaction.
        secondLevelOutpoint, err := h.broadcastSuccessTx(immediate)
        if err != nil {
                return nil, err
        }

        // To wrap this up, we'll wait until the second-level transaction has
        // been spent, then fully resolve the contract.
        log.Infof("%T(%x): waiting for second-level HTLC output to be spent "+
                "after csv_delay=%v", h, h.htlc.RHash[:], h.htlcResolution.CsvDelay)

        spend, err := waitForSpend(
                secondLevelOutpoint,
                h.htlcResolution.SweepSignDesc.Output.PkScript,
                h.broadcastHeight, h.Notifier, h.quit,
        )
        if err != nil {
                return nil, err
        }

        h.reportLock.Lock()
        h.currentReport.RecoveredBalance = h.currentReport.LimboBalance
        h.currentReport.LimboBalance = 0
        h.reportLock.Unlock()

        h.resolved = true
        return nil, h.checkpointClaim(
                spend.SpenderTxHash, channeldb.ResolverOutcomeClaimed,
        )
}

// broadcastSuccessTx handles an HTLC output on our local commitment by
// broadcasting the second-level success transaction. It returns the ultimate
// outpoint of the second-level tx, that we must wait to be spent for the
// resolver to be fully resolved.
func (h *htlcSuccessResolver) broadcastSuccessTx(
        immediate bool) (*wire.OutPoint, error) {

        // If we have non-nil SignDetails, this means that have a 2nd level
        // HTLC transaction that is signed using sighash SINGLE|ANYONECANPAY
        // (the case for anchor type channels). In this case we can re-sign it
        // and attach fees at will. We let the sweeper handle this job.  We use
        // the checkpointed outputIncubating field to determine if we already
        // swept the HTLC output into the second level transaction.
        if h.htlcResolution.SignDetails != nil {
                return h.broadcastReSignedSuccessTx(immediate)
        }

        // Otherwise we'll publish the second-level transaction directly and
        // offer the resolution to the nursery to handle.
        log.Infof("%T(%x): broadcasting second-layer transition tx: %v",
                h, h.htlc.RHash[:], spew.Sdump(h.htlcResolution.SignedSuccessTx))

        // We'll now broadcast the second layer transaction so we can kick off
        // the claiming process.
        //
        // TODO(roasbeef): after changing sighashes send to tx bundler
        label := labels.MakeLabel(
                labels.LabelTypeChannelClose, &h.ShortChanID,
        )
        err := h.PublishTx(h.htlcResolution.SignedSuccessTx, label)
        if err != nil {
                return nil, err
        }

        // Otherwise, this is an output on our commitment transaction. In this
        // case, we'll send it to the incubator, but only if we haven't already
        // done so.
        if !h.outputIncubating {
                log.Infof("%T(%x): incubating incoming htlc output",
                        h, h.htlc.RHash[:])

                err := h.IncubateOutputs(
                        h.ChanPoint, fn.None[lnwallet.OutgoingHtlcResolution](),
                        fn.Some(h.htlcResolution),
                        h.broadcastHeight, fn.Some(int32(h.htlc.RefundTimeout)),
                )
                if err != nil {
                        return nil, err
                }

                h.outputIncubating = true

                if err := h.Checkpoint(h); err != nil {
                        log.Errorf("unable to Checkpoint: %v", err)
                        return nil, err
                }
        }

        return &h.htlcResolution.ClaimOutpoint, nil
}

// broadcastReSignedSuccessTx handles the case where we have non-nil
// SignDetails, and offers the second level transaction to the Sweeper, that
// will re-sign it and attach fees at will.
//
//nolint:funlen
func (h *htlcSuccessResolver) broadcastReSignedSuccessTx(immediate bool) (
        *wire.OutPoint, error) {

        // Keep track of the tx spending the HTLC output on the commitment, as
        // this will be the confirmed second-level tx we'll ultimately sweep.
        var commitSpend *chainntnfs.SpendDetail

        // We will have to let the sweeper re-sign the success tx and wait for
        // it to confirm, if we haven't already.
        isTaproot := txscript.IsPayToTaproot(
                h.htlcResolution.SweepSignDesc.Output.PkScript,
        )
        if !h.outputIncubating {
                var secondLevelInput input.HtlcSecondLevelAnchorInput
                if isTaproot {
                        //nolint:ll
                        secondLevelInput = input.MakeHtlcSecondLevelSuccessTaprootInput(
                                h.htlcResolution.SignedSuccessTx,
                                h.htlcResolution.SignDetails, h.htlcResolution.Preimage,
                                h.broadcastHeight,
                                input.WithResolutionBlob(
                                        h.htlcResolution.ResolutionBlob,
                                ),
                        )
                } else {
                        //nolint:ll
                        secondLevelInput = input.MakeHtlcSecondLevelSuccessAnchorInput(
                                h.htlcResolution.SignedSuccessTx,
                                h.htlcResolution.SignDetails, h.htlcResolution.Preimage,
                                h.broadcastHeight,
                        )
                }

                // Calculate the budget for this sweep.
                value := btcutil.Amount(
                        secondLevelInput.SignDesc().Output.Value,
                )
                budget := calculateBudget(
                        value, h.Budget.DeadlineHTLCRatio,
                        h.Budget.DeadlineHTLC,
                )

                // The deadline would be the CLTV in this HTLC output. If we
                // are the initiator of this force close, with the default
                // `IncomingBroadcastDelta`, it means we have 10 blocks left
                // when going onchain. Given we need to mine one block to
                // confirm the force close tx, and one more block to trigger
                // the sweep, we have 8 blocks left to sweep the HTLC.
                deadline := fn.Some(int32(h.htlc.RefundTimeout))

                log.Infof("%T(%x): offering second-level HTLC success tx to "+
                        "sweeper with deadline=%v, budget=%v", h,
                        h.htlc.RHash[:], h.htlc.RefundTimeout, budget)

                // We'll now offer the second-level transaction to the sweeper.
                _, err := h.Sweeper.SweepInput(
                        &secondLevelInput,
                        sweep.Params{
                                Budget:         budget,
                                DeadlineHeight: deadline,
                                Immediate:      immediate,
                        },
                )
                if err != nil {
                        return nil, err
                }

                log.Infof("%T(%x): waiting for second-level HTLC success "+
                        "transaction to confirm", h, h.htlc.RHash[:])

                // Wait for the second level transaction to confirm.
                commitSpend, err = waitForSpend(
                        &h.htlcResolution.SignedSuccessTx.TxIn[0].PreviousOutPoint,
                        h.htlcResolution.SignDetails.SignDesc.Output.PkScript,
                        h.broadcastHeight, h.Notifier, h.quit,
                )
                if err != nil {
                        return nil, err
                }

                // Now that the second-level transaction has confirmed, we
                // checkpoint the state so we'll go to the next stage in case
                // of restarts.
                h.outputIncubating = true
                if err := h.Checkpoint(h); err != nil {
                        log.Errorf("unable to Checkpoint: %v", err)
                        return nil, err
                }

                log.Infof("%T(%x): second-level HTLC success transaction "+
                        "confirmed!", h, h.htlc.RHash[:])
        }

        // If we ended up here after a restart, we must again get the
        // spend notification.
        if commitSpend == nil {
                var err error
                commitSpend, err = waitForSpend(
                        &h.htlcResolution.SignedSuccessTx.TxIn[0].PreviousOutPoint,
                        h.htlcResolution.SignDetails.SignDesc.Output.PkScript,
                        h.broadcastHeight, h.Notifier, h.quit,
                )
                if err != nil {
                        return nil, err
                }
        }

        // The HTLC success tx has a CSV lock that we must wait for, and if
        // this is a lease enforced channel and we're the imitator, we may need
        // to wait for longer.
        waitHeight := h.deriveWaitHeight(
                h.htlcResolution.CsvDelay, commitSpend,
        )

        // Now that the sweeper has broadcasted the second-level transaction,
        // it has confirmed, and we have checkpointed our state, we'll sweep
        // the second level output. We report the resolver has moved the next
        // stage.
        h.reportLock.Lock()
        h.currentReport.Stage = 2
        h.currentReport.MaturityHeight = waitHeight
        h.reportLock.Unlock()

        if h.hasCLTV() {
                log.Infof("%T(%x): waiting for CSV and CLTV lock to "+
                        "expire at height %v", h, h.htlc.RHash[:],
                        waitHeight)
        } else {
                log.Infof("%T(%x): waiting for CSV lock to expire at "+
                        "height %v", h, h.htlc.RHash[:], waitHeight)
        }

        // Deduct one block so this input is offered to the sweeper one block
        // earlier since the sweeper will wait for one block to trigger the
        // sweeping.
        //
        // TODO(yy): this is done so the outputs can be aggregated
        // properly. Suppose CSV locks of five 2nd-level outputs all
        // expire at height 840000, there is a race in block digestion
        // between contractcourt and sweeper:
        // - G1: block 840000 received in contractcourt, it now offers
        //   the outputs to the sweeper.
        // - G2: block 840000 received in sweeper, it now starts to
        //   sweep the received outputs - there's no guarantee all
        //   fives have been received.
        // To solve this, we either offer the outputs earlier, or
        // implement `blockbeat`, and force contractcourt and sweeper
        // to consume each block sequentially.
        waitHeight--

        // TODO(yy): let sweeper handles the wait?
        err := waitForHeight(waitHeight, h.Notifier, h.quit)
        if err != nil {
                return nil, err
        }

        // We'll use this input index to determine the second-level output
        // index on the transaction, as the signatures requires the indexes to
        // be the same. We don't look for the second-level output script
        // directly, as there might be more than one HTLC output to the same
        // pkScript.
        op := &wire.OutPoint{
                Hash:  *commitSpend.SpenderTxHash,
                Index: commitSpend.SpenderInputIndex,
        }

        // Let the sweeper sweep the second-level output now that the
        // CSV/CLTV locks have expired.
        var witType input.StandardWitnessType
        if isTaproot {
                witType = input.TaprootHtlcAcceptedSuccessSecondLevel
        } else {
                witType = input.HtlcAcceptedSuccessSecondLevel
        }
        inp := h.makeSweepInput(
                op, witType,
                input.LeaseHtlcAcceptedSuccessSecondLevel,
                &h.htlcResolution.SweepSignDesc,
                h.htlcResolution.CsvDelay, uint32(commitSpend.SpendingHeight),
                h.htlc.RHash, h.htlcResolution.ResolutionBlob,
        )

        // Calculate the budget for this sweep.
        budget := calculateBudget(
                btcutil.Amount(inp.SignDesc().Output.Value),
                h.Budget.NoDeadlineHTLCRatio,
                h.Budget.NoDeadlineHTLC,
        )

        log.Infof("%T(%x): offering second-level success tx output to sweeper "+
                "with no deadline and budget=%v at height=%v", h,
                h.htlc.RHash[:], budget, waitHeight)

        // TODO(roasbeef): need to update above for leased types
        _, err = h.Sweeper.SweepInput(
                inp,
                sweep.Params{
                        Budget: budget,

                        // For second level success tx, there's no rush to get
                        // it confirmed, so we use a nil deadline.
                        DeadlineHeight: fn.None[int32](),
                },
        )
        if err != nil {
                return nil, err
        }

        // Will return this outpoint, when this is spent the resolver is fully
        // resolved.
        return op, nil
}

// resolveRemoteCommitOutput handles sweeping an HTLC output on the remote
// commitment with the preimage. In this case we can sweep the output directly,
// and don't have to broadcast a second-level transaction.
func (h *htlcSuccessResolver) resolveRemoteCommitOutput(immediate bool) (
        ContractResolver, error) {

        isTaproot := txscript.IsPayToTaproot(
                h.htlcResolution.SweepSignDesc.Output.PkScript,
        )

        // Before we can craft out sweeping transaction, we need to
        // create an input which contains all the items required to add
        // this input to a sweeping transaction, and generate a
        // witness.
        var inp input.Input
        if isTaproot {
                inp = lnutils.Ptr(input.MakeTaprootHtlcSucceedInput(
                        &h.htlcResolution.ClaimOutpoint,
                        &h.htlcResolution.SweepSignDesc,
                        h.htlcResolution.Preimage[:],
                        h.broadcastHeight,
                        h.htlcResolution.CsvDelay,
                        input.WithResolutionBlob(
                                h.htlcResolution.ResolutionBlob,
                        ),
                ))
        } else {
                inp = lnutils.Ptr(input.MakeHtlcSucceedInput(
                        &h.htlcResolution.ClaimOutpoint,
                        &h.htlcResolution.SweepSignDesc,
                        h.htlcResolution.Preimage[:],
                        h.broadcastHeight,
                        h.htlcResolution.CsvDelay,
                ))
        }

        // Calculate the budget for this sweep.
        budget := calculateBudget(
                btcutil.Amount(inp.SignDesc().Output.Value),
                h.Budget.DeadlineHTLCRatio,
                h.Budget.DeadlineHTLC,
        )

        deadline := fn.Some(int32(h.htlc.RefundTimeout))

        log.Infof("%T(%x): offering direct-preimage HTLC output to sweeper "+
                "with deadline=%v, budget=%v", h, h.htlc.RHash[:],
                h.htlc.RefundTimeout, budget)

        // We'll now offer the direct preimage HTLC to the sweeper.
        _, err := h.Sweeper.SweepInput(
                inp,
                sweep.Params{
                        Budget:         budget,
                        DeadlineHeight: deadline,
                        Immediate:      immediate,
                },
        )
        if err != nil {
                return nil, err
        }

        // Wait for the direct-preimage HTLC sweep tx to confirm.
        sweepTxDetails, err := waitForSpend(
                &h.htlcResolution.ClaimOutpoint,
                h.htlcResolution.SweepSignDesc.Output.PkScript,
                h.broadcastHeight, h.Notifier, h.quit,
        )
        if err != nil {
                return nil, err
        }

        // Once the transaction has received a sufficient number of
        // confirmations, we'll mark ourselves as fully resolved and exit.
        h.resolved = true

        // Checkpoint the resolver, and write the outcome to disk.
        return nil, h.checkpointClaim(
                sweepTxDetails.SpenderTxHash,
                channeldb.ResolverOutcomeClaimed,
        )
}

// checkpointClaim checkpoints the success resolver with the reports it needs.
// If this htlc was claimed two stages, it will write reports for both stages,
// otherwise it will just write for the single htlc claim.
func (h *htlcSuccessResolver) checkpointClaim(spendTx *chainhash.Hash,
        outcome channeldb.ResolverOutcome) error {

        // Mark the htlc as final settled.
        err := h.ChainArbitratorConfig.PutFinalHtlcOutcome(
                h.ChannelArbitratorConfig.ShortChanID, h.htlc.HtlcIndex, true,
        )
        if err != nil {
                return err
        }

        // Send notification.
        h.ChainArbitratorConfig.HtlcNotifier.NotifyFinalHtlcEvent(
                models.CircuitKey{
                        ChanID: h.ShortChanID,
                        HtlcID: h.htlc.HtlcIndex,
                },
                channeldb.FinalHtlcInfo{
                        Settled:  true,
                        Offchain: false,
                },
        )

        // Create a resolver report for claiming of the htlc itself.
        amt := btcutil.Amount(h.htlcResolution.SweepSignDesc.Output.Value)
        reports := []*channeldb.ResolverReport{
                {
                        OutPoint:        h.htlcResolution.ClaimOutpoint,
                        Amount:          amt,
                        ResolverType:    channeldb.ResolverTypeIncomingHtlc,
                        ResolverOutcome: outcome,
                        SpendTxID:       spendTx,
                },
        }

        // If we have a success tx, we append a report to represent our first
        // stage claim.
        if h.htlcResolution.SignedSuccessTx != nil {
                // If the SignedSuccessTx is not nil, we are claiming the htlc
                // in two stages, so we need to create a report for the first
                // stage transaction as well.
                spendTx := h.htlcResolution.SignedSuccessTx
                spendTxID := spendTx.TxHash()

                report := &channeldb.ResolverReport{
                        OutPoint:        spendTx.TxIn[0].PreviousOutPoint,
                        Amount:          h.htlc.Amt.ToSatoshis(),
                        ResolverType:    channeldb.ResolverTypeIncomingHtlc,
                        ResolverOutcome: channeldb.ResolverOutcomeFirstStage,
                        SpendTxID:       &spendTxID,
                }
                reports = append(reports, report)
        }

        // Finally, we checkpoint the resolver with our report(s).
        return h.Checkpoint(h, reports...)
}

// Stop signals the resolver to cancel any current resolution processes, and
// suspend.
//
// NOTE: Part of the ContractResolver interface.
func (h *htlcSuccessResolver) Stop() {
        close(h.quit)
}

// IsResolved returns true if the stored state in the resolve is fully
// resolved. In this case the target output can be forgotten.
//
// NOTE: Part of the ContractResolver interface.
func (h *htlcSuccessResolver) IsResolved() bool {
        return h.resolved
}

// report returns a report on the resolution state of the contract.
func (h *htlcSuccessResolver) report() *ContractReport {
        // If the sign details are nil, the report will be created by handled
        // by the nursery.
        if h.htlcResolution.SignDetails == nil {
                return nil
        }

        h.reportLock.Lock()
        defer h.reportLock.Unlock()
        cpy := h.currentReport
        return &cpy
}

func (h *htlcSuccessResolver) initReport() {
        // We create the initial report. This will only be reported for
        // resolvers not handled by the nursery.
        finalAmt := h.htlc.Amt.ToSatoshis()
        if h.htlcResolution.SignedSuccessTx != nil {
                finalAmt = btcutil.Amount(
                        h.htlcResolution.SignedSuccessTx.TxOut[0].Value,
                )
        }

        h.currentReport = ContractReport{
                Outpoint:       h.htlcResolution.ClaimOutpoint,
                Type:           ReportOutputIncomingHtlc,
                Amount:         finalAmt,
                MaturityHeight: h.htlcResolution.CsvDelay,
                LimboBalance:   finalAmt,
                Stage:          1,
        }
}

// Encode writes an encoded version of the ContractResolver into the passed
// Writer.
//
// NOTE: Part of the ContractResolver interface.
func (h *htlcSuccessResolver) Encode(w io.Writer) error {
        // First we'll encode our inner HTLC resolution.
        if err := encodeIncomingResolution(w, &h.htlcResolution); err != nil {
                return err
        }

        // Next, we'll write out the fields that are specified to the contract
        // resolver.
        if err := binary.Write(w, endian, h.outputIncubating); err != nil {
                return err
        }
        if err := binary.Write(w, endian, h.resolved); err != nil {
                return err
        }
        if err := binary.Write(w, endian, h.broadcastHeight); err != nil {
                return err
        }
        if _, err := w.Write(h.htlc.RHash[:]); err != nil {
                return err
        }

        // We encode the sign details last for backwards compatibility.
        err := encodeSignDetails(w, h.htlcResolution.SignDetails)
        if err != nil {
                return err
        }

        return nil
}

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

        h := &htlcSuccessResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
        }

        // First we'll decode our inner HTLC resolution.
        if err := decodeIncomingResolution(r, &h.htlcResolution); err != nil {
                return nil, err
        }

        // Next, we'll read all the fields that are specified to the contract
        // resolver.
        if err := binary.Read(r, endian, &h.outputIncubating); err != nil {
                return nil, err
        }
        if err := binary.Read(r, endian, &h.resolved); err != nil {
                return nil, err
        }
        if err := binary.Read(r, endian, &h.broadcastHeight); err != nil {
                return nil, err
        }
        if _, err := io.ReadFull(r, h.htlc.RHash[:]); err != nil {
                return nil, err
        }

        // Sign details is a new field that was added to the htlc resolution,
        // so it is serialized last for backwards compatibility. We try to read
        // it, but don't error out if there are not bytes left.
        signDetails, err := decodeSignDetails(r)
        if err == nil {
                h.htlcResolution.SignDetails = signDetails
        } else if err != io.EOF && err != io.ErrUnexpectedEOF {
                return nil, err
        }

        h.initReport()

        return h, nil
}

// Supplement adds additional information to the resolver that is required
// before Resolve() is called.
//
// NOTE: Part of the htlcContractResolver interface.
func (h *htlcSuccessResolver) Supplement(htlc channeldb.HTLC) {
        h.htlc = htlc
}

// HtlcPoint returns the htlc's outpoint on the commitment tx.
//
// NOTE: Part of the htlcContractResolver interface.
func (h *htlcSuccessResolver) HtlcPoint() wire.OutPoint {
        return h.htlcResolution.HtlcPoint()
}

// SupplementDeadline does nothing for an incoming htlc resolver.
//
// NOTE: Part of the htlcContractResolver interface.
func (h *htlcSuccessResolver) SupplementDeadline(_ fn.Option[int32]) {
}

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

lightningnetwork / lnd / 12312390362

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