package routerrpc
Get desktop application:
View/edit binary Protocol Buffers messages
service Router
router.proto:29Router is a service that offers advanced interaction with the router subsystem of the daemon.
rpc BuildRoute (, )
router.proto:124lncli: `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.
message
router.proto:705int64 amt_msat = 1
The amount to send expressed in msat. If set to zero, the minimum routable amount is used.
int32 final_cltv_delta = 2
CLTV delta from the current height that should be used for the timelock of the final hop
uint64 outgoing_chan_id = 3
The channel id of the channel that must be taken to the first hop. If zero, any channel may be used.
repeated bytes hop_pubkeys = 4
A list of hops that defines the route. This does not include the source hop pubkey.
bytes payment_addr = 5
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).
map<uint64, bytes> first_hop_custom_records = 6
An optional field that can be used to pass an arbitrary set of TLV records to the first hop peer of this payment. 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.
message
router.proto:746optional route = 1
Fully specified route that can be used to execute the payment.
lncli: `deletefwdhistory` DeleteForwardingHistory allows the caller to delete forwarding history events with a timestamp at or before a specified time. This is useful for implementing data retention policies for privacy purposes. The call deletes events in batches and returns statistics including the total number of events deleted and the aggregate fees earned from those events. The deletion is performed in a transaction-safe manner with configurable batch sizes to avoid holding large database locks.
message
router.proto:1080oneof time_spec
Specify the cutoff time for deletion using one of the following options. Events with a timestamp at or before the cutoff are deleted.
uint64 delete_before_time = 1
Absolute Unix timestamp (seconds). Events at or before this time are deleted.
string delete_before_duration = 2
Relative duration string indicating how far back to delete, e.g. "-30d" deletes events at or before 30 days ago. Standard Go: "-24h", "-1.5h" Custom units: "-1d", "-1w", "-1M", "-1y" Supported: ns, us/µs, ms, s, m, h, d (days), w (weeks), M (months=30.44d), y (years=365.25d). Use negative values to specify time in the past.
message
router.proto:1099uint64 events_deleted = 1
Number of forwarding events deleted.
int64 total_fee_msat = 2
Total fees earned from deleted events (in millisatoshis). This is the sum of (amt_in - amt_out) for all deleted events, which can be used for accounting purposes.
string status = 3
Status message.
rpc EstimateRouteFee (, )
router.proto:60lncli: `estimateroutefee` 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.
message
router.proto:378bytes dest = 1
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.
int64 amt_sat = 2
The amount one wishes to send to the target destination. It is only to be used in combination with the dest parameter.
string payment_request = 3
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.
uint32 timeout = 4
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. If the field is not set or is explicitly set to zero, the default value of 60 seconds will be applied.
repeated uint64 outgoing_chan_ids = 5
The channel ids of the channels that are allowed for the first hop. If empty, any channel may be used. This field is applicable to both graph-based fee estimation (using dest + amt_sat) and probe-based estimation (using payment_request).
message
router.proto:424int64 routing_fee_msat = 1
A lower bound of the estimated fee to the target destination within the network, expressed in milli-satoshis.
int64 time_lock_delay = 2
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.
lnrpc.PaymentFailureReason failure_reason = 5
An indication whether a probing payment succeeded or whether and why it failed. FAILURE_REASON_NONE indicates success.
lncli: `getmccfg` GetMissionControlConfig returns mission control's current config.
message
router.proto:541(message has no fields)
message
router.proto:544optional config = 1
Mission control's currently active config.
rpc HtlcInterceptor (stream , stream )
router.proto:140* 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.
message
router.proto:976* ForwardHtlcInterceptResponse enables the caller to resolve a previously hold forward. The caller can choose either to: - `Resume`: Execute the default behavior (usually forward). - `ResumeModified`: Execute the default behavior (usually forward) with HTLC field modifications. - `Reject`: Fail the htlc backwards. - `Settle`: Settle this htlc with a given preimage. Once the incoming channel has force-closed and the HTLC is being resolved on-chain (see auto_fail_height), only `Settle` has any effect. The HTLC can no longer be resumed or failed back off-chain, so `Resume`, `ResumeModified`, and `Fail` return a stream-terminating error. The HTLC stays held until it is settled with a preimage, the on-chain resolver completes, or it expires on-chain. Clients should reconnect to receive any held HTLCs that remain unresolved.
optional incoming_circuit_key = 1
* The key of this forwarded htlc. It defines the incoming channel id and the index in this channel.
ResolveHoldForwardAction action = 2
The resolve action for this intercepted htlc.
bytes preimage = 3
The preimage in case the resolve action is Settle.
bytes failure_message = 4
Encrypted failure message in case the resolve action is Fail. If failure_message is specified, the failure_code field must be set to zero.
lnrpc.Failure.FailureCode failure_code = 5
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.
uint64 in_amount_msat = 6
The amount that was set on the p2p wire message of the incoming HTLC. This field is ignored if the action is not RESUME_MODIFIED or the amount is zero.
uint64 out_amount_msat = 7
The amount to set on the p2p wire message of the resumed HTLC. This field is ignored if the action is not RESUME_MODIFIED or the amount is zero.
map<uint64, bytes> out_wire_custom_records = 8
Any custom records that should be set on the p2p wire message message of the resumed HTLC. This field is ignored if the action is not RESUME_MODIFIED. This map will merge with the existing set of custom records (if any), replacing any conflicting types. Note that there currently is no support for deleting existing custom records (they can only be replaced).
message
router.proto:909optional incoming_circuit_key = 1
The key of this forwarded htlc. It defines the incoming channel id and the index in this channel. Interceptor clients should handle requests for the same circuit key idempotently. Requests may be replayed after reconnect, and an htlc that was previously offered off-chain may be offered again after it moves on-chain.
uint64 incoming_amount_msat = 5
The incoming htlc amount.
uint32 incoming_expiry = 6
The incoming htlc expiry.
bytes payment_hash = 2
The htlc payment hash. This value is not guaranteed to be unique per request.
uint64 outgoing_requested_chan_id = 7
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.
uint64 outgoing_amount_msat = 3
The outgoing htlc amount.
uint32 outgoing_expiry = 4
The outgoing htlc expiry.
map<uint64, bytes> custom_records = 8
Any custom records that were present in the payload.
bytes onion_blob = 9
The onion blob for the next hop
int32 auto_fail_height = 10
The block height at which this htlc will be auto-failed to prevent the channel from force-closing. For on-chain htlcs, this field is the settlement deadline instead and no automatic fail-back is attempted.
map<uint64, bytes> in_wire_custom_records = 11
The custom records of the peer's incoming p2p wire message.
rpc QueryMissionControl (, )
router.proto:81lncli: `querymc` QueryMissionControl exposes the internal mission control state to callers. It is a development feature.
message
router.proto:476(message has no fields)
message
router.proto:480QueryMissionControlResponse contains mission control state.
repeated pairs = 2
Node pair-level mission control state.
rpc QueryProbability (, )
router.proto:112lncli: `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.
message
router.proto:686bytes from_node = 1
The source node pubkey of the pair.
bytes to_node = 2
The destination node pubkey of the pair.
int64 amt_msat = 3
The amount for which to calculate a probability.
message
router.proto:697double probability = 1
The success probability for the requested pair.
optional history = 2
The historical data for the requested pair.
rpc ResetMissionControl (, )
router.proto:74lncli: `resetmc` ResetMissionControl clears all mission control state and starts with a clean slate.
message
router.proto:470(message has no fields)
message
router.proto:473(message has no fields)
rpc SendPaymentV2 (, stream )
router.proto:38lncli: `sendpayment` 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.
message
router.proto:191bytes dest = 1
The identity pubkey of the payment recipient
int64 amt = 2
Number of satoshis to send. The fields amt and amt_msat are mutually exclusive.
bytes payment_hash = 3
The hash to use within the payment's HTLC
int32 final_cltv_delta = 4
The CLTV delta from the current height that should be used to set the timelock for the final hop.
string payment_request = 5
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.
int32 timeout_seconds = 6
An optional limit, expressed in seconds, on the time to wait before attempting the first HTLC. Once HTLCs are in flight, the payment will not be aborted until the HTLCs are either settled or failed. If the field is not set or is explicitly set to zero, the default value of 60 seconds will be applied.
int64 fee_limit_sat = 7
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.
int32 cltv_limit = 9
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.
repeated route_hints = 10
Optional route hints to reach the destination through private channels.
map<uint64, bytes> dest_custom_records = 11
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.
int64 amt_msat = 12
Number of millisatoshis to send. The fields amt and amt_msat are mutually exclusive.
int64 fee_limit_msat = 13
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.
bytes last_hop_pubkey = 14
The pubkey of the last hop of the route. If empty, any hop may be used.
bool allow_self_payment = 15
If set, circular payments to self are permitted.
repeated lnrpc.FeatureBit dest_features = 16
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.
uint32 max_parts = 17
The maximum number of partial payments that may be use to complete the full amount.
bool no_inflight_updates = 18
If set, only the final payment update is streamed back. Intermediate updates that show which htlcs are still in flight are suppressed.
repeated uint64 outgoing_chan_ids = 19
The channel ids of the channels are allowed for the first hop. If empty, any channel may be used.
bytes payment_addr = 20
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).
uint64 max_shard_size_msat = 21
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.
bool amp = 22
If set, an AMP-payment will be attempted.
double time_pref = 23
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.
bool cancelable = 24
If set, the payment loop can be interrupted by manually canceling the payment context, even before the payment timeout is reached. Note that the payment may still succeed after cancellation, as in-flight attempts can still settle afterwards. Canceling will only prevent further attempts from being sent.
map<uint64, bytes> first_hop_custom_records = 25
An optional field that can be used to pass an arbitrary set of TLV records to the first hop peer of this payment. 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.
rpc SendToRouteV2 (, )
router.proto:68lncli: `sendtoroute` 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.
message
router.proto:445bytes payment_hash = 1
The payment hash to use for the HTLC.
optional route = 2
Route that should be used to attempt to complete the payment.
bool skip_temp_err = 3
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.
map<uint64, bytes> first_hop_custom_records = 4
An optional field that can be used to pass an arbitrary set of TLV records to the first hop peer of this payment. 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.
lncli: `setmccfg` SetMissionControlConfig will set mission control's config, if the config provided is valid.
message
router.proto:551optional config = 1
The config to set for mission control. Note that all values *must* be set, because the full config will be applied.
message
router.proto:559(message has no fields)
rpc SubscribeHtlcEvents (, stream )
router.proto:130SubscribeHtlcEvents creates a uni-directional stream from the server to the client which delivers a stream of htlc events.
message
router.proto:753(message has no fields)
message
router.proto:764HtlcEvent contains the htlc event that was processed. These are served on a best-effort basis; events are not persisted, delivery is not guaranteed (in the event of a crash in the switch, forward events may be lost) and some events may be replayed upon restart. Events consumed from this package should be de-duplicated by the htlc's unique combination of incoming and outgoing channel id and htlc id. [EXPERIMENTAL]
uint64 incoming_channel_id = 1
The short channel id that the incoming htlc arrived at our node on. This value is zero for sends.
uint64 outgoing_channel_id = 2
The short channel id that the outgoing htlc left our node on. This value is zero for receives.
uint64 incoming_htlc_id = 3
Incoming id is the index of the incoming htlc in the incoming channel. This value is zero for sends.
uint64 outgoing_htlc_id = 4
Outgoing id is the index of the outgoing htlc in the outgoing channel. This value is zero for receives.
uint64 timestamp_ns = 5
The time in unix nanoseconds that the event occurred.
HtlcEvent.EventType event_type = 6
The event type indicates whether the htlc was part of a send, receive or forward.
oneof event
forward_event = 7
forward_fail_event = 8
settle_event = 9
link_fail_event = 10
subscribed_event = 11
final_htlc_event = 12
rpc TrackPaymentV2 (, stream )
router.proto:44lncli: `trackpayment` TrackPaymentV2 returns an update stream for the payment identified by the payment hash.
message
router.proto:359bytes payment_hash = 1
The hash of the payment to look up.
bool no_inflight_updates = 2
If set, only the final payment update is streamed back. Intermediate updates that show which htlcs are still in flight are suppressed.
rpc TrackPayments (, stream )
router.proto:54TrackPayments 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.
message
router.proto:370bool no_inflight_updates = 1
If set, only the final payment updates are streamed back. Intermediate updates that show which htlcs are still in flight are suppressed.
rpc UpdateChanStatus (, )
router.proto:149lncli: `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".
message
router.proto:1039optional chan_point = 1
ChanStatusAction action = 2
message
router.proto:1051(message has no fields)
rpc XAddLocalChanAliases (, )
router.proto:160XAddLocalChanAliases is an experimental API that creates a set of new channel SCID alias mappings. The final total set of aliases in the manager after the add operation is returned. This is only a locally stored alias, and will not be communicated to the channel peer via any message. Therefore, routing over such an alias will only work if the peer also calls this same RPC on their end. If an alias already exists, an error is returned
message
router.proto:1054repeated alias_maps = 1
message
router.proto:1058repeated alias_maps = 1
XDeleteLocalChanAliases is an experimental API that deletes a set of alias mappings. The final total set of aliases in the manager after the delete operation is returned. The deletion will not be communicated to the channel peer via any message.
message
router.proto:1062repeated alias_maps = 1
message
router.proto:1066repeated alias_maps = 1
XFindBaseLocalChanAlias is an experimental API that looks up the base scid for a local chan alias that was registered during the current runtime.
message
router.proto:1070uint64 alias = 1
The alias we want to look up the base scid for.
message
router.proto:1075uint64 base = 1
The base scid that resulted from the base scid look up.
rpc XImportMissionControl (, )
router.proto:90lncli: `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.
message
router.proto:487repeated pairs = 1
Node pair-level mission control state to be imported.
bool force = 2
Whether to force override MC pair history. Note that even with force override the failure pair is imported before the success pair and both still clamp existing failure/success amounts.
message
router.proto:497(message has no fields)
message
router.proto:649Used in:
uint64 half_life_seconds = 1
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.
double hop_probability = 2
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.
double weight = 3
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.
double capacity_fraction = 4
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].
message
router.proto:622Used in:
double node_weight = 1
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.
uint64 scale_msat = 2
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.
uint64 decay_time = 3
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.
Used in:
ENABLE = 0
DISABLE = 1
AUTO = 2
message
router.proto:901Used in: ,
uint64 chan_id = 1
/ The id of the channel that the is part of this circuit.
uint64 htlc_id = 2
/ The index of the incoming htlc in the incoming channel.
Used in:
UNKNOWN = 0
NO_DETAIL = 1
ONION_DECODE = 2
LINK_NOT_ELIGIBLE = 3
ON_CHAIN_TIMEOUT = 4
HTLC_EXCEEDS_MAX = 5
INSUFFICIENT_BALANCE = 6
INCOMPLETE_FORWARD = 7
HTLC_ADD_FAILED = 8
FORWARDS_DISABLED = 9
INVOICE_CANCELED = 10
INVOICE_UNDERPAID = 11
INVOICE_EXPIRY_TOO_SOON = 12
INVOICE_NOT_OPEN = 13
MPP_INVOICE_TIMEOUT = 14
ADDRESS_MISMATCH = 15
SET_TOTAL_MISMATCH = 16
SET_TOTAL_TOO_LOW = 17
SET_OVERPAID = 18
UNKNOWN_INVOICE = 19
INVALID_KEYSEND = 20
MPP_IN_PROGRESS = 21
CIRCULAR_ROUTE = 22
INVOICE_ALREADY_SETTLED = 23
HTLC_INVOICE_TYPE_MISMATCH = 24
AMP_ERROR = 25
AMP_RECONSTRUCTION = 26
EXTERNAL_VALIDATION_FAILED = 27
message
router.proto:844Used in:
bool settled = 1
bool offchain = 2
message
router.proto:831Used in:
optional info = 1
Info contains details about the htlc that was forwarded.
message
router.proto:836Used in:
(message has no fields)
Used in:
UNKNOWN = 0
SEND = 1
RECEIVE = 2
FORWARD = 3
message
router.proto:817Used in: ,
uint32 incoming_timelock = 1
The timelock on the incoming htlc.
uint32 outgoing_timelock = 2
The timelock on the outgoing htlc.
uint64 incoming_amt_msat = 3
The amount of the incoming htlc.
uint64 outgoing_amt_msat = 4
The amount of the outgoing htlc.
message
router.proto:852Used in:
optional info = 1
Info contains details about the htlc that we failed.
lnrpc.Failure.FailureCode wire_failure = 2
FailureCode is the BOLT error code for the failure.
FailureDetail failure_detail = 3
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.
string failure_string = 4
A string representation of the link failure.
message
router.proto:562Used in: ,
uint64 half_life_seconds = 1
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.
float hop_probability = 2
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.
float weight = 3
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.
uint32 maximum_payment_results = 4
The maximum number of payment results that mission control will store.
uint64 minimum_failure_relax_interval = 5
The minimum time that must have passed since the previously recorded failure before we raise the failure amount.
MissionControlConfig.ProbabilityModel model = 6
ProbabilityModel defines which probability estimator should be used in pathfinding. Note that the bimodal estimator is experimental.
oneof EstimatorConfig
EstimatorConfig is populated dependent on the estimator type.
apriori = 7
bimodal = 8
Used in:
APRIORI = 0
BIMODAL = 1
message
router.proto:513Used in: ,
int64 fail_time = 1
Time of last failure.
int64 fail_amt_sat = 2
Lowest amount that failed to forward rounded to whole sats. This may be set to zero if the failure is independent of amount.
int64 fail_amt_msat = 4
Lowest amount that failed to forward in millisats. This may be set to zero if the failure is independent of amount.
int64 success_time = 5
Time of last success.
int64 success_amt_sat = 6
Highest amount that we could successfully forward rounded to whole sats.
int64 success_amt_msat = 7
Highest amount that we could successfully forward in millisats.
message
router.proto:501PairHistory contains the mission control state for a particular node pair.
Used in: ,
bytes node_from = 1
The source node pubkey of the pair.
bytes node_to = 2
The destination node pubkey of the pair.
optional history = 7
Used in:
SETTLE = 0
SETTLE is an action that is used to settle an HTLC instead of forwarding it.
FAIL = 1
FAIL is an action that is used to fail an HTLC backwards.
RESUME = 2
RESUME is an action that is used to resume a forward HTLC.
RESUME_MODIFIED = 3
RESUME_MODIFIED is an action that is used to resume a hold forward HTLC with modifications specified during interception.
message
router.proto:839Used in:
bytes preimage = 1
The revealed preimage.
message
router.proto:849Used in:
(message has no fields)