routerrpc

type AprioriConfig struct {
	// HopProbability is the assumed success probability of a hop in a route
	// when no other information is available.
	HopProbability float64 `long:"hopprob" description:"Assumed success probability of a hop in a route when no other information is available."`

	// Weight is a value in the range [0, 1] that defines to what extent
	// historical results should be extrapolated to untried connections.
	// Setting it to one will completely ignore historical results and
	// always assume the configured a priori probability for untried
	// connections. A value of zero will ignore the a priori probability
	// completely and only base the probability on historical results,
	// unless there are none available.
	Weight float64 `long:"weight" description:"Weight of the a priori probability in success probability estimation. Valid values are in [0, 1]."`

	// PenaltyHalfLife defines after how much time a penalized node or
	// channel is back at 50% probability.
	PenaltyHalfLife time.Duration `long:"penaltyhalflife" description:"Defines the duration after which a penalized node or channel is back at 50% probability"`

	// CapacityFraction defines the fraction of channels' capacities that is considered liquid.
	CapacityFraction float64 `` /* 140-byte string literal not displayed */
}

type AprioriParameters struct {

	// The amount of time mission control will take to restore a penalized node
	// or channel back to 50% success probability, expressed in seconds. Setting
	// this value to a higher value will penalize failures for longer, making
	// mission control less likely to route through nodes and channels that we
	// have previously recorded failures for.
	HalfLifeSeconds uint64 `protobuf:"varint,1,opt,name=half_life_seconds,json=halfLifeSeconds,proto3" json:"half_life_seconds,omitempty"`
	// The probability of success mission control should assign to hop in a route
	// where it has no other information available. Higher values will make mission
	// control more willing to try hops that we have no information about, lower
	// values will discourage trying these hops.
	HopProbability float64 `protobuf:"fixed64,2,opt,name=hop_probability,json=hopProbability,proto3" json:"hop_probability,omitempty"`
	// The importance that mission control should place on historical results,
	// expressed as a value in [0;1]. Setting this value to 1 will ignore all
	// historical payments and just use the hop probability to assess the
	// probability of success for each hop. A zero value ignores hop probability
	// completely and relies entirely on historical results, unless none are
	// available.
	Weight float64 `protobuf:"fixed64,3,opt,name=weight,proto3" json:"weight,omitempty"`
	// The fraction of a channel's capacity that we consider to have liquidity. For
	// amounts that come close to or exceed the fraction, an additional penalty is
	// applied. A value of 1.0 disables the capacity factor. Allowed values are in
	// [0.75, 1.0].
	CapacityFraction float64 `protobuf:"fixed64,4,opt,name=capacity_fraction,json=capacityFraction,proto3" json:"capacity_fraction,omitempty"`
	// contains filtered or unexported fields
}

type BimodalConfig struct {
	// Scale describes the scale over which channels still have some
	// liquidity left on both channel ends. A value of 0 means that we
	// assume perfectly unbalanced channels, a very high value means
	// randomly balanced channels.
	Scale int64 `long:"scale" description:"Defines the unbalancedness assumed for the network, the amount defined in msat."`

	// NodeWeight defines how strongly non-routed channels should be taken
	// into account for probability estimation. Valid values are in [0,1].
	NodeWeight float64 `` /* 157-byte string literal not displayed */

	// DecayTime is the scale for the exponential information decay over
	// time for previous successes or failures.
	DecayTime time.Duration `` /* 126-byte string literal not displayed */
}

type BimodalParameters struct {

	// NodeWeight defines how strongly other previous forwardings on channels of a
	// router should be taken into account when computing a channel's probability
	// to route. The allowed values are in the range [0, 1], where a value of 0
	// means that only direct information about a channel is taken into account.
	NodeWeight float64 `protobuf:"fixed64,1,opt,name=node_weight,json=nodeWeight,proto3" json:"node_weight,omitempty"`
	// ScaleMsat describes the scale over which channels statistically have some
	// liquidity left. The value determines how quickly the bimodal distribution
	// drops off from the edges of a channel. A larger value (compared to typical
	// channel capacities) means that the drop off is slow and that channel
	// balances are distributed more uniformly. A small value leads to the
	// assumption of very unbalanced channels.
	ScaleMsat uint64 `protobuf:"varint,2,opt,name=scale_msat,json=scaleMsat,proto3" json:"scale_msat,omitempty"`
	// DecayTime describes the information decay of knowledge about previous
	// successes and failures in channels. The smaller the decay time, the quicker
	// we forget about past forwardings.
	DecayTime uint64 `protobuf:"varint,3,opt,name=decay_time,json=decayTime,proto3" json:"decay_time,omitempty"`
	// contains filtered or unexported fields
}

type BuildRouteRequest struct {

	// The amount to send expressed in msat. If set to zero, the minimum routable
	// amount is used.
	AmtMsat int64 `protobuf:"varint,1,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"`
	// CLTV delta from the current height that should be used for the timelock
	// of the final hop
	FinalCltvDelta int32 `protobuf:"varint,2,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"`
	// The channel id of the channel that must be taken to the first hop. If zero,
	// any channel may be used.
	OutgoingChanId uint64 `protobuf:"varint,3,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"`
	// A list of hops that defines the route. This does not include the source hop
	// pubkey.
	HopPubkeys [][]byte `protobuf:"bytes,4,rep,name=hop_pubkeys,json=hopPubkeys,proto3" json:"hop_pubkeys,omitempty"`
	// An optional payment addr to be included within the last hop of the route.
	// This is also called payment secret in specifications (e.g. BOLT 11).
	PaymentAddr []byte `protobuf:"bytes,5,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"`
	// contains filtered or unexported fields
}

type BuildRouteResponse struct {

	// Fully specified route that can be used to execute the payment.
	Route *lnrpc.Route `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
	// contains filtered or unexported fields
}

type ChanStatusAction int32

type CircuitKey struct {

	// / The id of the channel that the is part of this circuit.
	ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"`
	// / The index of the incoming htlc in the incoming channel.
	HtlcId uint64 `protobuf:"varint,2,opt,name=htlc_id,json=htlcId,proto3" json:"htlc_id,omitempty"`
	// contains filtered or unexported fields
}

type Config struct {
	RoutingConfig

	// UseStatusInitiated is a boolean that indicates whether the router
	// should use the new status code `Payment_INITIATED`.
	//
	// TODO(yy): remove this config after the new status code is fully
	// deployed to the network(v0.20.0).
	UseStatusInitiated bool `` /* 174-byte string literal not displayed */

	// RouterMacPath is the path for the router macaroon. If unspecified
	// then we assume that the macaroon will be found under the network
	// directory, named DefaultRouterMacFilename.
	RouterMacPath string `long:"routermacaroonpath" description:"Path to the router macaroon"`

	// NetworkDir is the main network directory wherein the router rpc
	// server will find the macaroon named DefaultRouterMacFilename.
	NetworkDir string

	// MacService is the main macaroon service that we'll use to handle
	// authentication for the Router rpc server.
	MacService *macaroons.Service

	// Router is the main channel router instance that backs this RPC
	// server.
	//
	// TODO(roasbeef): make into pkg lvl interface?
	//
	// TODO(roasbeef): assumes router handles saving payment state
	Router *routing.ChannelRouter

	// RouterBackend contains shared logic between this sub server and the
	// main rpc server.
	RouterBackend *RouterBackend
}

