12349698563

Committed 16 Dec 2024 09:29AM UTC coverage: 58.55% (-0.09%) from 58.636%

Build # 12349698563

Build Type

Pull #9357

github

Committed by

GeorgeTsagk

Commit Message

contractcourt: include custom records on replayed htlc

When notifying the invoice registry for an exit hop htlc we also want to
include its custom records. The channelLink, the other caller of this
method, already populates this field. So we make sure the contest
resolver does so too.

Pull Request Pull Request #9357: contractcourt: include custom records on replayed htlc

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

262 existing lines in 24 files now uncovered.

134243 of 229278 relevant lines covered (58.55%)

19277.11 hits per line

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

59.04

/lnwallet/btcwallet/blockchain.go

package btcwallet

import (
        "encoding/hex"
        "errors"
        "fmt"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        "github.com/btcsuite/btcwallet/chain"
        "github.com/lightninglabs/neutrino"
        "github.com/lightninglabs/neutrino/headerfs"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwallet"
)

var (
        // ErrOutputSpent is returned by the GetUtxo method if the target output
        // for lookup has already been spent.
        ErrOutputSpent = errors.New("target output has been spent")

        // ErrOutputNotFound signals that the desired output could not be
        // located.
        ErrOutputNotFound = errors.New("target output was not found")
)

// GetBestBlock returns the current height and hash of the best known block
// within the main chain.
//
// This method is a part of the lnwallet.BlockChainIO interface.
func (b *BtcWallet) GetBestBlock() (*chainhash.Hash, int32, error) {
        return b.chain.GetBestBlock()
}

// GetUtxo returns the original output referenced by the passed outpoint that
// creates the target pkScript.
//
// This method is a part of the lnwallet.BlockChainIO interface.
func (b *BtcWallet) GetUtxo(op *wire.OutPoint, pkScript []byte,
        heightHint uint32, cancel <-chan struct{}) (*wire.TxOut, error) {

        switch backend := b.chain.(type) {

        case *chain.NeutrinoClient:
                spendReport, err := backend.CS.GetUtxo(
                        neutrino.WatchInputs(neutrino.InputWithScript{
                                OutPoint: *op,
                                PkScript: pkScript,
                        }),
                        neutrino.StartBlock(&headerfs.BlockStamp{
                                Height: int32(heightHint),
                        }),
                        neutrino.QuitChan(cancel),
                )
                if err != nil {
                        return nil, err
                }

                // If the spend report is nil, then the output was not found in
                // the rescan.
                if spendReport == nil {
                        return nil, ErrOutputNotFound
                }

                // If the spending transaction is populated in the spend report,
                // this signals that the output has already been spent.
                if spendReport.SpendingTx != nil {
                        return nil, ErrOutputSpent
                }

                // Otherwise, the output is assumed to be in the UTXO.
                return spendReport.Output, nil

        case *chain.RPCClient:
                txout, err := backend.GetTxOut(&op.Hash, op.Index, false)
                if err != nil {
                        return nil, err
                } else if txout == nil {
                        return nil, ErrOutputSpent
                }

                pkScript, err := hex.DecodeString(txout.ScriptPubKey.Hex)
                if err != nil {
                        return nil, err
                }

                // We'll ensure we properly convert the amount given in BTC to
                // satoshis.
                amt, err := btcutil.NewAmount(txout.Value)
                if err != nil {
                        return nil, err
                }

                return &wire.TxOut{
                        Value:    int64(amt),
                        PkScript: pkScript,
                }, nil

        case *chain.BitcoindClient:
                txout, err := backend.GetTxOut(&op.Hash, op.Index, false)
                if err != nil {
                        return nil, err
                } else if txout == nil {
                        return nil, ErrOutputSpent
                }

                pkScript, err := hex.DecodeString(txout.ScriptPubKey.Hex)
                if err != nil {
                        return nil, err
                }

                // Sadly, gettxout returns the output value in BTC instead of
                // satoshis.
                amt, err := btcutil.NewAmount(txout.Value)
                if err != nil {
                        return nil, err
                }

                return &wire.TxOut{
                        Value:    int64(amt),
                        PkScript: pkScript,
                }, nil

        default:
                return nil, fmt.Errorf("unknown backend")
        }
}

