15249422085

Committed 26 May 2025 08:11AM UTC coverage: 57.977% (-11.0%) from 69.015%

Build # 15249422085

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9853 from lightningnetwork/elle-graphSQL8-prep

graph/db: init SQLStore caches and batch schedulers

Run Details

9 of 34 new or added lines in 4 files covered. (26.47%)

29283 existing lines in 458 files now uncovered.

96475 of 166402 relevant lines covered (57.98%)

1.22 hits per line

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

70.9

/lnrpc/marshall_utils.go

package lnrpc

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

        "github.com/btcsuite/btcd/btcutil"
        "github.com/btcsuite/btcd/chaincfg"
        "github.com/btcsuite/btcd/txscript"
        "github.com/btcsuite/btcd/wire"
        "github.com/btcsuite/btcwallet/wallet"
        "github.com/lightningnetwork/lnd/aliasmgr"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwire"
)

var (
        // ErrSatMsatMutualExclusive is returned when both a sat and an msat
        // amount are set.
        ErrSatMsatMutualExclusive = errors.New(
                "sat and msat arguments are mutually exclusive",
        )

        // ErrNegativeAmt is returned when a negative amount is specified.
        ErrNegativeAmt = errors.New("amount cannot be negative")
)

// CalculateFeeLimit returns the fee limit in millisatoshis. If a percentage
// based fee limit has been requested, we'll factor in the ratio provided with
// the amount of the payment.
func CalculateFeeLimit(feeLimit *FeeLimit,
        amount lnwire.MilliSatoshi) lnwire.MilliSatoshi {

        switch feeLimit.GetLimit().(type) {
        case *FeeLimit_Fixed:
                return lnwire.NewMSatFromSatoshis(
                        btcutil.Amount(feeLimit.GetFixed()),
                )

        case *FeeLimit_FixedMsat:
                return lnwire.MilliSatoshi(feeLimit.GetFixedMsat())

        case *FeeLimit_Percent:
                return amount * lnwire.MilliSatoshi(feeLimit.GetPercent()) / 100

        default:
                // Fall back to a sane default value that is based on the amount
                // itself.
                return lnwallet.DefaultRoutingFeeLimitForAmount(amount)
        }
}

// UnmarshallAmt returns a strong msat type for a sat/msat pair of rpc fields.
func UnmarshallAmt(amtSat, amtMsat int64) (lnwire.MilliSatoshi, error) {
        if amtSat != 0 && amtMsat != 0 {
                return 0, ErrSatMsatMutualExclusive
        }

        if amtSat < 0 || amtMsat < 0 {
                return 0, ErrNegativeAmt
        }

        if amtSat != 0 {
                return lnwire.NewMSatFromSatoshis(btcutil.Amount(amtSat)), nil
        }

        return lnwire.MilliSatoshi(amtMsat), nil
}

// ParseConfs validates the minimum and maximum confirmation arguments of a
// ListUnspent request.
func ParseConfs(min, max int32) (int32, int32, error) {
        switch {
        // Ensure that the user didn't attempt to specify a negative number of
        // confirmations, as that isn't possible.
        case min < 0:
                return 0, 0, fmt.Errorf("min confirmations must be >= 0")

        // We'll also ensure that the min number of confs is strictly less than
        // or equal to the max number of confs for sanity.
        case min > max:
                return 0, 0, fmt.Errorf("max confirmations must be >= min " +
                        "confirmations")

        default:
                return min, max, nil
        }
}