type FailureDetail int32

type FinalHtlcEvent struct {
	Settled  bool `protobuf:"varint,1,opt,name=settled,proto3" json:"settled,omitempty"`
	Offchain bool `protobuf:"varint,2,opt,name=offchain,proto3" json:"offchain,omitempty"`
	// contains filtered or unexported fields
}

type ForwardEvent struct {

	// Info contains details about the htlc that was forwarded.
	Info *HtlcInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	// contains filtered or unexported fields
}

type ForwardFailEvent struct {
	// contains filtered or unexported fields
}

type ForwardHtlcInterceptRequest struct {

	// The key of this forwarded htlc. It defines the incoming channel id and
	// the index in this channel.
	IncomingCircuitKey *CircuitKey `protobuf:"bytes,1,opt,name=incoming_circuit_key,json=incomingCircuitKey,proto3" json:"incoming_circuit_key,omitempty"`
	// The incoming htlc amount.
	IncomingAmountMsat uint64 `protobuf:"varint,5,opt,name=incoming_amount_msat,json=incomingAmountMsat,proto3" json:"incoming_amount_msat,omitempty"`
	// The incoming htlc expiry.
	IncomingExpiry uint32 `protobuf:"varint,6,opt,name=incoming_expiry,json=incomingExpiry,proto3" json:"incoming_expiry,omitempty"`
	// The htlc payment hash. This value is not guaranteed to be unique per
	// request.
	PaymentHash []byte `protobuf:"bytes,2,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	// The requested outgoing channel id for this forwarded htlc. Because of
	// non-strict forwarding, this isn't necessarily the channel over which the
	// packet will be forwarded eventually. A different channel to the same peer
	// may be selected as well.
	OutgoingRequestedChanId uint64 `` /* 135-byte string literal not displayed */
	// The outgoing htlc amount.
	OutgoingAmountMsat uint64 `protobuf:"varint,3,opt,name=outgoing_amount_msat,json=outgoingAmountMsat,proto3" json:"outgoing_amount_msat,omitempty"`
	// The outgoing htlc expiry.
	OutgoingExpiry uint32 `protobuf:"varint,4,opt,name=outgoing_expiry,json=outgoingExpiry,proto3" json:"outgoing_expiry,omitempty"`
	// Any custom records that were present in the payload.
	CustomRecords map[uint64][]byte `` /* 189-byte string literal not displayed */
	// The onion blob for the next hop
	OnionBlob []byte `protobuf:"bytes,9,opt,name=onion_blob,json=onionBlob,proto3" json:"onion_blob,omitempty"`
	// The block height at which this htlc will be auto-failed to prevent the
	// channel from force-closing.
	AutoFailHeight int32 `protobuf:"varint,10,opt,name=auto_fail_height,json=autoFailHeight,proto3" json:"auto_fail_height,omitempty"`
	// contains filtered or unexported fields
}

type ForwardHtlcInterceptResponse struct {

	// *
	// The key of this forwarded htlc. It defines the incoming channel id and
	// the index in this channel.
	IncomingCircuitKey *CircuitKey `protobuf:"bytes,1,opt,name=incoming_circuit_key,json=incomingCircuitKey,proto3" json:"incoming_circuit_key,omitempty"`
	// The resolve action for this intercepted htlc.
	Action ResolveHoldForwardAction `protobuf:"varint,2,opt,name=action,proto3,enum=routerrpc.ResolveHoldForwardAction" json:"action,omitempty"`
	// The preimage in case the resolve action is Settle.
	Preimage []byte `protobuf:"bytes,3,opt,name=preimage,proto3" json:"preimage,omitempty"`
	// Encrypted failure message in case the resolve action is Fail.
	//
	// If failure_message is specified, the failure_code field must be set
	// to zero.
	FailureMessage []byte `protobuf:"bytes,4,opt,name=failure_message,json=failureMessage,proto3" json:"failure_message,omitempty"`
	// Return the specified failure code in case the resolve action is Fail. The
	// message data fields are populated automatically.
	//
	// If a non-zero failure_code is specified, failure_message must not be set.
	//
	// For backwards-compatibility reasons, TEMPORARY_CHANNEL_FAILURE is the
	// default value for this field.
	FailureCode lnrpc.Failure_FailureCode `` /* 126-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetMissionControlConfigRequest struct {
	// contains filtered or unexported fields
}

type GetMissionControlConfigResponse struct {

	// Mission control's currently active config.
	Config *MissionControlConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// contains filtered or unexported fields
}

type HtlcEvent struct {

	// The short channel id that the incoming htlc arrived at our node on. This
	// value is zero for sends.
	IncomingChannelId uint64 `protobuf:"varint,1,opt,name=incoming_channel_id,json=incomingChannelId,proto3" json:"incoming_channel_id,omitempty"`
	// The short channel id that the outgoing htlc left our node on. This value
	// is zero for receives.
	OutgoingChannelId uint64 `protobuf:"varint,2,opt,name=outgoing_channel_id,json=outgoingChannelId,proto3" json:"outgoing_channel_id,omitempty"`
	// Incoming id is the index of the incoming htlc in the incoming channel.
	// This value is zero for sends.
	IncomingHtlcId uint64 `protobuf:"varint,3,opt,name=incoming_htlc_id,json=incomingHtlcId,proto3" json:"incoming_htlc_id,omitempty"`
	// Outgoing id is the index of the outgoing htlc in the outgoing channel.
	// This value is zero for receives.
	OutgoingHtlcId uint64 `protobuf:"varint,4,opt,name=outgoing_htlc_id,json=outgoingHtlcId,proto3" json:"outgoing_htlc_id,omitempty"`
	// The time in unix nanoseconds that the event occurred.
	TimestampNs uint64 `protobuf:"varint,5,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"`
	// The event type indicates whether the htlc was part of a send, receive or
	// forward.
	EventType HtlcEvent_EventType `protobuf:"varint,6,opt,name=event_type,json=eventType,proto3,enum=routerrpc.HtlcEvent_EventType" json:"event_type,omitempty"`
	// Types that are assignable to Event:
	//
	//	*HtlcEvent_ForwardEvent
	//	*HtlcEvent_ForwardFailEvent
	//	*HtlcEvent_SettleEvent
	//	*HtlcEvent_LinkFailEvent
	//	*HtlcEvent_SubscribedEvent
	//	*HtlcEvent_FinalHtlcEvent
	Event isHtlcEvent_Event `protobuf_oneof:"event"`
	// contains filtered or unexported fields
}

type HtlcEvent_EventType int32

type HtlcEvent_FinalHtlcEvent struct {
	FinalHtlcEvent *FinalHtlcEvent `protobuf:"bytes,12,opt,name=final_htlc_event,json=finalHtlcEvent,proto3,oneof"`
}

type HtlcEvent_ForwardEvent struct {
	ForwardEvent *ForwardEvent `protobuf:"bytes,7,opt,name=forward_event,json=forwardEvent,proto3,oneof"`
}

type HtlcEvent_ForwardFailEvent struct {
	ForwardFailEvent *ForwardFailEvent `protobuf:"bytes,8,opt,name=forward_fail_event,json=forwardFailEvent,proto3,oneof"`
}

type HtlcEvent_LinkFailEvent struct {
	LinkFailEvent *LinkFailEvent `protobuf:"bytes,10,opt,name=link_fail_event,json=linkFailEvent,proto3,oneof"`
}

type HtlcEvent_SettleEvent struct {
	SettleEvent *SettleEvent `protobuf:"bytes,9,opt,name=settle_event,json=settleEvent,proto3,oneof"`
}

type HtlcEvent_SubscribedEvent struct {
	SubscribedEvent *SubscribedEvent `protobuf:"bytes,11,opt,name=subscribed_event,json=subscribedEvent,proto3,oneof"`
}

type HtlcInfo struct {

	// The timelock on the incoming htlc.
	IncomingTimelock uint32 `protobuf:"varint,1,opt,name=incoming_timelock,json=incomingTimelock,proto3" json:"incoming_timelock,omitempty"`
	// The timelock on the outgoing htlc.
	OutgoingTimelock uint32 `protobuf:"varint,2,opt,name=outgoing_timelock,json=outgoingTimelock,proto3" json:"outgoing_timelock,omitempty"`
	// The amount of the incoming htlc.
	IncomingAmtMsat uint64 `protobuf:"varint,3,opt,name=incoming_amt_msat,json=incomingAmtMsat,proto3" json:"incoming_amt_msat,omitempty"`
	// The amount of the outgoing htlc.
	OutgoingAmtMsat uint64 `protobuf:"varint,4,opt,name=outgoing_amt_msat,json=outgoingAmtMsat,proto3" json:"outgoing_amt_msat,omitempty"`
	// contains filtered or unexported fields
}

type LinkFailEvent struct {

	// Info contains details about the htlc that we failed.
	Info *HtlcInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	// FailureCode is the BOLT error code for the failure.
	WireFailure lnrpc.Failure_FailureCode `` /* 126-byte string literal not displayed */
	// FailureDetail provides additional information about the reason for the
	// failure. This detail enriches the information provided by the wire message
	// and may be 'no detail' if the wire message requires no additional metadata.
	FailureDetail FailureDetail `` /* 130-byte string literal not displayed */
	// A string representation of the link failure.
	FailureString string `protobuf:"bytes,4,opt,name=failure_string,json=failureString,proto3" json:"failure_string,omitempty"`
	// contains filtered or unexported fields
}

type MissionControl interface {
	// GetProbability is expected to return the success probability of a
	// payment from fromNode to toNode.
	GetProbability(fromNode, toNode route.Vertex,
		amt lnwire.MilliSatoshi, capacity btcutil.Amount) float64

	// ResetHistory resets the history of MissionControl returning it to a
	// state as if no payment attempts have been made.
	ResetHistory() error

	// GetHistorySnapshot takes a snapshot from the current mission control
	// state and actual probability estimates.
	GetHistorySnapshot() *routing.MissionControlSnapshot

	// ImportHistory imports the mission control snapshot to our internal
	// state. This import will only be applied in-memory, and will not be
	// persisted across restarts.
	ImportHistory(snapshot *routing.MissionControlSnapshot, force bool) error

	// GetPairHistorySnapshot returns the stored history for a given node
	// pair.
	GetPairHistorySnapshot(fromNode,
		toNode route.Vertex) routing.TimedPairResult

	// GetConfig gets mission control's current config.
	GetConfig() *routing.MissionControlConfig

	// SetConfig sets mission control's config to the values provided, if
	// they are valid.
	SetConfig(cfg *routing.MissionControlConfig) error
}

type MissionControlConfig struct {

	// Deprecated, use AprioriParameters. The amount of time mission control will
	// take to restore a penalized node or channel back to 50% success probability,
	// expressed in seconds. Setting this value to a higher value will penalize
	// failures for longer, making mission control less likely to route through
	// nodes and channels that we have previously recorded failures for.
	//
	// Deprecated: Marked as deprecated in routerrpc/router.proto.
	HalfLifeSeconds uint64 `protobuf:"varint,1,opt,name=half_life_seconds,json=halfLifeSeconds,proto3" json:"half_life_seconds,omitempty"`
	// Deprecated, use AprioriParameters. The probability of success mission
	// control should assign to hop in a route where it has no other information
	// available. Higher values will make mission control more willing to try hops
	// that we have no information about, lower values will discourage trying these
	// hops.
	//
	// Deprecated: Marked as deprecated in routerrpc/router.proto.
	HopProbability float32 `protobuf:"fixed32,2,opt,name=hop_probability,json=hopProbability,proto3" json:"hop_probability,omitempty"`
	// Deprecated, use AprioriParameters. The importance that mission control
	// should place on historical results, expressed as a value in [0;1]. Setting
	// this value to 1 will ignore all historical payments and just use the hop
	// probability to assess the probability of success for each hop. A zero value
	// ignores hop probability completely and relies entirely on historical
	// results, unless none are available.
	//
	// Deprecated: Marked as deprecated in routerrpc/router.proto.
	Weight float32 `protobuf:"fixed32,3,opt,name=weight,proto3" json:"weight,omitempty"`
	// The maximum number of payment results that mission control will store.
	MaximumPaymentResults uint32 `` /* 127-byte string literal not displayed */
	// The minimum time that must have passed since the previously recorded failure
	// before we raise the failure amount.
	MinimumFailureRelaxInterval uint64 `` /* 147-byte string literal not displayed */
	// ProbabilityModel defines which probability estimator should be used in
	// pathfinding. Note that the bimodal estimator is experimental.
	Model MissionControlConfig_ProbabilityModel `protobuf:"varint,6,opt,name=model,proto3,enum=routerrpc.MissionControlConfig_ProbabilityModel" json:"model,omitempty"`
	// EstimatorConfig is populated dependent on the estimator type.
	//
	// Types that are assignable to EstimatorConfig:
	//
	//	*MissionControlConfig_Apriori
	//	*MissionControlConfig_Bimodal
	EstimatorConfig isMissionControlConfig_EstimatorConfig `protobuf_oneof:"EstimatorConfig"`
	// contains filtered or unexported fields
}

type MissionControlConfig_Apriori struct {
	Apriori *AprioriParameters `protobuf:"bytes,7,opt,name=apriori,proto3,oneof"`
}

type MissionControlConfig_Bimodal struct {
	Bimodal *BimodalParameters `protobuf:"bytes,8,opt,name=bimodal,proto3,oneof"`
}

type MissionControlConfig_ProbabilityModel int32

type PairData struct {

	// Time of last failure.
	FailTime int64 `protobuf:"varint,1,opt,name=fail_time,json=failTime,proto3" json:"fail_time,omitempty"`
	// Lowest amount that failed to forward rounded to whole sats. This may be
	// set to zero if the failure is independent of amount.
	FailAmtSat int64 `protobuf:"varint,2,opt,name=fail_amt_sat,json=failAmtSat,proto3" json:"fail_amt_sat,omitempty"`
	// Lowest amount that failed to forward in millisats. This may be
	// set to zero if the failure is independent of amount.
	FailAmtMsat int64 `protobuf:"varint,4,opt,name=fail_amt_msat,json=failAmtMsat,proto3" json:"fail_amt_msat,omitempty"`
	// Time of last success.
	SuccessTime int64 `protobuf:"varint,5,opt,name=success_time,json=successTime,proto3" json:"success_time,omitempty"`
	// Highest amount that we could successfully forward rounded to whole sats.
	SuccessAmtSat int64 `protobuf:"varint,6,opt,name=success_amt_sat,json=successAmtSat,proto3" json:"success_amt_sat,omitempty"`
	// Highest amount that we could successfully forward in millisats.
	SuccessAmtMsat int64 `protobuf:"varint,7,opt,name=success_amt_msat,json=successAmtMsat,proto3" json:"success_amt_msat,omitempty"`
	// contains filtered or unexported fields
}

type PairHistory struct {

	// The source node pubkey of the pair.
	NodeFrom []byte `protobuf:"bytes,1,opt,name=node_from,json=nodeFrom,proto3" json:"node_from,omitempty"`
	// The destination node pubkey of the pair.
	NodeTo  []byte    `protobuf:"bytes,2,opt,name=node_to,json=nodeTo,proto3" json:"node_to,omitempty"`
	History *PairData `protobuf:"bytes,7,opt,name=history,proto3" json:"history,omitempty"`
	// contains filtered or unexported fields
}

type PaymentState int32

type PaymentStatus struct {

	// Current state the payment is in.
	State PaymentState `protobuf:"varint,1,opt,name=state,proto3,enum=routerrpc.PaymentState" json:"state,omitempty"`
	// The pre-image of the payment when state is SUCCEEDED.
	Preimage []byte `protobuf:"bytes,2,opt,name=preimage,proto3" json:"preimage,omitempty"`
	// The HTLCs made in attempt to settle the payment [EXPERIMENTAL].
	Htlcs []*lnrpc.HTLCAttempt `protobuf:"bytes,4,rep,name=htlcs,proto3" json:"htlcs,omitempty"`
	// contains filtered or unexported fields
}

type QueryMissionControlRequest struct {
	// contains filtered or unexported fields
}

type QueryMissionControlResponse struct {

	// Node pair-level mission control state.
	Pairs []*PairHistory `protobuf:"bytes,2,rep,name=pairs,proto3" json:"pairs,omitempty"`
	// contains filtered or unexported fields
}

type QueryProbabilityRequest struct {

	// The source node pubkey of the pair.
	FromNode []byte `protobuf:"bytes,1,opt,name=from_node,json=fromNode,proto3" json:"from_node,omitempty"`
	// The destination node pubkey of the pair.
	ToNode []byte `protobuf:"bytes,2,opt,name=to_node,json=toNode,proto3" json:"to_node,omitempty"`
	// The amount for which to calculate a probability.
	AmtMsat int64 `protobuf:"varint,3,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"`
	// contains filtered or unexported fields
}

type QueryProbabilityResponse struct {

	// The success probability for the requested pair.
	Probability float64 `protobuf:"fixed64,1,opt,name=probability,proto3" json:"probability,omitempty"`
	// The historical data for the requested pair.
	History *PairData `protobuf:"bytes,2,opt,name=history,proto3" json:"history,omitempty"`
	// contains filtered or unexported fields
}

type ResetMissionControlRequest struct {
	// contains filtered or unexported fields
}

type ResetMissionControlResponse struct {
	// contains filtered or unexported fields
}

type ResolveHoldForwardAction int32

type RouteFeeRequest struct {

	// The destination one wishes to obtain a routing fee quote to. If set, this
	// parameter requires the amt_sat parameter also to be set. This parameter
	// combination triggers a graph based routing fee estimation as opposed to a
	// payment probe based estimate in case a payment request is provided. The
	// graph based estimation is an algorithm that is executed on the in memory
	// graph. Hence its runtime is significantly shorter than a payment probe
	// estimation that sends out actual payments to the network.
	Dest []byte `protobuf:"bytes,1,opt,name=dest,proto3" json:"dest,omitempty"`
	// The amount one wishes to send to the target destination. It is only to be
	// used in combination with the dest parameter.
	AmtSat int64 `protobuf:"varint,2,opt,name=amt_sat,json=amtSat,proto3" json:"amt_sat,omitempty"`
	// A payment request of the target node that the route fee request is intended
	// for. Its parameters are input to probe payments that estimate routing fees.
	// The timeout parameter can be specified to set a maximum time on the probing
	// attempt. Cannot be used in combination with dest and amt_sat.
	PaymentRequest string `protobuf:"bytes,3,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"`
	// A user preference of how long a probe payment should maximally be allowed to
	// take, denoted in seconds. The probing payment loop is aborted if this
	// timeout is reached. Note that the probing process itself can take longer
	// than the timeout if the HTLC becomes delayed or stuck. Canceling the context
	// of this call will not cancel the payment loop, the duration is only
	// controlled by the timeout parameter.
	Timeout uint32 `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
	// contains filtered or unexported fields
}