// GetBlock returns a raw block from the server given its hash. For the Neutrino
// implementation of the lnwallet.BlockChainIO interface, the Neutrino GetBlock
// method is called directly. For other implementations, the block cache is used
// to wrap the call to GetBlock.
//
// This method is a part of the lnwallet.BlockChainIO interface.
func (b *BtcWallet) GetBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error) {
        _, ok := b.chain.(*chain.NeutrinoClient)
        if !ok {
                return b.blockCache.GetBlock(blockHash, b.chain.GetBlock)
        }

        // For the neutrino implementation of lnwallet.BlockChainIO the neutrino
        // GetBlock function can be called directly since it uses the same block
        // cache. However, it does not lock the block cache mutex for the given
        // block hash and so that is done here.
        b.blockCache.HashMutex.Lock(lntypes.Hash(*blockHash))
        defer b.blockCache.HashMutex.Unlock(lntypes.Hash(*blockHash))

        return b.chain.GetBlock(blockHash)
}

// GetBlockHeader returns a block header for the block with the given hash.
//
// This method is a part of the lnwallet.BlockChainIO interface.
func (b *BtcWallet) GetBlockHeader(
        blockHash *chainhash.Hash) (*wire.BlockHeader, error) {

        return b.chain.GetBlockHeader(blockHash)
}

// GetBlockHash returns the hash of the block in the best blockchain at the
// given height.
//
// This method is a part of the lnwallet.BlockChainIO interface.
func (b *BtcWallet) GetBlockHash(blockHeight int64) (*chainhash.Hash, error) {
        return b.chain.GetBlockHash(blockHeight)
}

// A compile time check to ensure that BtcWallet implements the BlockChainIO
// interface.
var _ lnwallet.WalletController = (*BtcWallet)(nil)