// MarshalUtxos translates a []*lnwallet.Utxo into a []*lnrpc.Utxo.
func MarshalUtxos(utxos []*lnwallet.Utxo, activeNetParams *chaincfg.Params) (
        []*Utxo, error) {

        res := make([]*Utxo, 0, len(utxos))
        for _, utxo := range utxos {
                // Translate lnwallet address type to the proper gRPC proto
                // address type.
                var addrType AddressType
                switch utxo.AddressType {
                case lnwallet.WitnessPubKey:
                        addrType = AddressType_WITNESS_PUBKEY_HASH

                case lnwallet.NestedWitnessPubKey:
                        addrType = AddressType_NESTED_PUBKEY_HASH

                case lnwallet.TaprootPubkey:
                        addrType = AddressType_TAPROOT_PUBKEY

                case lnwallet.UnknownAddressType:
                        continue

                default:
                        return nil, fmt.Errorf("invalid utxo address type")
                }

                // Now that we know we have a proper mapping to an address,
                // we'll convert the regular outpoint to an lnrpc variant.
                outpoint := MarshalOutPoint(&utxo.OutPoint)

                utxoResp := Utxo{
                        AddressType:   addrType,
                        AmountSat:     int64(utxo.Value),
                        PkScript:      hex.EncodeToString(utxo.PkScript),
                        Outpoint:      outpoint,
                        Confirmations: utxo.Confirmations,
                }

                // Finally, we'll attempt to extract the raw address from the
                // script so we can display a human friendly address to the end
                // user.
                _, outAddresses, _, err := txscript.ExtractPkScriptAddrs(
                        utxo.PkScript, activeNetParams,
                )
                if err != nil {
                        return nil, err
                }

                // If we can't properly locate a single address, then this was
                // an error in our mapping, and we'll return an error back to
                // the user.
                if len(outAddresses) != 1 {
                        return nil, fmt.Errorf("an output was unexpectedly " +
                                "multisig")
                }
                utxoResp.Address = outAddresses[0].String()

                res = append(res, &utxoResp)
        }

        return res, nil
}

// MarshallOutputType translates a txscript.ScriptClass into a
// lnrpc.OutputScriptType.
func MarshallOutputType(o txscript.ScriptClass) OutputScriptType {
        // Translate txscript ScriptClass type to the proper gRPC proto
        // output script type.
        switch o {
        case txscript.ScriptHashTy:
                return OutputScriptType_SCRIPT_TYPE_SCRIPT_HASH
        case txscript.WitnessV0PubKeyHashTy:
                return OutputScriptType_SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH
        case txscript.WitnessV0ScriptHashTy:
                return OutputScriptType_SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH
        case txscript.PubKeyTy:
                return OutputScriptType_SCRIPT_TYPE_PUBKEY
        case txscript.MultiSigTy:
                return OutputScriptType_SCRIPT_TYPE_MULTISIG
        case txscript.NullDataTy:
                return OutputScriptType_SCRIPT_TYPE_NULLDATA
        case txscript.NonStandardTy:
                return OutputScriptType_SCRIPT_TYPE_NON_STANDARD
        case txscript.WitnessUnknownTy:
                return OutputScriptType_SCRIPT_TYPE_WITNESS_UNKNOWN
        case txscript.WitnessV1TaprootTy:
                return OutputScriptType_SCRIPT_TYPE_WITNESS_V1_TAPROOT
        default:
                return OutputScriptType_SCRIPT_TYPE_PUBKEY_HASH
        }
}

// MarshalOutPoint converts a wire.OutPoint to its proto counterpart.
func MarshalOutPoint(op *wire.OutPoint) *OutPoint {
        return &OutPoint{
                TxidBytes:   op.Hash[:],
                TxidStr:     op.Hash.String(),
                OutputIndex: op.Index,
        }
}

// UnmarshallCoinSelectionStrategy converts a lnrpc.CoinSelectionStrategy proto
// type to its wallet.CoinSelectionStrategy counterpart type, considering
// a global default strategy if necessary.
//
// The globalStrategy parameter specifies the default coin selection strategy
// to use if the strategy is set to STRATEGY_USE_GLOBAL_CONFIG. This allows
// flexibility in defining a default strategy at a global level.
func UnmarshallCoinSelectionStrategy(strategy CoinSelectionStrategy,
        globalStrategy wallet.CoinSelectionStrategy) (
        wallet.CoinSelectionStrategy, error) {

        switch strategy {
        case CoinSelectionStrategy_STRATEGY_USE_GLOBAL_CONFIG:
                return globalStrategy, nil

        case CoinSelectionStrategy_STRATEGY_LARGEST:
                return wallet.CoinSelectionLargest, nil

        case CoinSelectionStrategy_STRATEGY_RANDOM:
                return wallet.CoinSelectionRandom, nil

        default:
                return nil, fmt.Errorf("unknown coin selection strategy "+
                        "%v", strategy)
        }
}