type RouteFeeResponse struct {

	// A lower bound of the estimated fee to the target destination within the
	// network, expressed in milli-satoshis.
	RoutingFeeMsat int64 `protobuf:"varint,1,opt,name=routing_fee_msat,json=routingFeeMsat,proto3" json:"routing_fee_msat,omitempty"`
	// An estimate of the worst case time delay that can occur. Note that callers
	// will still need to factor in the final CLTV delta of the last hop into this
	// value.
	TimeLockDelay int64 `protobuf:"varint,2,opt,name=time_lock_delay,json=timeLockDelay,proto3" json:"time_lock_delay,omitempty"`
	// An indication whether a probing payment succeeded or whether and why it
	// failed. FAILURE_REASON_NONE indicates success.
	FailureReason lnrpc.PaymentFailureReason `` /* 133-byte string literal not displayed */
	// contains filtered or unexported fields
}

type RouterBackend struct {
	// SelfNode is the vertex of the node sending the payment.
	SelfNode route.Vertex

	// FetchChannelCapacity is a closure that we'll use the fetch the total
	// capacity of a channel to populate in responses.
	FetchChannelCapacity func(chanID uint64) (btcutil.Amount, error)

	// FetchAmountPairCapacity determines the maximal channel capacity
	// between two nodes given a certain amount.
	FetchAmountPairCapacity func(nodeFrom, nodeTo route.Vertex,
		amount lnwire.MilliSatoshi) (btcutil.Amount, error)

	// FetchChannelEndpoints returns the pubkeys of both endpoints of the
	// given channel id.
	FetchChannelEndpoints func(chanID uint64) (route.Vertex,
		route.Vertex, error)

	// FindRoute is a closure that abstracts away how we locate/query for
	// routes.
	FindRoute func(*routing.RouteRequest) (*route.Route, float64, error)

	MissionControl MissionControl

	// ActiveNetParams are the network parameters of the primary network
	// that the route is operating on. This is necessary so we can ensure
	// that we receive payment requests that send to destinations on our
	// network.
	ActiveNetParams *chaincfg.Params

	// Tower is the ControlTower instance that is used to track pending
	// payments.
	Tower routing.ControlTower

	// MaxTotalTimelock is the maximum total time lock a route is allowed to
	// have.
	MaxTotalTimelock uint32

	// DefaultFinalCltvDelta is the default value used as final cltv delta
	// when an RPC caller doesn't specify a value.
	DefaultFinalCltvDelta uint16

	// SubscribeHtlcEvents returns a subscription client for the node's
	// htlc events.
	SubscribeHtlcEvents func() (*subscribe.Client, error)

	// InterceptableForwarder exposes the ability to intercept forward events
	// by letting the router register a ForwardInterceptor.
	InterceptableForwarder htlcswitch.InterceptableHtlcForwarder

	// SetChannelEnabled exposes the ability to manually enable a channel.
	SetChannelEnabled func(wire.OutPoint) error

	// SetChannelDisabled exposes the ability to manually disable a channel
	SetChannelDisabled func(wire.OutPoint) error

	// SetChannelAuto exposes the ability to restore automatic channel state
	// management after manually setting channel status.
	SetChannelAuto func(wire.OutPoint) error

	// UseStatusInitiated is a boolean that indicates whether the router
	// should use the new status code `Payment_INITIATED`.
	//
	// TODO(yy): remove this config after the new status code is fully
	// deployed to the network(v0.20.0).
	UseStatusInitiated bool
}

