@ -17,7 +17,7 @@ import (
"github.com/lightninglabs/loop/labels"
"github.com/lightninglabs/loop/liquidity"
"github.com/lightninglabs/loop/loopdb"
"github.com/lightninglabs/loop/looprpc"
clientrpc "github.com/lightninglabs/loop/looprpc"
"github.com/lightninglabs/loop/swap"
"github.com/lightninglabs/loop/swapserverrpc"
"github.com/lightningnetwork/lnd/lntypes"
@ -60,8 +60,8 @@ var (
// swapClientServer implements the grpc service exposed by loopd.
type swapClientServer struct {
// Required by the grpc-gateway/v2 library for forward compatibility.
loop rpc. UnimplementedSwapClientServer
loop rpc. UnimplementedDebugServer
client rpc. UnimplementedSwapClientServer
client rpc. UnimplementedDebugServer
network lndclient . Network
impl * loop . Client
@ -80,8 +80,8 @@ type swapClientServer struct {
// onwards, progress can be tracked via the LoopOutStatus stream that is
// returned from Monitor().
func ( s * swapClientServer ) LoopOut ( ctx context . Context ,
in * loop rpc. LoopOutRequest ) (
* loop rpc. SwapResponse , error ) {
in * client rpc. LoopOutRequest ) (
* client rpc. SwapResponse , error ) {
log . Infof ( "Loop out request received" )
@ -146,7 +146,7 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
return nil , err
}
return & loop rpc. SwapResponse {
return & client rpc. SwapResponse {
Id : info . SwapHash . String ( ) ,
IdBytes : info . SwapHash [ : ] ,
HtlcAddress : info . HtlcAddressP2WSH . String ( ) ,
@ -156,11 +156,11 @@ func (s *swapClientServer) LoopOut(ctx context.Context,
}
func ( s * swapClientServer ) marshallSwap ( loopSwap * loop . SwapInfo ) (
* loop rpc. SwapStatus , error ) {
* client rpc. SwapStatus , error ) {
var (
state loop rpc. SwapState
failureReason = loop rpc. FailureReason_FAILURE_REASON_NONE
state client rpc. SwapState
failureReason = client rpc. FailureReason_FAILURE_REASON_NONE
)
// Set our state var for non-failure states. If we get a failure, we
@ -170,37 +170,37 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
// states, and set our failed state for all of them.
switch loopSwap . State {
case loopdb . StateInitiated :
state = loop rpc. SwapState_INITIATED
state = client rpc. SwapState_INITIATED
case loopdb . StatePreimageRevealed :
state = loop rpc. SwapState_PREIMAGE_REVEALED
state = client rpc. SwapState_PREIMAGE_REVEALED
case loopdb . StateHtlcPublished :
state = loop rpc. SwapState_HTLC_PUBLISHED
state = client rpc. SwapState_HTLC_PUBLISHED
case loopdb . StateInvoiceSettled :
state = loop rpc. SwapState_INVOICE_SETTLED
state = client rpc. SwapState_INVOICE_SETTLED
case loopdb . StateSuccess :
state = loop rpc. SwapState_SUCCESS
state = client rpc. SwapState_SUCCESS
case loopdb . StateFailOffchainPayments :
failureReason = loop rpc. FailureReason_FAILURE_REASON_OFFCHAIN
failureReason = client rpc. FailureReason_FAILURE_REASON_OFFCHAIN
case loopdb . StateFailTimeout :
failureReason = loop rpc. FailureReason_FAILURE_REASON_TIMEOUT
failureReason = client rpc. FailureReason_FAILURE_REASON_TIMEOUT
case loopdb . StateFailSweepTimeout :
failureReason = loop rpc. FailureReason_FAILURE_REASON_SWEEP_TIMEOUT
failureReason = client rpc. FailureReason_FAILURE_REASON_SWEEP_TIMEOUT
case loopdb . StateFailInsufficientValue :
failureReason = loop rpc. FailureReason_FAILURE_REASON_INSUFFICIENT_VALUE
failureReason = client rpc. FailureReason_FAILURE_REASON_INSUFFICIENT_VALUE
case loopdb . StateFailTemporary :
failureReason = loop rpc. FailureReason_FAILURE_REASON_TEMPORARY
failureReason = client rpc. FailureReason_FAILURE_REASON_TEMPORARY
case loopdb . StateFailIncorrectHtlcAmt :
failureReason = loop rpc. FailureReason_FAILURE_REASON_INCORRECT_AMOUNT
failureReason = client rpc. FailureReason_FAILURE_REASON_INCORRECT_AMOUNT
default :
return nil , fmt . Errorf ( "unknown swap state: %v" , loopSwap . State )
@ -208,16 +208,16 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
// If we have a failure reason, we have a failure state, so should use
// our catchall failed state.
if failureReason != loop rpc. FailureReason_FAILURE_REASON_NONE {
state = loop rpc. SwapState_FAILED
if failureReason != client rpc. FailureReason_FAILURE_REASON_NONE {
state = client rpc. SwapState_FAILED
}
var swapType loop rpc. SwapType
var swapType client rpc. SwapType
var htlcAddress , htlcAddressP2WSH , htlcAddressNP2WSH string
switch loopSwap . SwapType {
case swap . TypeIn :
swapType = loop rpc. SwapType_LOOP_IN
swapType = client rpc. SwapType_LOOP_IN
htlcAddressP2WSH = loopSwap . HtlcAddressP2WSH . EncodeAddress ( )
if loopSwap . ExternalHtlc {
@ -228,7 +228,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
}
case swap . TypeOut :
swapType = loop rpc. SwapType_LOOP_OUT
swapType = client rpc. SwapType_LOOP_OUT
htlcAddressP2WSH = loopSwap . HtlcAddressP2WSH . EncodeAddress ( )
htlcAddress = htlcAddressP2WSH
@ -236,7 +236,7 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
return nil , errors . New ( "unknown swap type" )
}
return & loop rpc. SwapStatus {
return & client rpc. SwapStatus {
Amt : int64 ( loopSwap . AmountRequested ) ,
Id : loopSwap . SwapHash . String ( ) ,
IdBytes : loopSwap . SwapHash [ : ] ,
@ -256,8 +256,8 @@ func (s *swapClientServer) marshallSwap(loopSwap *loop.SwapInfo) (
}
// Monitor will return a stream of swap updates for currently active swaps.
func ( s * swapClientServer ) Monitor ( in * loop rpc. MonitorRequest ,
server loop rpc. SwapClient_MonitorServer ) error {
func ( s * swapClientServer ) Monitor ( in * client rpc. MonitorRequest ,
server client rpc. SwapClient_MonitorServer ) error {
log . Infof ( "Monitor request received" )
@ -358,10 +358,10 @@ func (s *swapClientServer) Monitor(in *looprpc.MonitorRequest,
// ListSwaps returns a list of all currently known swaps and their current
// status.
func ( s * swapClientServer ) ListSwaps ( _ context . Context ,
_ * looprpc. ListSwapsRequest ) ( * loop rpc. ListSwapsResponse , error ) {
_ * clientrpc. ListSwapsRequest ) ( * client rpc. ListSwapsResponse , error ) {
var (
rpcSwaps = make ( [ ] * loop rpc. SwapStatus , len ( s . swaps ) )
rpcSwaps = make ( [ ] * client rpc. SwapStatus , len ( s . swaps ) )
idx = 0
err error
)
@ -381,12 +381,12 @@ func (s *swapClientServer) ListSwaps(_ context.Context,
}
idx ++
}
return & loop rpc. ListSwapsResponse { Swaps : rpcSwaps } , nil
return & client rpc. ListSwapsResponse { Swaps : rpcSwaps } , nil
}
// SwapInfo returns all known details about a single swap.
func ( s * swapClientServer ) SwapInfo ( _ context . Context ,
req * looprpc. SwapInfoRequest ) ( * loop rpc. SwapStatus , error ) {
req * clientrpc. SwapInfoRequest ) ( * client rpc. SwapStatus , error ) {
swapHash , err := lntypes . MakeHash ( req . Id )
if err != nil {
@ -404,7 +404,7 @@ func (s *swapClientServer) SwapInfo(_ context.Context,
// LoopOutTerms returns the terms that the server enforces for loop out swaps.
func ( s * swapClientServer ) LoopOutTerms ( ctx context . Context ,
req * looprpc. TermsRequest ) ( * loop rpc. OutTermsResponse , error ) {
req * clientrpc. TermsRequest ) ( * client rpc. OutTermsResponse , error ) {
log . Infof ( "Loop out terms request received" )
@ -414,7 +414,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
return nil , err
}
return & loop rpc. OutTermsResponse {
return & client rpc. OutTermsResponse {
MinSwapAmount : int64 ( terms . MinSwapAmount ) ,
MaxSwapAmount : int64 ( terms . MaxSwapAmount ) ,
MinCltvDelta : terms . MinCltvDelta ,
@ -425,7 +425,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
// LoopOutQuote returns a quote for a loop out swap with the provided
// parameters.
func ( s * swapClientServer ) LoopOutQuote ( ctx context . Context ,
req * looprpc. QuoteRequest ) ( * loop rpc. OutQuoteResponse , error ) {
req * clientrpc. QuoteRequest ) ( * client rpc. OutQuoteResponse , error ) {
confTarget , err := validateConfTarget (
req . ConfTarget , loop . DefaultSweepConfTarget ,
@ -444,7 +444,7 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
return nil , err
}
return & loop rpc. OutQuoteResponse {
return & client rpc. OutQuoteResponse {
HtlcSweepFeeSat : int64 ( quote . MinerFee ) ,
PrepayAmtSat : int64 ( quote . PrepayAmount ) ,
SwapFeeSat : int64 ( quote . SwapFee ) ,
@ -455,7 +455,7 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
// GetTerms returns the terms that the server enforces for swaps.
func ( s * swapClientServer ) GetLoopInTerms ( ctx context . Context ,
req * looprpc. TermsRequest ) ( * loop rpc. InTermsResponse , error ) {
req * clientrpc. TermsRequest ) ( * client rpc. InTermsResponse , error ) {
log . Infof ( "Loop in terms request received" )
@ -465,7 +465,7 @@ func (s *swapClientServer) GetLoopInTerms(ctx context.Context,
return nil , err
}
return & loop rpc. InTermsResponse {
return & client rpc. InTermsResponse {
MinSwapAmount : int64 ( terms . MinSwapAmount ) ,
MaxSwapAmount : int64 ( terms . MaxSwapAmount ) ,
} , nil
@ -473,7 +473,7 @@ func (s *swapClientServer) GetLoopInTerms(ctx context.Context,
// GetQuote returns a quote for a swap with the provided parameters.
func ( s * swapClientServer ) GetLoopInQuote ( ctx context . Context ,
req * looprpc. QuoteRequest ) ( * loop rpc. InQuoteResponse , error ) {
req * clientrpc. QuoteRequest ) ( * client rpc. InQuoteResponse , error ) {
log . Infof ( "Loop in quote request received" )
@ -518,7 +518,7 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
return nil , err
}
return & loop rpc. InQuoteResponse {
return & client rpc. InQuoteResponse {
HtlcPublishFeeSat : int64 ( quote . MinerFee ) ,
SwapFeeSat : int64 ( quote . SwapFee ) ,
ConfTarget : htlcConfTarget ,
@ -572,7 +572,7 @@ func unmarshallHopHint(rpcHint *swapserverrpc.HopHint) (zpay32.HopHint, error) {
// Probe requests the server to probe the client's node to test inbound
// liquidity.
func ( s * swapClientServer ) Probe ( ctx context . Context ,
req * looprpc. ProbeRequest ) ( * loop rpc. ProbeResponse , error ) {
req * clientrpc. ProbeRequest ) ( * client rpc. ProbeResponse , error ) {
log . Infof ( "Probe request received" )
@ -600,12 +600,12 @@ func (s *swapClientServer) Probe(ctx context.Context,
return nil , err
}
return & loop rpc. ProbeResponse { } , nil
return & client rpc. ProbeResponse { } , nil
}
func ( s * swapClientServer ) LoopIn ( ctx context . Context ,
in * loop rpc. LoopInRequest ) (
* loop rpc. SwapResponse , error ) {
in * client rpc. LoopInRequest ) (
* client rpc. SwapResponse , error ) {
log . Infof ( "Loop in request received" )
@ -650,7 +650,7 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
return nil , err
}
response := & loop rpc. SwapResponse {
response := & client rpc. SwapResponse {
Id : swapInfo . SwapHash . String ( ) ,
IdBytes : swapInfo . SwapHash [ : ] ,
HtlcAddressP2Wsh : swapInfo . HtlcAddressP2WSH . String ( ) ,
@ -669,7 +669,7 @@ func (s *swapClientServer) LoopIn(ctx context.Context,
// GetLsatTokens returns all tokens that are contained in the LSAT token store.
func ( s * swapClientServer ) GetLsatTokens ( ctx context . Context ,
_ * looprpc. TokensRequest ) ( * loop rpc. TokensResponse , error ) {
_ * clientrpc. TokensRequest ) ( * client rpc. TokensResponse , error ) {
log . Infof ( "Get LSAT tokens request received" )
@ -678,14 +678,14 @@ func (s *swapClientServer) GetLsatTokens(ctx context.Context,
return nil , err
}
rpcTokens := make ( [ ] * loop rpc. LsatToken , len ( tokens ) )
rpcTokens := make ( [ ] * client rpc. LsatToken , len ( tokens ) )
idx := 0
for key , token := range tokens {
macBytes , err := token . BaseMacaroon ( ) . MarshalBinary ( )
if err != nil {
return nil , err
}
rpcTokens [ idx ] = & loop rpc. LsatToken {
rpcTokens [ idx ] = & client rpc. LsatToken {
BaseMacaroon : macBytes ,
PaymentHash : token . PaymentHash [ : ] ,
PaymentPreimage : token . Preimage [ : ] ,
@ -698,26 +698,26 @@ func (s *swapClientServer) GetLsatTokens(ctx context.Context,
idx ++
}
return & loop rpc. TokensResponse { Tokens : rpcTokens } , nil
return & client rpc. TokensResponse { Tokens : rpcTokens } , nil
}
// GetLiquidityParams gets our current liquidity manager's parameters.
func ( s * swapClientServer ) GetLiquidityParams ( _ context . Context ,
_ * looprpc. GetLiquidityParamsRequest ) ( * loop rpc. LiquidityParameters ,
_ * clientrpc. GetLiquidityParamsRequest ) ( * client rpc. LiquidityParameters ,
error ) {
cfg := s . liquidityMgr . GetParameters ( )
totalRules := len ( cfg . ChannelRules ) + len ( cfg . PeerRules )
rpcCfg := & loop rpc. LiquidityParameters {
rpcCfg := & client rpc. LiquidityParameters {
SweepConfTarget : cfg . SweepConfTarget ,
FailureBackoffSec : uint64 ( cfg . FailureBackOff . Seconds ( ) ) ,
Autoloop : cfg . Autoloop ,
AutoloopBudgetSat : uint64 ( cfg . AutoFeeBudget ) ,
AutoMaxInFlight : uint64 ( cfg . MaxAutoInFlight ) ,
Rules : make (
[ ] * loop rpc. LiquidityRule , 0 , totalRules ,
[ ] * client rpc. LiquidityRule , 0 , totalRules ,
) ,
MinSwapAmount : uint64 ( cfg . ClientRestrictions . Minimum ) ,
MaxSwapAmount : uint64 ( cfg . ClientRestrictions . Maximum ) ,
@ -765,19 +765,19 @@ func (s *swapClientServer) GetLiquidityParams(_ context.Context,
}
func newRPCRule ( channelID uint64 , peer [ ] byte ,
rule * liquidity . SwapRule ) * loop rpc. LiquidityRule {
rule * liquidity . SwapRule ) * client rpc. LiquidityRule {
rpcRule := & loop rpc. LiquidityRule {
rpcRule := & client rpc. LiquidityRule {
ChannelId : channelID ,
Pubkey : peer ,
Type : loop rpc. LiquidityRuleType_THRESHOLD ,
Type : client rpc. LiquidityRuleType_THRESHOLD ,
IncomingThreshold : uint32 ( rule . MinimumIncoming ) ,
OutgoingThreshold : uint32 ( rule . MinimumOutgoing ) ,
SwapType : loop rpc. SwapType_LOOP_OUT ,
SwapType : client rpc. SwapType_LOOP_OUT ,
}
if rule . Type == swap . TypeIn {
rpcRule . SwapType = loop rpc. SwapType_LOOP_IN
rpcRule . SwapType = client rpc. SwapType_LOOP_IN
}
return rpcRule
@ -786,7 +786,7 @@ func newRPCRule(channelID uint64, peer []byte,
// SetLiquidityParams attempts to set our current liquidity manager's
// parameters.
func ( s * swapClientServer ) SetLiquidityParams ( ctx context . Context ,
in * looprpc. SetLiquidityParamsRequest ) ( * loop rpc. SetLiquidityParamsResponse ,
in * clientrpc. SetLiquidityParamsRequest ) ( * client rpc. SetLiquidityParamsResponse ,
error ) {
feeLimit , err := rpcToFee ( in . Parameters )
@ -869,12 +869,12 @@ func (s *swapClientServer) SetLiquidityParams(ctx context.Context,
return nil , err
}
return & loop rpc. SetLiquidityParamsResponse { } , nil
return & client rpc. SetLiquidityParamsResponse { } , nil
}
// rpcToFee converts the values provided over rpc to a fee limit interface,
// failing if an inconsistent set of fields are set.
func rpcToFee ( req * loop rpc. LiquidityParameters ) ( liquidity . FeeLimit ,
func rpcToFee ( req * client rpc. LiquidityParameters ) ( liquidity . FeeLimit ,
error ) {
// Check which fee limit type we have values set for. If any fields
@ -912,17 +912,17 @@ func rpcToFee(req *looprpc.LiquidityParameters) (liquidity.FeeLimit,
}
// rpcToRule switches on rpc rule type to convert to our rule interface.
func rpcToRule ( rule * loop rpc. LiquidityRule ) ( * liquidity . SwapRule , error ) {
func rpcToRule ( rule * client rpc. LiquidityRule ) ( * liquidity . SwapRule , error ) {
swapType := swap . TypeOut
if rule . SwapType == loop rpc. SwapType_LOOP_IN {
if rule . SwapType == client rpc. SwapType_LOOP_IN {
swapType = swap . TypeIn
}
switch rule . Type {
case loop rpc. LiquidityRuleType_UNKNOWN :
case client rpc. LiquidityRuleType_UNKNOWN :
return nil , fmt . Errorf ( "rule type field must be set" )
case loop rpc. LiquidityRuleType_THRESHOLD :
case client rpc. LiquidityRuleType_THRESHOLD :
return & liquidity . SwapRule {
ThresholdRule : liquidity . NewThresholdRule (
int ( rule . IncomingThreshold ) ,
@ -940,7 +940,7 @@ func rpcToRule(rule *looprpc.LiquidityRule) (*liquidity.SwapRule, error) {
// SuggestSwaps provides a list of suggested swaps based on lnd's current
// channel balances and rules set by the liquidity manager.
func ( s * swapClientServer ) SuggestSwaps ( ctx context . Context ,
_ * looprpc. SuggestSwapsRequest ) ( * loop rpc. SuggestSwapsResponse , error ) {
_ * clientrpc. SuggestSwapsRequest ) ( * client rpc. SuggestSwapsResponse , error ) {
suggestions , err := s . liquidityMgr . SuggestSwaps ( ctx , false )
switch err {
@ -954,12 +954,12 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context,
}
var (
loopOut [ ] * loop rpc. LoopOutRequest
disqualified [ ] * loop rpc. Disqualified
loopOut [ ] * client rpc. LoopOutRequest
disqualified [ ] * client rpc. Disqualified
)
for _ , swap := range suggestions . OutSwaps {
loopOut = append ( loopOut , & loop rpc. LoopOutRequest {
loopOut = append ( loopOut , & client rpc. LoopOutRequest {
Amt : int64 ( swap . Amount ) ,
OutgoingChanSet : swap . OutgoingChanSet ,
MaxSwapFee : int64 ( swap . MaxSwapFee ) ,
@ -977,7 +977,7 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context,
return nil , err
}
exclChan := & loop rpc. Disqualified {
exclChan := & client rpc. Disqualified {
Reason : autoloopReason ,
ChannelId : id . ToUint64 ( ) ,
}
@ -991,7 +991,7 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context,
return nil , err
}
exclChan := & loop rpc. Disqualified {
exclChan := & client rpc. Disqualified {
Reason : autoloopReason ,
Pubkey : pubkey [ : ] ,
}
@ -999,55 +999,55 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context,
disqualified = append ( disqualified , exclChan )
}
return & loop rpc. SuggestSwapsResponse {
return & client rpc. SuggestSwapsResponse {
LoopOut : loopOut ,
Disqualified : disqualified ,
} , nil
}
func rpcAutoloopReason ( reason liquidity . Reason ) ( loop rpc. AutoReason , error ) {
func rpcAutoloopReason ( reason liquidity . Reason ) ( client rpc. AutoReason , error ) {
switch reason {
case liquidity . ReasonNone :
return loop rpc. AutoReason_AUTO_REASON_UNKNOWN , nil
return client rpc. AutoReason_AUTO_REASON_UNKNOWN , nil
case liquidity . ReasonBudgetNotStarted :
return loop rpc. AutoReason_AUTO_REASON_BUDGET_NOT_STARTED , nil
return client rpc. AutoReason_AUTO_REASON_BUDGET_NOT_STARTED , nil
case liquidity . ReasonSweepFees :
return loop rpc. AutoReason_AUTO_REASON_SWEEP_FEES , nil
return client rpc. AutoReason_AUTO_REASON_SWEEP_FEES , nil
case liquidity . ReasonBudgetElapsed :
return loop rpc. AutoReason_AUTO_REASON_BUDGET_ELAPSED , nil
return client rpc. AutoReason_AUTO_REASON_BUDGET_ELAPSED , nil
case liquidity . ReasonInFlight :
return loop rpc. AutoReason_AUTO_REASON_IN_FLIGHT , nil
return client rpc. AutoReason_AUTO_REASON_IN_FLIGHT , nil
case liquidity . ReasonSwapFee :
return loop rpc. AutoReason_AUTO_REASON_SWAP_FEE , nil
return client rpc. AutoReason_AUTO_REASON_SWAP_FEE , nil
case liquidity . ReasonMinerFee :
return loop rpc. AutoReason_AUTO_REASON_MINER_FEE , nil
return client rpc. AutoReason_AUTO_REASON_MINER_FEE , nil
case liquidity . ReasonPrepay :
return loop rpc. AutoReason_AUTO_REASON_PREPAY , nil
return client rpc. AutoReason_AUTO_REASON_PREPAY , nil
case liquidity . ReasonFailureBackoff :
return loop rpc. AutoReason_AUTO_REASON_FAILURE_BACKOFF , nil
return client rpc. AutoReason_AUTO_REASON_FAILURE_BACKOFF , nil
case liquidity . ReasonLoopOut :
return loop rpc. AutoReason_AUTO_REASON_LOOP_OUT , nil
return client rpc. AutoReason_AUTO_REASON_LOOP_OUT , nil
case liquidity . ReasonLoopIn :
return loop rpc. AutoReason_AUTO_REASON_LOOP_IN , nil
return client rpc. AutoReason_AUTO_REASON_LOOP_IN , nil
case liquidity . ReasonLiquidityOk :
return loop rpc. AutoReason_AUTO_REASON_LIQUIDITY_OK , nil
return client rpc. AutoReason_AUTO_REASON_LIQUIDITY_OK , nil
case liquidity . ReasonBudgetInsufficient :
return loop rpc. AutoReason_AUTO_REASON_BUDGET_INSUFFICIENT , nil
return client rpc. AutoReason_AUTO_REASON_BUDGET_INSUFFICIENT , nil
case liquidity . ReasonFeePPMInsufficient :
return loop rpc. AutoReason_AUTO_REASON_SWAP_FEE , nil
return client rpc. AutoReason_AUTO_REASON_SWAP_FEE , nil
default :
return 0 , fmt . Errorf ( "unknown autoloop reason: %v" , reason )
@ -1126,7 +1126,7 @@ func validateLoopInRequest(htlcConfTarget int32, external bool) (int32, error) {
// address and label of the loop out request. It also checks that the requested
// loop amount is valid given the available balance.
func validateLoopOutRequest ( ctx context . Context , lnd lndclient . LightningClient ,
chainParams * chaincfg . Params , req * loop rpc. LoopOutRequest ,
chainParams * chaincfg . Params , req * client rpc. LoopOutRequest ,
sweepAddr btcutil . Address , maxParts uint32 ) ( int32 , error ) {
// Check that the provided destination address has the correct format