// MarshalAliasMap converts a ScidAliasMap to its proto counterpart. This is
// used in various RPCs that handle scid alias mappings.
func MarshalAliasMap(scidMap aliasmgr.ScidAliasMap) []*AliasMap {
        return fn.Map(
                slices.Collect(maps.Keys(scidMap)),
                func(base lnwire.ShortChannelID) *AliasMap {
                        return &AliasMap{
                                BaseScid: base.ToUint64(),
                                Aliases: fn.Map(
                                        scidMap[base],
                                        func(a lnwire.ShortChannelID) uint64 {
                                                return a.ToUint64()
                                        },
                                ),
                        }
                },
        )
}

1	package lnrpc
2
3	import (
4	"encoding/hex"
5	"errors"
6	"fmt"
7	"maps"
8	"slices"
9
10	"github.com/btcsuite/btcd/btcutil"
11	"github.com/btcsuite/btcd/chaincfg"
12	"github.com/btcsuite/btcd/txscript"
13	"github.com/btcsuite/btcd/wire"
14	"github.com/btcsuite/btcwallet/wallet"
15	"github.com/lightningnetwork/lnd/aliasmgr"
16	"github.com/lightningnetwork/lnd/fn/v2"
17	"github.com/lightningnetwork/lnd/lnwallet"
18	"github.com/lightningnetwork/lnd/lnwire"
19	)
20
21	var (
22	// ErrSatMsatMutualExclusive is returned when both a sat and an msat
23	// amount are set.
24	ErrSatMsatMutualExclusive = errors.New(
25	"sat and msat arguments are mutually exclusive",
26	)
27
28	// ErrNegativeAmt is returned when a negative amount is specified.
29	ErrNegativeAmt = errors.New("amount cannot be negative")
30	)
31
32	// CalculateFeeLimit returns the fee limit in millisatoshis. If a percentage
33	// based fee limit has been requested, we'll factor in the ratio provided with
34	// the amount of the payment.
35	func CalculateFeeLimit(feeLimit *FeeLimit,
36	amount lnwire.MilliSatoshi) lnwire.MilliSatoshi {	2✔
37		2✔
38	switch feeLimit.GetLimit().(type) {	2✔
39	case *FeeLimit_Fixed:	2✔
40	return lnwire.NewMSatFromSatoshis(	2✔
41	btcutil.Amount(feeLimit.GetFixed()),	2✔
42	)	2✔
43
UNCOV 44	case *FeeLimit_FixedMsat:	×
UNCOV 45	return lnwire.MilliSatoshi(feeLimit.GetFixedMsat())	×
46
47	case *FeeLimit_Percent:	2✔
48	return amount * lnwire.MilliSatoshi(feeLimit.GetPercent()) / 100	2✔
49
50	default:	2✔
51	// Fall back to a sane default value that is based on the amount	2✔
52	// itself.	2✔
53	return lnwallet.DefaultRoutingFeeLimitForAmount(amount)	2✔
54	}
55	}
56
57	// UnmarshallAmt returns a strong msat type for a sat/msat pair of rpc fields.
58	func UnmarshallAmt(amtSat, amtMsat int64) (lnwire.MilliSatoshi, error) {	2✔
59	if amtSat != 0 && amtMsat != 0 {	2✔
UNCOV 60	return 0, ErrSatMsatMutualExclusive	×
UNCOV 61	}	×
62
63	if amtSat < 0 \|\| amtMsat < 0 {	2✔
UNCOV 64	return 0, ErrNegativeAmt	×
UNCOV 65	}	×
66
67	if amtSat != 0 {	4✔
68	return lnwire.NewMSatFromSatoshis(btcutil.Amount(amtSat)), nil	2✔
69	}	2✔
70
71	return lnwire.MilliSatoshi(amtMsat), nil	2✔
72	}
73
74	// ParseConfs validates the minimum and maximum confirmation arguments of a
75	// ListUnspent request.
76	func ParseConfs(min, max int32) (int32, int32, error) {	2✔
77	switch {	2✔
78	// Ensure that the user didn't attempt to specify a negative number of
79	// confirmations, as that isn't possible.
80	case min < 0:	×
81	return 0, 0, fmt.Errorf("min confirmations must be >= 0")	×
82
83	// We'll also ensure that the min number of confs is strictly less than
84	// or equal to the max number of confs for sanity.
85	case min > max:	×
86	return 0, 0, fmt.Errorf("max confirmations must be >= min " +	×
87	"confirmations")	×
88
89	default:	2✔
90	return min, max, nil	2✔
91	}
92	}
93
94	// MarshalUtxos translates a []lnwallet.Utxo into a []lnrpc.Utxo.
95	func MarshalUtxos(utxos []lnwallet.Utxo, activeNetParams chaincfg.Params) (
96	[]*Utxo, error) {	2✔
97		2✔
98	res := make([]*Utxo, 0, len(utxos))	2✔
99	for _, utxo := range utxos {	4✔
100	// Translate lnwallet address type to the proper gRPC proto	2✔
101	// address type.	2✔
102	var addrType AddressType	2✔
103	switch utxo.AddressType {	2✔
104	case lnwallet.WitnessPubKey:	2✔
105	addrType = AddressType_WITNESS_PUBKEY_HASH	2✔
106
107	case lnwallet.NestedWitnessPubKey:	2✔
108	addrType = AddressType_NESTED_PUBKEY_HASH	2✔
109
110	case lnwallet.TaprootPubkey:	2✔
111	addrType = AddressType_TAPROOT_PUBKEY	2✔
112
113	case lnwallet.UnknownAddressType:	×
114	continue	×
115
116	default:	×
117	return nil, fmt.Errorf("invalid utxo address type")	×
118	}
119
120	// Now that we know we have a proper mapping to an address,
121	// we'll convert the regular outpoint to an lnrpc variant.
122	outpoint := MarshalOutPoint(&utxo.OutPoint)	2✔
123		2✔
124	utxoResp := Utxo{	2✔
125	AddressType: addrType,	2✔
126	AmountSat: int64(utxo.Value),	2✔
127	PkScript: hex.EncodeToString(utxo.PkScript),	2✔
128	Outpoint: outpoint,	2✔
129	Confirmations: utxo.Confirmations,	2✔
130	}	2✔
131		2✔
132	// Finally, we'll attempt to extract the raw address from the	2✔
133	// script so we can display a human friendly address to the end	2✔
134	// user.	2✔
135	_, outAddresses, _, err := txscript.ExtractPkScriptAddrs(	2✔
136	utxo.PkScript, activeNetParams,	2✔
137	)	2✔
138	if err != nil {	2✔
139	return nil, err	×
140	}	×
141
142	// If we can't properly locate a single address, then this was
143	// an error in our mapping, and we'll return an error back to
144	// the user.
145	if len(outAddresses) != 1 {	2✔
146	return nil, fmt.Errorf("an output was unexpectedly " +	×
147	"multisig")	×
148	}	×
149	utxoResp.Address = outAddresses[0].String()	2✔
150		2✔
151	res = append(res, &utxoResp)	2✔
152	}
153
154	return res, nil	2✔
155	}
156
157	// MarshallOutputType translates a txscript.ScriptClass into a
158	// lnrpc.OutputScriptType.
159	func MarshallOutputType(o txscript.ScriptClass) OutputScriptType {	2✔
160	// Translate txscript ScriptClass type to the proper gRPC proto	2✔
161	// output script type.	2✔
162	switch o {	2✔
163	case txscript.ScriptHashTy:	×
164	return OutputScriptType_SCRIPT_TYPE_SCRIPT_HASH	×
165	case txscript.WitnessV0PubKeyHashTy:	2✔
166	return OutputScriptType_SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH	2✔
167	case txscript.WitnessV0ScriptHashTy:	2✔
168	return OutputScriptType_SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH	2✔
169	case txscript.PubKeyTy:	×
170	return OutputScriptType_SCRIPT_TYPE_PUBKEY	×
171	case txscript.MultiSigTy:	×
172	return OutputScriptType_SCRIPT_TYPE_MULTISIG	×
173	case txscript.NullDataTy:	×
174	return OutputScriptType_SCRIPT_TYPE_NULLDATA	×
175	case txscript.NonStandardTy:	×
176	return OutputScriptType_SCRIPT_TYPE_NON_STANDARD	×
177	case txscript.WitnessUnknownTy:	×
178	return OutputScriptType_SCRIPT_TYPE_WITNESS_UNKNOWN	×
179	case txscript.WitnessV1TaprootTy:	2✔
180	return OutputScriptType_SCRIPT_TYPE_WITNESS_V1_TAPROOT	2✔
181	default:	2✔
182	return OutputScriptType_SCRIPT_TYPE_PUBKEY_HASH	2✔
183	}
184	}
185
186	// MarshalOutPoint converts a wire.OutPoint to its proto counterpart.
187	func MarshalOutPoint(op wire.OutPoint) OutPoint {	2✔
188	return &OutPoint{	2✔
189	TxidBytes: op.Hash[:],	2✔
190	TxidStr: op.Hash.String(),	2✔
191	OutputIndex: op.Index,	2✔
192	}	2✔
193	}	2✔
194
195	// UnmarshallCoinSelectionStrategy converts a lnrpc.CoinSelectionStrategy proto
196	// type to its wallet.CoinSelectionStrategy counterpart type, considering
197	// a global default strategy if necessary.
198	//
199	// The globalStrategy parameter specifies the default coin selection strategy
200	// to use if the strategy is set to STRATEGY_USE_GLOBAL_CONFIG. This allows
201	// flexibility in defining a default strategy at a global level.
202	func UnmarshallCoinSelectionStrategy(strategy CoinSelectionStrategy,
203	globalStrategy wallet.CoinSelectionStrategy) (
204	wallet.CoinSelectionStrategy, error) {	2✔
205		2✔
206	switch strategy {	2✔
207	case CoinSelectionStrategy_STRATEGY_USE_GLOBAL_CONFIG:	2✔
208	return globalStrategy, nil	2✔
209
210	case CoinSelectionStrategy_STRATEGY_LARGEST:	×
211	return wallet.CoinSelectionLargest, nil	×
212
213	case CoinSelectionStrategy_STRATEGY_RANDOM:	×
214	return wallet.CoinSelectionRandom, nil	×
215
216	default:	×
217	return nil, fmt.Errorf("unknown coin selection strategy "+	×
218	"%v", strategy)	×
219	}
220	}
221
222	// MarshalAliasMap converts a ScidAliasMap to its proto counterpart. This is
223	// used in various RPCs that handle scid alias mappings.
224	func MarshalAliasMap(scidMap aliasmgr.ScidAliasMap) []*AliasMap {	2✔
225	return fn.Map(	2✔
226	slices.Collect(maps.Keys(scidMap)),	2✔
227	func(base lnwire.ShortChannelID) *AliasMap {	4✔
228	return &AliasMap{	2✔
229	BaseScid: base.ToUint64(),	2✔
230	Aliases: fn.Map(	2✔
231	scidMap[base],	2✔
232	func(a lnwire.ShortChannelID) uint64 {	4✔
233	return a.ToUint64()	2✔
234	},	2✔
235	),
236	}
237	},
238	)
239	}

lightningnetwork / lnd / 15249422085

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