type RouterClient interface {
	// SendPaymentV2 attempts to route a payment described by the passed
	// PaymentRequest to the final destination. The call returns a stream of
	// payment updates. When using this RPC, make sure to set a fee limit, as the
	// default routing fee limit is 0 sats. Without a non-zero fee limit only
	// routes without fees will be attempted which often fails with
	// FAILURE_REASON_NO_ROUTE.
	SendPaymentV2(ctx context.Context, in *SendPaymentRequest, opts ...grpc.CallOption) (Router_SendPaymentV2Client, error)
	// lncli: `trackpayment`
	// TrackPaymentV2 returns an update stream for the payment identified by the
	// payment hash.
	TrackPaymentV2(ctx context.Context, in *TrackPaymentRequest, opts ...grpc.CallOption) (Router_TrackPaymentV2Client, error)
	// TrackPayments returns an update stream for every payment that is not in a
	// terminal state. Note that if payments are in-flight while starting a new
	// subscription, the start of the payment stream could produce out-of-order
	// and/or duplicate events. In order to get updates for every in-flight
	// payment attempt make sure to subscribe to this method before initiating any
	// payments.
	TrackPayments(ctx context.Context, in *TrackPaymentsRequest, opts ...grpc.CallOption) (Router_TrackPaymentsClient, error)
	// EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
	// may cost to send an HTLC to the target end destination.
	EstimateRouteFee(ctx context.Context, in *RouteFeeRequest, opts ...grpc.CallOption) (*RouteFeeResponse, error)
	// Deprecated: Do not use.
	//
	// Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via
	// the specified route. This method differs from SendPayment in that it
	// allows users to specify a full route manually. This can be used for
	// things like rebalancing, and atomic swaps. It differs from the newer
	// SendToRouteV2 in that it doesn't return the full HTLC information.
	SendToRoute(ctx context.Context, in *SendToRouteRequest, opts ...grpc.CallOption) (*SendToRouteResponse, error)
	// SendToRouteV2 attempts to make a payment via the specified route. This
	// method differs from SendPayment in that it allows users to specify a full
	// route manually. This can be used for things like rebalancing, and atomic
	// swaps.
	SendToRouteV2(ctx context.Context, in *SendToRouteRequest, opts ...grpc.CallOption) (*lnrpc.HTLCAttempt, error)
	// lncli: `resetmc`
	// ResetMissionControl clears all mission control state and starts with a clean
	// slate.
	ResetMissionControl(ctx context.Context, in *ResetMissionControlRequest, opts ...grpc.CallOption) (*ResetMissionControlResponse, error)
	// lncli: `querymc`
	// QueryMissionControl exposes the internal mission control state to callers.
	// It is a development feature.
	QueryMissionControl(ctx context.Context, in *QueryMissionControlRequest, opts ...grpc.CallOption) (*QueryMissionControlResponse, error)
	// lncli: `importmc`
	// XImportMissionControl is an experimental API that imports the state provided
	// to the internal mission control's state, using all results which are more
	// recent than our existing values. These values will only be imported
	// in-memory, and will not be persisted across restarts.
	XImportMissionControl(ctx context.Context, in *XImportMissionControlRequest, opts ...grpc.CallOption) (*XImportMissionControlResponse, error)
	// lncli: `getmccfg`
	// GetMissionControlConfig returns mission control's current config.
	GetMissionControlConfig(ctx context.Context, in *GetMissionControlConfigRequest, opts ...grpc.CallOption) (*GetMissionControlConfigResponse, error)
	// lncli: `setmccfg`
	// SetMissionControlConfig will set mission control's config, if the config
	// provided is valid.
	SetMissionControlConfig(ctx context.Context, in *SetMissionControlConfigRequest, opts ...grpc.CallOption) (*SetMissionControlConfigResponse, error)
	// lncli: `queryprob`
	// Deprecated. QueryProbability returns the current success probability
	// estimate for a given node pair and amount. The call returns a zero success
	// probability if no channel is available or if the amount violates min/max
	// HTLC constraints.
	QueryProbability(ctx context.Context, in *QueryProbabilityRequest, opts ...grpc.CallOption) (*QueryProbabilityResponse, error)
	// lncli: `buildroute`
	// BuildRoute builds a fully specified route based on a list of hop public
	// keys. It retrieves the relevant channel policies from the graph in order to
	// calculate the correct fees and time locks.
	// Note that LND will use its default final_cltv_delta if no value is supplied.
	// Make sure to add the correct final_cltv_delta depending on the invoice
	// restriction. Moreover the caller has to make sure to provide the
	// payment_addr if the route is paying an invoice which signaled it.
	BuildRoute(ctx context.Context, in *BuildRouteRequest, opts ...grpc.CallOption) (*BuildRouteResponse, error)
	// SubscribeHtlcEvents creates a uni-directional stream from the server to
	// the client which delivers a stream of htlc events.
	SubscribeHtlcEvents(ctx context.Context, in *SubscribeHtlcEventsRequest, opts ...grpc.CallOption) (Router_SubscribeHtlcEventsClient, error)
	// Deprecated: Do not use.
	//
	// Deprecated, use SendPaymentV2. SendPayment attempts to route a payment
	// described by the passed PaymentRequest to the final destination. The call
	// returns a stream of payment status updates.
	SendPayment(ctx context.Context, in *SendPaymentRequest, opts ...grpc.CallOption) (Router_SendPaymentClient, error)
	// Deprecated: Do not use.
	//
	// Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for
	// the payment identified by the payment hash.
	TrackPayment(ctx context.Context, in *TrackPaymentRequest, opts ...grpc.CallOption) (Router_TrackPaymentClient, error)
	// *
	// HtlcInterceptor dispatches a bi-directional streaming RPC in which
	// Forwarded HTLC requests are sent to the client and the client responds with
	// a boolean that tells LND if this htlc should be intercepted.
	// In case of interception, the htlc can be either settled, cancelled or
	// resumed later by using the ResolveHoldForward endpoint.
	HtlcInterceptor(ctx context.Context, opts ...grpc.CallOption) (Router_HtlcInterceptorClient, error)
	// lncli: `updatechanstatus`
	// UpdateChanStatus attempts to manually set the state of a channel
	// (enabled, disabled, or auto). A manual "disable" request will cause the
	// channel to stay disabled until a subsequent manual request of either
	// "enable" or "auto".
	UpdateChanStatus(ctx context.Context, in *UpdateChanStatusRequest, opts ...grpc.CallOption) (*UpdateChanStatusResponse, error)
}

