diff --git a/loopd/swapclient_server.go b/loopd/swapclient_server.go index bb9fa88..23a4bb6 100644 --- a/loopd/swapclient_server.go +++ b/loopd/swapclient_server.go @@ -17,9 +17,9 @@ 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" + looprpc "github.com/lightninglabs/loop/swapserverrpc" "github.com/lightningnetwork/lnd/lntypes" "github.com/lightningnetwork/lnd/lnwallet/chainfee" "github.com/lightningnetwork/lnd/lnwire" @@ -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. - looprpc.UnimplementedSwapClientServer - looprpc.UnimplementedDebugServer + clientrpc.UnimplementedSwapClientServer + clientrpc.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 *looprpc.LoopOutRequest) ( - *looprpc.SwapResponse, error) { + in *clientrpc.LoopOutRequest) ( + *clientrpc.SwapResponse, error) { log.Infof("Loop out request received") @@ -146,7 +146,7 @@ func (s *swapClientServer) LoopOut(ctx context.Context, return nil, err } - return &looprpc.SwapResponse{ + return &clientrpc.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) ( - *looprpc.SwapStatus, error) { + *clientrpc.SwapStatus, error) { var ( - state looprpc.SwapState - failureReason = looprpc.FailureReason_FAILURE_REASON_NONE + state clientrpc.SwapState + failureReason = clientrpc.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 = looprpc.SwapState_INITIATED + state = clientrpc.SwapState_INITIATED case loopdb.StatePreimageRevealed: - state = looprpc.SwapState_PREIMAGE_REVEALED + state = clientrpc.SwapState_PREIMAGE_REVEALED case loopdb.StateHtlcPublished: - state = looprpc.SwapState_HTLC_PUBLISHED + state = clientrpc.SwapState_HTLC_PUBLISHED case loopdb.StateInvoiceSettled: - state = looprpc.SwapState_INVOICE_SETTLED + state = clientrpc.SwapState_INVOICE_SETTLED case loopdb.StateSuccess: - state = looprpc.SwapState_SUCCESS + state = clientrpc.SwapState_SUCCESS case loopdb.StateFailOffchainPayments: - failureReason = looprpc.FailureReason_FAILURE_REASON_OFFCHAIN + failureReason = clientrpc.FailureReason_FAILURE_REASON_OFFCHAIN case loopdb.StateFailTimeout: - failureReason = looprpc.FailureReason_FAILURE_REASON_TIMEOUT + failureReason = clientrpc.FailureReason_FAILURE_REASON_TIMEOUT case loopdb.StateFailSweepTimeout: - failureReason = looprpc.FailureReason_FAILURE_REASON_SWEEP_TIMEOUT + failureReason = clientrpc.FailureReason_FAILURE_REASON_SWEEP_TIMEOUT case loopdb.StateFailInsufficientValue: - failureReason = looprpc.FailureReason_FAILURE_REASON_INSUFFICIENT_VALUE + failureReason = clientrpc.FailureReason_FAILURE_REASON_INSUFFICIENT_VALUE case loopdb.StateFailTemporary: - failureReason = looprpc.FailureReason_FAILURE_REASON_TEMPORARY + failureReason = clientrpc.FailureReason_FAILURE_REASON_TEMPORARY case loopdb.StateFailIncorrectHtlcAmt: - failureReason = looprpc.FailureReason_FAILURE_REASON_INCORRECT_AMOUNT + failureReason = clientrpc.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 != looprpc.FailureReason_FAILURE_REASON_NONE { - state = looprpc.SwapState_FAILED + if failureReason != clientrpc.FailureReason_FAILURE_REASON_NONE { + state = clientrpc.SwapState_FAILED } - var swapType looprpc.SwapType + var swapType clientrpc.SwapType var htlcAddress, htlcAddressP2WSH, htlcAddressNP2WSH string switch loopSwap.SwapType { case swap.TypeIn: - swapType = looprpc.SwapType_LOOP_IN + swapType = clientrpc.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 = looprpc.SwapType_LOOP_OUT + swapType = clientrpc.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 &looprpc.SwapStatus{ + return &clientrpc.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 *looprpc.MonitorRequest, - server looprpc.SwapClient_MonitorServer) error { +func (s *swapClientServer) Monitor(in *clientrpc.MonitorRequest, + server clientrpc.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) (*looprpc.ListSwapsResponse, error) { + _ *clientrpc.ListSwapsRequest) (*clientrpc.ListSwapsResponse, error) { var ( - rpcSwaps = make([]*looprpc.SwapStatus, len(s.swaps)) + rpcSwaps = make([]*clientrpc.SwapStatus, len(s.swaps)) idx = 0 err error ) @@ -381,12 +381,12 @@ func (s *swapClientServer) ListSwaps(_ context.Context, } idx++ } - return &looprpc.ListSwapsResponse{Swaps: rpcSwaps}, nil + return &clientrpc.ListSwapsResponse{Swaps: rpcSwaps}, nil } // SwapInfo returns all known details about a single swap. func (s *swapClientServer) SwapInfo(_ context.Context, - req *looprpc.SwapInfoRequest) (*looprpc.SwapStatus, error) { + req *clientrpc.SwapInfoRequest) (*clientrpc.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) (*looprpc.OutTermsResponse, error) { + req *clientrpc.TermsRequest) (*clientrpc.OutTermsResponse, error) { log.Infof("Loop out terms request received") @@ -414,7 +414,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context, return nil, err } - return &looprpc.OutTermsResponse{ + return &clientrpc.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) (*looprpc.OutQuoteResponse, error) { + req *clientrpc.QuoteRequest) (*clientrpc.OutQuoteResponse, error) { confTarget, err := validateConfTarget( req.ConfTarget, loop.DefaultSweepConfTarget, @@ -444,7 +444,7 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context, return nil, err } - return &looprpc.OutQuoteResponse{ + return &clientrpc.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) (*looprpc.InTermsResponse, error) { + req *clientrpc.TermsRequest) (*clientrpc.InTermsResponse, error) { log.Infof("Loop in terms request received") @@ -465,7 +465,7 @@ func (s *swapClientServer) GetLoopInTerms(ctx context.Context, return nil, err } - return &looprpc.InTermsResponse{ + return &clientrpc.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) (*looprpc.InQuoteResponse, error) { + req *clientrpc.QuoteRequest) (*clientrpc.InQuoteResponse, error) { log.Infof("Loop in quote request received") @@ -518,7 +518,7 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context, return nil, err } - return &looprpc.InQuoteResponse{ + return &clientrpc.InQuoteResponse{ HtlcPublishFeeSat: int64(quote.MinerFee), SwapFeeSat: int64(quote.SwapFee), ConfTarget: htlcConfTarget, @@ -526,7 +526,7 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context, } // unmarshallRouteHints unmarshalls a list of route hints. -func unmarshallRouteHints(rpcRouteHints []*swapserverrpc.RouteHint) ( +func unmarshallRouteHints(rpcRouteHints []*looprpc.RouteHint) ( [][]zpay32.HopHint, error) { routeHints := make([][]zpay32.HopHint, 0, len(rpcRouteHints)) @@ -549,7 +549,7 @@ func unmarshallRouteHints(rpcRouteHints []*swapserverrpc.RouteHint) ( } // unmarshallHopHint unmarshalls a single hop hint. -func unmarshallHopHint(rpcHint *swapserverrpc.HopHint) (zpay32.HopHint, error) { +func unmarshallHopHint(rpcHint *looprpc.HopHint) (zpay32.HopHint, error) { pubBytes, err := hex.DecodeString(rpcHint.NodeId) if err != nil { return zpay32.HopHint{}, err @@ -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) (*looprpc.ProbeResponse, error) { + req *clientrpc.ProbeRequest) (*clientrpc.ProbeResponse, error) { log.Infof("Probe request received") @@ -600,12 +600,12 @@ func (s *swapClientServer) Probe(ctx context.Context, return nil, err } - return &looprpc.ProbeResponse{}, nil + return &clientrpc.ProbeResponse{}, nil } func (s *swapClientServer) LoopIn(ctx context.Context, - in *looprpc.LoopInRequest) ( - *looprpc.SwapResponse, error) { + in *clientrpc.LoopInRequest) ( + *clientrpc.SwapResponse, error) { log.Infof("Loop in request received") @@ -650,7 +650,7 @@ func (s *swapClientServer) LoopIn(ctx context.Context, return nil, err } - response := &looprpc.SwapResponse{ + response := &clientrpc.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) (*looprpc.TokensResponse, error) { + _ *clientrpc.TokensRequest) (*clientrpc.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([]*looprpc.LsatToken, len(tokens)) + rpcTokens := make([]*clientrpc.LsatToken, len(tokens)) idx := 0 for key, token := range tokens { macBytes, err := token.BaseMacaroon().MarshalBinary() if err != nil { return nil, err } - rpcTokens[idx] = &looprpc.LsatToken{ + rpcTokens[idx] = &clientrpc.LsatToken{ BaseMacaroon: macBytes, PaymentHash: token.PaymentHash[:], PaymentPreimage: token.Preimage[:], @@ -698,26 +698,26 @@ func (s *swapClientServer) GetLsatTokens(ctx context.Context, idx++ } - return &looprpc.TokensResponse{Tokens: rpcTokens}, nil + return &clientrpc.TokensResponse{Tokens: rpcTokens}, nil } // GetLiquidityParams gets our current liquidity manager's parameters. func (s *swapClientServer) GetLiquidityParams(_ context.Context, - _ *looprpc.GetLiquidityParamsRequest) (*looprpc.LiquidityParameters, + _ *clientrpc.GetLiquidityParamsRequest) (*clientrpc.LiquidityParameters, error) { cfg := s.liquidityMgr.GetParameters() totalRules := len(cfg.ChannelRules) + len(cfg.PeerRules) - rpcCfg := &looprpc.LiquidityParameters{ + rpcCfg := &clientrpc.LiquidityParameters{ SweepConfTarget: cfg.SweepConfTarget, FailureBackoffSec: uint64(cfg.FailureBackOff.Seconds()), Autoloop: cfg.Autoloop, AutoloopBudgetSat: uint64(cfg.AutoFeeBudget), AutoMaxInFlight: uint64(cfg.MaxAutoInFlight), Rules: make( - []*looprpc.LiquidityRule, 0, totalRules, + []*clientrpc.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) *looprpc.LiquidityRule { + rule *liquidity.SwapRule) *clientrpc.LiquidityRule { - rpcRule := &looprpc.LiquidityRule{ + rpcRule := &clientrpc.LiquidityRule{ ChannelId: channelID, Pubkey: peer, - Type: looprpc.LiquidityRuleType_THRESHOLD, + Type: clientrpc.LiquidityRuleType_THRESHOLD, IncomingThreshold: uint32(rule.MinimumIncoming), OutgoingThreshold: uint32(rule.MinimumOutgoing), - SwapType: looprpc.SwapType_LOOP_OUT, + SwapType: clientrpc.SwapType_LOOP_OUT, } if rule.Type == swap.TypeIn { - rpcRule.SwapType = looprpc.SwapType_LOOP_IN + rpcRule.SwapType = clientrpc.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) (*looprpc.SetLiquidityParamsResponse, + in *clientrpc.SetLiquidityParamsRequest) (*clientrpc.SetLiquidityParamsResponse, error) { feeLimit, err := rpcToFee(in.Parameters) @@ -869,12 +869,12 @@ func (s *swapClientServer) SetLiquidityParams(ctx context.Context, return nil, err } - return &looprpc.SetLiquidityParamsResponse{}, nil + return &clientrpc.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 *looprpc.LiquidityParameters) (liquidity.FeeLimit, +func rpcToFee(req *clientrpc.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 *looprpc.LiquidityRule) (*liquidity.SwapRule, error) { +func rpcToRule(rule *clientrpc.LiquidityRule) (*liquidity.SwapRule, error) { swapType := swap.TypeOut - if rule.SwapType == looprpc.SwapType_LOOP_IN { + if rule.SwapType == clientrpc.SwapType_LOOP_IN { swapType = swap.TypeIn } switch rule.Type { - case looprpc.LiquidityRuleType_UNKNOWN: + case clientrpc.LiquidityRuleType_UNKNOWN: return nil, fmt.Errorf("rule type field must be set") - case looprpc.LiquidityRuleType_THRESHOLD: + case clientrpc.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) (*looprpc.SuggestSwapsResponse, error) { + _ *clientrpc.SuggestSwapsRequest) (*clientrpc.SuggestSwapsResponse, error) { suggestions, err := s.liquidityMgr.SuggestSwaps(ctx, false) switch err { @@ -954,12 +954,12 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context, } var ( - loopOut []*looprpc.LoopOutRequest - disqualified []*looprpc.Disqualified + loopOut []*clientrpc.LoopOutRequest + disqualified []*clientrpc.Disqualified ) for _, swap := range suggestions.OutSwaps { - loopOut = append(loopOut, &looprpc.LoopOutRequest{ + loopOut = append(loopOut, &clientrpc.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 := &looprpc.Disqualified{ + exclChan := &clientrpc.Disqualified{ Reason: autoloopReason, ChannelId: id.ToUint64(), } @@ -991,7 +991,7 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context, return nil, err } - exclChan := &looprpc.Disqualified{ + exclChan := &clientrpc.Disqualified{ Reason: autoloopReason, Pubkey: pubkey[:], } @@ -999,55 +999,55 @@ func (s *swapClientServer) SuggestSwaps(ctx context.Context, disqualified = append(disqualified, exclChan) } - return &looprpc.SuggestSwapsResponse{ + return &clientrpc.SuggestSwapsResponse{ LoopOut: loopOut, Disqualified: disqualified, }, nil } -func rpcAutoloopReason(reason liquidity.Reason) (looprpc.AutoReason, error) { +func rpcAutoloopReason(reason liquidity.Reason) (clientrpc.AutoReason, error) { switch reason { case liquidity.ReasonNone: - return looprpc.AutoReason_AUTO_REASON_UNKNOWN, nil + return clientrpc.AutoReason_AUTO_REASON_UNKNOWN, nil case liquidity.ReasonBudgetNotStarted: - return looprpc.AutoReason_AUTO_REASON_BUDGET_NOT_STARTED, nil + return clientrpc.AutoReason_AUTO_REASON_BUDGET_NOT_STARTED, nil case liquidity.ReasonSweepFees: - return looprpc.AutoReason_AUTO_REASON_SWEEP_FEES, nil + return clientrpc.AutoReason_AUTO_REASON_SWEEP_FEES, nil case liquidity.ReasonBudgetElapsed: - return looprpc.AutoReason_AUTO_REASON_BUDGET_ELAPSED, nil + return clientrpc.AutoReason_AUTO_REASON_BUDGET_ELAPSED, nil case liquidity.ReasonInFlight: - return looprpc.AutoReason_AUTO_REASON_IN_FLIGHT, nil + return clientrpc.AutoReason_AUTO_REASON_IN_FLIGHT, nil case liquidity.ReasonSwapFee: - return looprpc.AutoReason_AUTO_REASON_SWAP_FEE, nil + return clientrpc.AutoReason_AUTO_REASON_SWAP_FEE, nil case liquidity.ReasonMinerFee: - return looprpc.AutoReason_AUTO_REASON_MINER_FEE, nil + return clientrpc.AutoReason_AUTO_REASON_MINER_FEE, nil case liquidity.ReasonPrepay: - return looprpc.AutoReason_AUTO_REASON_PREPAY, nil + return clientrpc.AutoReason_AUTO_REASON_PREPAY, nil case liquidity.ReasonFailureBackoff: - return looprpc.AutoReason_AUTO_REASON_FAILURE_BACKOFF, nil + return clientrpc.AutoReason_AUTO_REASON_FAILURE_BACKOFF, nil case liquidity.ReasonLoopOut: - return looprpc.AutoReason_AUTO_REASON_LOOP_OUT, nil + return clientrpc.AutoReason_AUTO_REASON_LOOP_OUT, nil case liquidity.ReasonLoopIn: - return looprpc.AutoReason_AUTO_REASON_LOOP_IN, nil + return clientrpc.AutoReason_AUTO_REASON_LOOP_IN, nil case liquidity.ReasonLiquidityOk: - return looprpc.AutoReason_AUTO_REASON_LIQUIDITY_OK, nil + return clientrpc.AutoReason_AUTO_REASON_LIQUIDITY_OK, nil case liquidity.ReasonBudgetInsufficient: - return looprpc.AutoReason_AUTO_REASON_BUDGET_INSUFFICIENT, nil + return clientrpc.AutoReason_AUTO_REASON_BUDGET_INSUFFICIENT, nil case liquidity.ReasonFeePPMInsufficient: - return looprpc.AutoReason_AUTO_REASON_SWAP_FEE, nil + return clientrpc.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 *looprpc.LoopOutRequest, + chainParams *chaincfg.Params, req *clientrpc.LoopOutRequest, sweepAddr btcutil.Address, maxParts uint32) (int32, error) { // Check that the provided destination address has the correct format diff --git a/loopdb/protocol_version.go b/loopdb/protocol_version.go index 416369e..c8664dc 100644 --- a/loopdb/protocol_version.go +++ b/loopdb/protocol_version.go @@ -3,7 +3,7 @@ package loopdb import ( "math" - "github.com/lightninglabs/loop/swapserverrpc" + looprpc "github.com/lightninglabs/loop/swapserverrpc" ) // ProtocolVersion represents the protocol version (declared on rpc level) that @@ -53,7 +53,7 @@ const ( // CurrentRPCProtocolVersion defines the version of the RPC protocol // that is currently supported by the loop client. - CurrentRPCProtocolVersion = swapserverrpc.ProtocolVersion_PROBE + CurrentRPCProtocolVersion = looprpc.ProtocolVersion_PROBE // CurrentInternalProtocolVersion defines the RPC current protocol in // the internal representation. diff --git a/loopdb/protocol_version_test.go b/loopdb/protocol_version_test.go index d73e0c2..9f30877 100644 --- a/loopdb/protocol_version_test.go +++ b/loopdb/protocol_version_test.go @@ -3,7 +3,7 @@ package loopdb import ( "testing" - "github.com/lightninglabs/loop/swapserverrpc" + looprpc "github.com/lightninglabs/loop/swapserverrpc" "github.com/stretchr/testify/require" ) @@ -25,16 +25,16 @@ func TestProtocolVersionSanity(t *testing.T) { ProtocolVersionProbe, } - rpcVersions := [...]swapserverrpc.ProtocolVersion{ - swapserverrpc.ProtocolVersion_LEGACY, - swapserverrpc.ProtocolVersion_MULTI_LOOP_OUT, - swapserverrpc.ProtocolVersion_NATIVE_SEGWIT_LOOP_IN, - swapserverrpc.ProtocolVersion_PREIMAGE_PUSH_LOOP_OUT, - swapserverrpc.ProtocolVersion_USER_EXPIRY_LOOP_OUT, - swapserverrpc.ProtocolVersion_HTLC_V2, - swapserverrpc.ProtocolVersion_MULTI_LOOP_IN, - swapserverrpc.ProtocolVersion_LOOP_OUT_CANCEL, - swapserverrpc.ProtocolVersion_PROBE, + rpcVersions := [...]looprpc.ProtocolVersion{ + looprpc.ProtocolVersion_LEGACY, + looprpc.ProtocolVersion_MULTI_LOOP_OUT, + looprpc.ProtocolVersion_NATIVE_SEGWIT_LOOP_IN, + looprpc.ProtocolVersion_PREIMAGE_PUSH_LOOP_OUT, + looprpc.ProtocolVersion_USER_EXPIRY_LOOP_OUT, + looprpc.ProtocolVersion_HTLC_V2, + looprpc.ProtocolVersion_MULTI_LOOP_IN, + looprpc.ProtocolVersion_LOOP_OUT_CANCEL, + looprpc.ProtocolVersion_PROBE, } require.Equal(t, len(versions), len(rpcVersions)) diff --git a/swap_server_client.go b/swap_server_client.go index 566c9d9..93e45ae 100644 --- a/swap_server_client.go +++ b/swap_server_client.go @@ -16,7 +16,7 @@ import ( "github.com/btcsuite/btcutil" "github.com/lightninglabs/aperture/lsat" "github.com/lightninglabs/loop/loopdb" - "github.com/lightninglabs/loop/swapserverrpc" + looprpc "github.com/lightninglabs/loop/swapserverrpc" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lntypes" "github.com/lightningnetwork/lnd/routing/route" @@ -89,7 +89,7 @@ type swapServerClient interface { } type grpcSwapServerClient struct { - server swapserverrpc.SwapServerClient + server looprpc.SwapServerClient conn *grpc.ClientConn wg sync.WaitGroup @@ -124,7 +124,7 @@ func newSwapServerClient(cfg *ClientConfig, lsatStore lsat.Store) ( return nil, err } - server := swapserverrpc.NewSwapServerClient(serverConn) + server := looprpc.NewSwapServerClient(serverConn) return &grpcSwapServerClient{ conn: serverConn, @@ -138,7 +138,7 @@ func (s *grpcSwapServerClient) GetLoopOutTerms(ctx context.Context) ( rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() terms, err := s.server.LoopOutTerms(rpcCtx, - &swapserverrpc.ServerLoopOutTermsRequest{ + &looprpc.ServerLoopOutTermsRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, }, ) @@ -161,7 +161,7 @@ func (s *grpcSwapServerClient) GetLoopOutQuote(ctx context.Context, rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() quoteResp, err := s.server.LoopOutQuote(rpcCtx, - &swapserverrpc.ServerLoopOutQuoteRequest{ + &looprpc.ServerLoopOutQuoteRequest{ Amt: uint64(amt), SwapPublicationDeadline: swapPublicationDeadline.Unix(), ProtocolVersion: loopdb.CurrentRPCProtocolVersion, @@ -195,7 +195,7 @@ func (s *grpcSwapServerClient) GetLoopInTerms(ctx context.Context) ( rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() terms, err := s.server.LoopInTerms(rpcCtx, - &swapserverrpc.ServerLoopInTermsRequest{ + &looprpc.ServerLoopInTermsRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, }, ) @@ -221,7 +221,7 @@ func (s *grpcSwapServerClient) GetLoopInQuote(ctx context.Context, rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() - req := &swapserverrpc.ServerLoopInQuoteRequest{ + req := &looprpc.ServerLoopInQuoteRequest{ Amt: uint64(amt), ProtocolVersion: loopdb.CurrentRPCProtocolVersion, Pubkey: pubKey[:], @@ -252,12 +252,12 @@ func (s *grpcSwapServerClient) GetLoopInQuote(ctx context.Context, // marshallRouteHints marshalls a list of route hints. func marshallRouteHints(routeHints [][]zpay32.HopHint) ( - []*swapserverrpc.RouteHint, error) { + []*looprpc.RouteHint, error) { - rpcRouteHints := make([]*swapserverrpc.RouteHint, 0, len(routeHints)) + rpcRouteHints := make([]*looprpc.RouteHint, 0, len(routeHints)) for _, routeHint := range routeHints { rpcRouteHint := make( - []*swapserverrpc.HopHint, 0, len(routeHint), + []*looprpc.HopHint, 0, len(routeHint), ) for _, hint := range routeHint { rpcHint, err := marshallHopHint(hint) @@ -267,7 +267,7 @@ func marshallRouteHints(routeHints [][]zpay32.HopHint) ( rpcRouteHint = append(rpcRouteHint, rpcHint) } - rpcRouteHints = append(rpcRouteHints, &swapserverrpc.RouteHint{ + rpcRouteHints = append(rpcRouteHints, &looprpc.RouteHint{ HopHints: rpcRouteHint, }) } @@ -276,7 +276,7 @@ func marshallRouteHints(routeHints [][]zpay32.HopHint) ( } // marshallHopHint marshalls a single hop hint. -func marshallHopHint(hint zpay32.HopHint) (*swapserverrpc.HopHint, error) { +func marshallHopHint(hint zpay32.HopHint) (*looprpc.HopHint, error) { nodeID, err := route.NewVertexFromBytes( hint.NodeID.SerializeCompressed(), ) @@ -284,7 +284,7 @@ func marshallHopHint(hint zpay32.HopHint) (*swapserverrpc.HopHint, error) { return nil, err } - return &swapserverrpc.HopHint{ + return &looprpc.HopHint{ ChanId: hint.ChannelID, CltvExpiryDelta: uint32(hint.CLTVExpiryDelta), FeeBaseMsat: hint.FeeBaseMSat, @@ -305,7 +305,7 @@ func (s *grpcSwapServerClient) Probe(ctx context.Context, amt btcutil.Amount, return err } - req := &swapserverrpc.ServerProbeRequest{ + req := &looprpc.ServerProbeRequest{ Amt: uint64(amt), Target: target[:], ProtocolVersion: loopdb.CurrentRPCProtocolVersion, @@ -328,7 +328,7 @@ func (s *grpcSwapServerClient) NewLoopOutSwap(ctx context.Context, rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() swapResp, err := s.server.NewLoopOutSwap(rpcCtx, - &swapserverrpc.ServerLoopOutRequest{ + &looprpc.ServerLoopOutRequest{ SwapHash: swapHash[:], Amt: uint64(amount), ReceiverKey: receiverKey[:], @@ -367,7 +367,7 @@ func (s *grpcSwapServerClient) PushLoopOutPreimage(ctx context.Context, defer rpcCancel() _, err := s.server.LoopOutPushPreimage(rpcCtx, - &swapserverrpc.ServerLoopOutPushPreimageRequest{ + &looprpc.ServerLoopOutPushPreimageRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, Preimage: preimage[:], }, @@ -384,7 +384,7 @@ func (s *grpcSwapServerClient) NewLoopInSwap(ctx context.Context, rpcCtx, rpcCancel := context.WithTimeout(ctx, globalCallTimeout) defer rpcCancel() - req := &swapserverrpc.ServerLoopInRequest{ + req := &looprpc.ServerLoopInRequest{ SwapHash: swapHash[:], Amt: uint64(amount), SenderKey: senderKey[:], @@ -421,7 +421,7 @@ func (s *grpcSwapServerClient) NewLoopInSwap(ctx context.Context, // ServerUpdate summarizes an update from the swap server. type ServerUpdate struct { // State is the state that the server has sent us. - State swapserverrpc.ServerSwapState + State looprpc.ServerSwapState // Timestamp is the time of the server state update. Timestamp time.Time @@ -433,7 +433,7 @@ func (s *grpcSwapServerClient) SubscribeLoopInUpdates(ctx context.Context, hash lntypes.Hash) (<-chan *ServerUpdate, <-chan error, error) { resp, err := s.server.SubscribeLoopInUpdates( - ctx, &swapserverrpc.SubscribeUpdatesRequest{ + ctx, &looprpc.SubscribeUpdatesRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, SwapHash: hash[:], }, @@ -464,7 +464,7 @@ func (s *grpcSwapServerClient) SubscribeLoopOutUpdates(ctx context.Context, hash lntypes.Hash) (<-chan *ServerUpdate, <-chan error, error) { resp, err := s.server.SubscribeLoopOutUpdates( - ctx, &swapserverrpc.SubscribeUpdatesRequest{ + ctx, &looprpc.SubscribeUpdatesRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, SwapHash: hash[:], }, @@ -603,7 +603,7 @@ type outCancelDetails struct { func (s *grpcSwapServerClient) CancelLoopOutSwap(ctx context.Context, details *outCancelDetails) error { - req := &swapserverrpc.CancelLoopOutSwapRequest{ + req := &looprpc.CancelLoopOutSwapRequest{ ProtocolVersion: loopdb.CurrentRPCProtocolVersion, SwapHash: details.hash[:], PaymentAddress: details.paymentAddr[:], @@ -620,24 +620,24 @@ func (s *grpcSwapServerClient) CancelLoopOutSwap(ctx context.Context, } func rpcRouteCancel(details *outCancelDetails) ( - *swapserverrpc.CancelLoopOutSwapRequest_RouteCancel, error) { + *looprpc.CancelLoopOutSwapRequest_RouteCancel, error) { attempts := make( - []*swapserverrpc.HtlcAttempt, len(details.metadata.attempts), + []*looprpc.HtlcAttempt, len(details.metadata.attempts), ) for i, remaining := range details.metadata.attempts { - attempts[i] = &swapserverrpc.HtlcAttempt{ + attempts[i] = &looprpc.HtlcAttempt{ RemainingHops: remaining, } } - resp := &swapserverrpc.CancelLoopOutSwapRequest_RouteCancel{ - RouteCancel: &swapserverrpc.RouteCancel{ + resp := &looprpc.CancelLoopOutSwapRequest_RouteCancel{ + RouteCancel: &looprpc.RouteCancel{ Attempts: attempts, // We can cast our lnd failure reason to a loop payment // failure reason because these values are copied 1:1 // from lnd. - Failure: swapserverrpc.PaymentFailureReason( + Failure: looprpc.PaymentFailureReason( details.metadata.failureReason, ), }, @@ -645,10 +645,10 @@ func rpcRouteCancel(details *outCancelDetails) ( switch details.metadata.paymentType { case paymentTypePrepay: - resp.RouteCancel.RouteType = swapserverrpc.RoutePaymentType_PREPAY_ROUTE + resp.RouteCancel.RouteType = looprpc.RoutePaymentType_PREPAY_ROUTE case paymentTypeInvoice: - resp.RouteCancel.RouteType = swapserverrpc.RoutePaymentType_INVOICE_ROUTE + resp.RouteCancel.RouteType = looprpc.RoutePaymentType_INVOICE_ROUTE default: return nil, fmt.Errorf("unknown payment type: %v",