1	package btcwallet
2
3	import (
4	"encoding/hex"
5	"errors"
6	"fmt"
7
8	"github.com/btcsuite/btcd/btcutil"
9	"github.com/btcsuite/btcd/chaincfg/chainhash"
10	"github.com/btcsuite/btcd/wire"
11	"github.com/btcsuite/btcwallet/chain"
12	"github.com/lightninglabs/neutrino"
13	"github.com/lightninglabs/neutrino/headerfs"
14	"github.com/lightningnetwork/lnd/lntypes"
15	"github.com/lightningnetwork/lnd/lnwallet"
16	)
17
18	var (
19	// ErrOutputSpent is returned by the GetUtxo method if the target output
20	// for lookup has already been spent.
21	ErrOutputSpent = errors.New("target output has been spent")
22
23	// ErrOutputNotFound signals that the desired output could not be
24	// located.
25	ErrOutputNotFound = errors.New("target output was not found")
26	)
27
28	// GetBestBlock returns the current height and hash of the best known block
29	// within the main chain.
30	//
31	// This method is a part of the lnwallet.BlockChainIO interface.
32	func (b BtcWallet) GetBestBlock() (chainhash.Hash, int32, error) {	270✔
33	return b.chain.GetBestBlock()	270✔
34	}	270✔
35
36	// GetUtxo returns the original output referenced by the passed outpoint that
37	// creates the target pkScript.
38	//
39	// This method is a part of the lnwallet.BlockChainIO interface.
40	func (b BtcWallet) GetUtxo(op wire.OutPoint, pkScript []byte,
41	heightHint uint32, cancel <-chan struct{}) (*wire.TxOut, error) {	3✔
42		3✔
43	switch backend := b.chain.(type) {	3✔
44
45	case *chain.NeutrinoClient:	1✔
46	spendReport, err := backend.CS.GetUtxo(	1✔
47	neutrino.WatchInputs(neutrino.InputWithScript{	1✔
48	OutPoint: *op,	1✔
49	PkScript: pkScript,	1✔
50	}),	1✔
51	neutrino.StartBlock(&headerfs.BlockStamp{	1✔
52	Height: int32(heightHint),	1✔
53	}),	1✔
54	neutrino.QuitChan(cancel),	1✔
55	)	1✔
56	if err != nil {	1✔
57	return nil, err	×
58	}	×
59
60	// If the spend report is nil, then the output was not found in
61	// the rescan.
62	if spendReport == nil {	1✔
63	return nil, ErrOutputNotFound	×
64	}	×
65
66	// If the spending transaction is populated in the spend report,
67	// this signals that the output has already been spent.
68	if spendReport.SpendingTx != nil {	1✔
69	return nil, ErrOutputSpent	×
70	}	×
71
72	// Otherwise, the output is assumed to be in the UTXO.
73	return spendReport.Output, nil	1✔
74
UNCOV 75	case *chain.RPCClient:	×
UNCOV 76	txout, err := backend.GetTxOut(&op.Hash, op.Index, false)	×
UNCOV 77	if err != nil {	×
78	return nil, err	×
UNCOV 79	} else if txout == nil {	×
80	return nil, ErrOutputSpent	×
81	}	×
82
UNCOV 83	pkScript, err := hex.DecodeString(txout.ScriptPubKey.Hex)	×
UNCOV 84	if err != nil {	×
85	return nil, err	×
86	}	×
87
88	// We'll ensure we properly convert the amount given in BTC to
89	// satoshis.
UNCOV 90	amt, err := btcutil.NewAmount(txout.Value)	×
UNCOV 91	if err != nil {	×
92	return nil, err	×
93	}	×
94
UNCOV 95	return &wire.TxOut{	×
UNCOV 96	Value: int64(amt),	×
UNCOV 97	PkScript: pkScript,	×
UNCOV 98	}, nil	×
99
100	case *chain.BitcoindClient:	2✔
101	txout, err := backend.GetTxOut(&op.Hash, op.Index, false)	2✔
102	if err != nil {	2✔
103	return nil, err	×
104	} else if txout == nil {	2✔
105	return nil, ErrOutputSpent	×
106	}	×
107
108	pkScript, err := hex.DecodeString(txout.ScriptPubKey.Hex)	2✔
109	if err != nil {	2✔
110	return nil, err	×
111	}	×
112
113	// Sadly, gettxout returns the output value in BTC instead of
114	// satoshis.
115	amt, err := btcutil.NewAmount(txout.Value)	2✔
116	if err != nil {	2✔
117	return nil, err	×
118	}	×
119
120	return &wire.TxOut{	2✔
121	Value: int64(amt),	2✔
122	PkScript: pkScript,	2✔
123	}, nil	2✔
124
125	default:	×
126	return nil, fmt.Errorf("unknown backend")	×
127	}
128	}
129
130	// GetBlock returns a raw block from the server given its hash. For the Neutrino
131	// implementation of the lnwallet.BlockChainIO interface, the Neutrino GetBlock
132	// method is called directly. For other implementations, the block cache is used
133	// to wrap the call to GetBlock.
134	//
135	// This method is a part of the lnwallet.BlockChainIO interface.
136	func (b BtcWallet) GetBlock(blockHash chainhash.Hash) (*wire.MsgBlock, error) {	7✔
137	_, ok := b.chain.(*chain.NeutrinoClient)	7✔
138	if !ok {	12✔
139	return b.blockCache.GetBlock(blockHash, b.chain.GetBlock)	5✔
140	}	5✔
141
142	// For the neutrino implementation of lnwallet.BlockChainIO the neutrino
143	// GetBlock function can be called directly since it uses the same block
144	// cache. However, it does not lock the block cache mutex for the given
145	// block hash and so that is done here.
146	b.blockCache.HashMutex.Lock(lntypes.Hash(*blockHash))	2✔
147	defer b.blockCache.HashMutex.Unlock(lntypes.Hash(*blockHash))	2✔
148		2✔
149	return b.chain.GetBlock(blockHash)	2✔
150	}
151
152	// GetBlockHeader returns a block header for the block with the given hash.
153	//
154	// This method is a part of the lnwallet.BlockChainIO interface.
155	func (b *BtcWallet) GetBlockHeader(
156	blockHash chainhash.Hash) (wire.BlockHeader, error) {	3✔
157		3✔
158	return b.chain.GetBlockHeader(blockHash)	3✔
159	}	3✔
160
161	// GetBlockHash returns the hash of the block in the best blockchain at the
162	// given height.
163	//
164	// This method is a part of the lnwallet.BlockChainIO interface.
165	func (b BtcWallet) GetBlockHash(blockHeight int64) (chainhash.Hash, error) {	3✔
166	return b.chain.GetBlockHash(blockHeight)	3✔
167	}	3✔
168
169	// A compile time check to ensure that BtcWallet implements the BlockChainIO
170	// interface.
171	var _ lnwallet.WalletController = (*BtcWallet)(nil)

lightningnetwork / lnd / 12349698563

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