type RouterServer interface {
	// SendPaymentV2 attempts to route a payment described by the passed
	// PaymentRequest to the final destination. The call returns a stream of
	// payment updates. When using this RPC, make sure to set a fee limit, as the
	// default routing fee limit is 0 sats. Without a non-zero fee limit only
	// routes without fees will be attempted which often fails with
	// FAILURE_REASON_NO_ROUTE.
	SendPaymentV2(*SendPaymentRequest, Router_SendPaymentV2Server) error
	// lncli: `trackpayment`
	// TrackPaymentV2 returns an update stream for the payment identified by the
	// payment hash.
	TrackPaymentV2(*TrackPaymentRequest, Router_TrackPaymentV2Server) error
	// TrackPayments returns an update stream for every payment that is not in a
	// terminal state. Note that if payments are in-flight while starting a new
	// subscription, the start of the payment stream could produce out-of-order
	// and/or duplicate events. In order to get updates for every in-flight
	// payment attempt make sure to subscribe to this method before initiating any
	// payments.
	TrackPayments(*TrackPaymentsRequest, Router_TrackPaymentsServer) error
	// EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it
	// may cost to send an HTLC to the target end destination.
	EstimateRouteFee(context.Context, *RouteFeeRequest) (*RouteFeeResponse, error)
	// Deprecated: Do not use.
	//
	// Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via
	// the specified route. This method differs from SendPayment in that it
	// allows users to specify a full route manually. This can be used for
	// things like rebalancing, and atomic swaps. It differs from the newer
	// SendToRouteV2 in that it doesn't return the full HTLC information.
	SendToRoute(context.Context, *SendToRouteRequest) (*SendToRouteResponse, error)
	// SendToRouteV2 attempts to make a payment via the specified route. This
	// method differs from SendPayment in that it allows users to specify a full
	// route manually. This can be used for things like rebalancing, and atomic
	// swaps.
	SendToRouteV2(context.Context, *SendToRouteRequest) (*lnrpc.HTLCAttempt, error)
	// lncli: `resetmc`
	// ResetMissionControl clears all mission control state and starts with a clean
	// slate.
	ResetMissionControl(context.Context, *ResetMissionControlRequest) (*ResetMissionControlResponse, error)
	// lncli: `querymc`
	// QueryMissionControl exposes the internal mission control state to callers.
	// It is a development feature.
	QueryMissionControl(context.Context, *QueryMissionControlRequest) (*QueryMissionControlResponse, error)
	// lncli: `importmc`
	// XImportMissionControl is an experimental API that imports the state provided
	// to the internal mission control's state, using all results which are more
	// recent than our existing values. These values will only be imported
	// in-memory, and will not be persisted across restarts.
	XImportMissionControl(context.Context, *XImportMissionControlRequest) (*XImportMissionControlResponse, error)
	// lncli: `getmccfg`
	// GetMissionControlConfig returns mission control's current config.
	GetMissionControlConfig(context.Context, *GetMissionControlConfigRequest) (*GetMissionControlConfigResponse, error)
	// lncli: `setmccfg`
	// SetMissionControlConfig will set mission control's config, if the config
	// provided is valid.
	SetMissionControlConfig(context.Context, *SetMissionControlConfigRequest) (*SetMissionControlConfigResponse, error)
	// lncli: `queryprob`
	// Deprecated. QueryProbability returns the current success probability
	// estimate for a given node pair and amount. The call returns a zero success
	// probability if no channel is available or if the amount violates min/max
	// HTLC constraints.
	QueryProbability(context.Context, *QueryProbabilityRequest) (*QueryProbabilityResponse, error)
	// lncli: `buildroute`
	// BuildRoute builds a fully specified route based on a list of hop public
	// keys. It retrieves the relevant channel policies from the graph in order to
	// calculate the correct fees and time locks.
	// Note that LND will use its default final_cltv_delta if no value is supplied.
	// Make sure to add the correct final_cltv_delta depending on the invoice
	// restriction. Moreover the caller has to make sure to provide the
	// payment_addr if the route is paying an invoice which signaled it.
	BuildRoute(context.Context, *BuildRouteRequest) (*BuildRouteResponse, error)
	// SubscribeHtlcEvents creates a uni-directional stream from the server to
	// the client which delivers a stream of htlc events.
	SubscribeHtlcEvents(*SubscribeHtlcEventsRequest, Router_SubscribeHtlcEventsServer) error
	// Deprecated: Do not use.
	//
	// Deprecated, use SendPaymentV2. SendPayment attempts to route a payment
	// described by the passed PaymentRequest to the final destination. The call
	// returns a stream of payment status updates.
	SendPayment(*SendPaymentRequest, Router_SendPaymentServer) error
	// Deprecated: Do not use.
	//
	// Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for
	// the payment identified by the payment hash.
	TrackPayment(*TrackPaymentRequest, Router_TrackPaymentServer) error
	// *
	// HtlcInterceptor dispatches a bi-directional streaming RPC in which
	// Forwarded HTLC requests are sent to the client and the client responds with
	// a boolean that tells LND if this htlc should be intercepted.
	// In case of interception, the htlc can be either settled, cancelled or
	// resumed later by using the ResolveHoldForward endpoint.
	HtlcInterceptor(Router_HtlcInterceptorServer) error
	// lncli: `updatechanstatus`
	// UpdateChanStatus attempts to manually set the state of a channel
	// (enabled, disabled, or auto). A manual "disable" request will cause the
	// channel to stay disabled until a subsequent manual request of either
	// "enable" or "auto".
	UpdateChanStatus(context.Context, *UpdateChanStatusRequest) (*UpdateChanStatusResponse, error)
	// contains filtered or unexported methods
}

type Router_HtlcInterceptorClient interface {
	Send(*ForwardHtlcInterceptResponse) error
	Recv() (*ForwardHtlcInterceptRequest, error)
	grpc.ClientStream
}

type Router_HtlcInterceptorServer interface {
	Send(*ForwardHtlcInterceptRequest) error
	Recv() (*ForwardHtlcInterceptResponse, error)
	grpc.ServerStream
}

type Router_SendPaymentClient interface {
	Recv() (*PaymentStatus, error)
	grpc.ClientStream
}

type Router_SendPaymentServer interface {
	Send(*PaymentStatus) error
	grpc.ServerStream
}

type Router_SendPaymentV2Client interface {
	Recv() (*lnrpc.Payment, error)
	grpc.ClientStream
}

type Router_SendPaymentV2Server interface {
	Send(*lnrpc.Payment) error
	grpc.ServerStream
}

type Router_SubscribeHtlcEventsClient interface {
	Recv() (*HtlcEvent, error)
	grpc.ClientStream
}

type Router_SubscribeHtlcEventsServer interface {
	Send(*HtlcEvent) error
	grpc.ServerStream
}

type Router_TrackPaymentClient interface {
	Recv() (*PaymentStatus, error)
	grpc.ClientStream
}

type Router_TrackPaymentServer interface {
	Send(*PaymentStatus) error
	grpc.ServerStream
}

type Router_TrackPaymentV2Client interface {
	Recv() (*lnrpc.Payment, error)
	grpc.ClientStream
}

type Router_TrackPaymentV2Server interface {
	Send(*lnrpc.Payment) error
	grpc.ServerStream
}

type Router_TrackPaymentsClient interface {
	Recv() (*lnrpc.Payment, error)
	grpc.ClientStream
}

type Router_TrackPaymentsServer interface {
	Send(*lnrpc.Payment) error
	grpc.ServerStream
}

type RoutingConfig struct {
	// ProbabilityEstimatorType sets the estimator to use.
	ProbabilityEstimatorType string `long:"estimator" choice:"apriori" choice:"bimodal" description:"Probability estimator used for pathfinding." `

	// MinRouteProbability is the minimum required route success probability
	// to attempt the payment.
	MinRouteProbability float64 `long:"minrtprob" description:"Minimum required route success probability to attempt the payment"`

	// AttemptCost is the fixed virtual cost in path finding of a failed
	// payment attempt. It is used to trade off potentially better routes
	// against their probability of succeeding.
	AttemptCost btcutil.Amount `long:"attemptcost" description:"The fixed (virtual) cost in sats of a failed payment attempt"`

	// AttemptCostPPM is the proportional virtual cost in path finding of a
	// failed payment attempt. It is used to trade off potentially better
	// routes against their probability of succeeding. This parameter is
	// expressed in parts per million of the total payment amount.
	AttemptCostPPM int64 `` /* 162-byte string literal not displayed */

	// MaxMcHistory defines the maximum number of payment results that
	// are held on disk by mission control.
	MaxMcHistory int `long:"maxmchistory" description:"the maximum number of payment results that are held on disk by mission control"`

	// McFlushInterval defines the timer interval to use to flush mission
	// control state to the DB.
	McFlushInterval time.Duration `long:"mcflushinterval" description:"the timer interval to use to flush mission control state to the DB"`

	// AprioriConfig defines parameters for the apriori probability.
	AprioriConfig *AprioriConfig `group:"apriori" namespace:"apriori" description:"configuration for the apriori pathfinding probability estimator"`

	// BimodalConfig defines parameters for the bimodal probability.
	BimodalConfig *BimodalConfig `group:"bimodal" namespace:"bimodal" description:"configuration for the bimodal pathfinding probability estimator"`

	// FeeEstimationTimeout is the maximum time to wait for routing fees to be estimated.
	FeeEstimationTimeout time.Duration `long:"fee-estimation-timeout" description:"the maximum time to wait for routing fees to be estimated by payment probes"`
}

type SendPaymentRequest struct {

	// The identity pubkey of the payment recipient
	Dest []byte `protobuf:"bytes,1,opt,name=dest,proto3" json:"dest,omitempty"`
	// Number of satoshis to send.
	//
	// The fields amt and amt_msat are mutually exclusive.
	Amt int64 `protobuf:"varint,2,opt,name=amt,proto3" json:"amt,omitempty"`
	// The hash to use within the payment's HTLC
	PaymentHash []byte `protobuf:"bytes,3,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	// The CLTV delta from the current height that should be used to set the
	// timelock for the final hop.
	FinalCltvDelta int32 `protobuf:"varint,4,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"`
	// A bare-bones invoice for a payment within the Lightning Network.  With the
	// details of the invoice, the sender has all the data necessary to send a
	// payment to the recipient. The amount in the payment request may be zero. In
	// that case it is required to set the amt field as well. If no payment request
	// is specified, the following fields are required: dest, amt and payment_hash.
	PaymentRequest string `protobuf:"bytes,5,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"`
	// An upper limit on the amount of time we should spend when attempting to
	// fulfill the payment. This is expressed in seconds. If we cannot make a
	// successful payment within this time frame, an error will be returned.
	// This field must be non-zero.
	TimeoutSeconds int32 `protobuf:"varint,6,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	// The maximum number of satoshis that will be paid as a fee of the payment.
	// If this field is left to the default value of 0, only zero-fee routes will
	// be considered. This usually means single hop routes connecting directly to
	// the destination. To send the payment without a fee limit, use max int here.
	//
	// The fields fee_limit_sat and fee_limit_msat are mutually exclusive.
	FeeLimitSat int64 `protobuf:"varint,7,opt,name=fee_limit_sat,json=feeLimitSat,proto3" json:"fee_limit_sat,omitempty"`
	// Deprecated, use outgoing_chan_ids. The channel id of the channel that must
	// be taken to the first hop. If zero, any channel may be used (unless
	// outgoing_chan_ids are set).
	//
	// Deprecated: Marked as deprecated in routerrpc/router.proto.
	OutgoingChanId uint64 `protobuf:"varint,8,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"`
	// An optional maximum total time lock for the route. This should not
	// exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of
	// `--max-cltv-expiry` is enforced.
	CltvLimit int32 `protobuf:"varint,9,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,omitempty"`
	// Optional route hints to reach the destination through private channels.
	RouteHints []*lnrpc.RouteHint `protobuf:"bytes,10,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"`
	// An optional field that can be used to pass an arbitrary set of TLV records
	// to a peer which understands the new records. This can be used to pass
	// application specific data during the payment attempt. Record types are
	// required to be in the custom range >= 65536. When using REST, the values
	// must be encoded as base64.
	DestCustomRecords map[uint64][]byte `` /* 204-byte string literal not displayed */
	// Number of millisatoshis to send.
	//
	// The fields amt and amt_msat are mutually exclusive.
	AmtMsat int64 `protobuf:"varint,12,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"`
	// The maximum number of millisatoshis that will be paid as a fee of the
	// payment. If this field is left to the default value of 0, only zero-fee
	// routes will be considered. This usually means single hop routes connecting
	// directly to the destination. To send the payment without a fee limit, use
	// max int here.
	//
	// The fields fee_limit_sat and fee_limit_msat are mutually exclusive.
	FeeLimitMsat int64 `protobuf:"varint,13,opt,name=fee_limit_msat,json=feeLimitMsat,proto3" json:"fee_limit_msat,omitempty"`
	// The pubkey of the last hop of the route. If empty, any hop may be used.
	LastHopPubkey []byte `protobuf:"bytes,14,opt,name=last_hop_pubkey,json=lastHopPubkey,proto3" json:"last_hop_pubkey,omitempty"`
	// If set, circular payments to self are permitted.
	AllowSelfPayment bool `protobuf:"varint,15,opt,name=allow_self_payment,json=allowSelfPayment,proto3" json:"allow_self_payment,omitempty"`
	// Features assumed to be supported by the final node. All transitive feature
	// dependencies must also be set properly. For a given feature bit pair, either
	// optional or remote may be set, but not both. If this field is nil or empty,
	// the router will try to load destination features from the graph as a
	// fallback.
	DestFeatures []lnrpc.FeatureBit `` /* 128-byte string literal not displayed */
	// The maximum number of partial payments that may be use to complete the full
	// amount.
	MaxParts uint32 `protobuf:"varint,17,opt,name=max_parts,json=maxParts,proto3" json:"max_parts,omitempty"`
	// If set, only the final payment update is streamed back. Intermediate updates
	// that show which htlcs are still in flight are suppressed.
	NoInflightUpdates bool `protobuf:"varint,18,opt,name=no_inflight_updates,json=noInflightUpdates,proto3" json:"no_inflight_updates,omitempty"`
	// The channel ids of the channels are allowed for the first hop. If empty,
	// any channel may be used.
	OutgoingChanIds []uint64 `protobuf:"varint,19,rep,packed,name=outgoing_chan_ids,json=outgoingChanIds,proto3" json:"outgoing_chan_ids,omitempty"`
	// An optional payment addr to be included within the last hop of the route.
	// This is also called payment secret in specifications (e.g. BOLT 11).
	PaymentAddr []byte `protobuf:"bytes,20,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"`
	// The largest payment split that should be attempted when making a payment if
	// splitting is necessary. Setting this value will effectively cause lnd to
	// split more aggressively, vs only when it thinks it needs to. Note that this
	// value is in milli-satoshis.
	MaxShardSizeMsat uint64 `protobuf:"varint,21,opt,name=max_shard_size_msat,json=maxShardSizeMsat,proto3" json:"max_shard_size_msat,omitempty"`
	// If set, an AMP-payment will be attempted.
	Amp bool `protobuf:"varint,22,opt,name=amp,proto3" json:"amp,omitempty"`
	// The time preference for this payment. Set to -1 to optimize for fees
	// only, to 1 to optimize for reliability only or a value inbetween for a mix.
	TimePref float64 `protobuf:"fixed64,23,opt,name=time_pref,json=timePref,proto3" json:"time_pref,omitempty"`
	// contains filtered or unexported fields
}

type SendToRouteRequest struct {

	// The payment hash to use for the HTLC.
	PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	// Route that should be used to attempt to complete the payment.
	Route *lnrpc.Route `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"`
	// Whether the payment should be marked as failed when a temporary error is
	// returned from the given route. Set it to true so the payment won't be
	// failed unless a terminal error is occurred, such as payment timeout, no
	// routes, incorrect payment details, or insufficient funds.
	SkipTempErr bool `protobuf:"varint,3,opt,name=skip_temp_err,json=skipTempErr,proto3" json:"skip_temp_err,omitempty"`
	// contains filtered or unexported fields
}

type SendToRouteResponse struct {

	// The preimage obtained by making the payment.
	Preimage []byte `protobuf:"bytes,1,opt,name=preimage,proto3" json:"preimage,omitempty"`
	// The failure message in case the payment failed.
	Failure *lnrpc.Failure `protobuf:"bytes,2,opt,name=failure,proto3" json:"failure,omitempty"`
	// contains filtered or unexported fields
}

type Server struct {

	// Required by the grpc-gateway/v2 library for forward compatibility.
	// Must be after the atomically used variables to not break struct
	// alignment.
	UnimplementedRouterServer
	// contains filtered or unexported fields
}

type ServerShell struct {
	RouterServer
}

type SetMissionControlConfigRequest struct {

	// The config to set for mission control. Note that all values *must* be set,
	// because the full config will be applied.
	Config *MissionControlConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	// contains filtered or unexported fields
}

type SetMissionControlConfigResponse struct {
	// contains filtered or unexported fields
}

type SettleEvent struct {

	// The revealed preimage.
	Preimage []byte `protobuf:"bytes,1,opt,name=preimage,proto3" json:"preimage,omitempty"`
	// contains filtered or unexported fields
}

type SubscribeHtlcEventsRequest struct {
	// contains filtered or unexported fields
}

type SubscribedEvent struct {
	// contains filtered or unexported fields
}

type TrackPaymentRequest struct {

	// The hash of the payment to look up.
	PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"`
	// If set, only the final payment update is streamed back. Intermediate updates
	// that show which htlcs are still in flight are suppressed.
	NoInflightUpdates bool `protobuf:"varint,2,opt,name=no_inflight_updates,json=noInflightUpdates,proto3" json:"no_inflight_updates,omitempty"`
	// contains filtered or unexported fields
}

type TrackPaymentsRequest struct {

	// If set, only the final payment updates are streamed back. Intermediate
	// updates that show which htlcs are still in flight are suppressed.
	NoInflightUpdates bool `protobuf:"varint,1,opt,name=no_inflight_updates,json=noInflightUpdates,proto3" json:"no_inflight_updates,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedRouterServer struct {
}