lnd.xprv/lnrpc/routerrpc/subscribe_events.go

242 lines
6.3 KiB
Go

// +build routerrpc
package routerrpc
import (
"fmt"
"time"
"github.com/lightningnetwork/lnd/htlcswitch"
"github.com/lightningnetwork/lnd/invoices"
"github.com/lightningnetwork/lnd/lnrpc"
)
// rpcHtlcEvent returns a rpc htlc event from a htlcswitch event.
func rpcHtlcEvent(htlcEvent interface{}) (*HtlcEvent, error) {
var (
key htlcswitch.HtlcKey
timestamp time.Time
eventType htlcswitch.HtlcEventType
event isHtlcEvent_Event
)
switch e := htlcEvent.(type) {
case *htlcswitch.ForwardingEvent:
event = &HtlcEvent_ForwardEvent{
ForwardEvent: &ForwardEvent{
Info: rpcInfo(e.HtlcInfo),
},
}
key = e.HtlcKey
eventType = e.HtlcEventType
timestamp = e.Timestamp
case *htlcswitch.ForwardingFailEvent:
event = &HtlcEvent_ForwardFailEvent{
ForwardFailEvent: &ForwardFailEvent{},
}
key = e.HtlcKey
eventType = e.HtlcEventType
timestamp = e.Timestamp
case *htlcswitch.LinkFailEvent:
failureCode, failReason, err := rpcFailReason(
e.LinkError,
)
if err != nil {
return nil, err
}
event = &HtlcEvent_LinkFailEvent{
LinkFailEvent: &LinkFailEvent{
Info: rpcInfo(e.HtlcInfo),
WireFailure: failureCode,
FailureDetail: failReason,
FailureString: e.LinkError.Error(),
},
}
key = e.HtlcKey
eventType = e.HtlcEventType
timestamp = e.Timestamp
case *htlcswitch.SettleEvent:
event = &HtlcEvent_SettleEvent{
SettleEvent: &SettleEvent{},
}
key = e.HtlcKey
eventType = e.HtlcEventType
timestamp = e.Timestamp
default:
return nil, fmt.Errorf("unknown event type: %T", e)
}
rpcEvent := &HtlcEvent{
IncomingChannelId: key.IncomingCircuit.ChanID.ToUint64(),
OutgoingChannelId: key.OutgoingCircuit.ChanID.ToUint64(),
IncomingHtlcId: key.IncomingCircuit.HtlcID,
OutgoingHtlcId: key.OutgoingCircuit.HtlcID,
TimestampNs: uint64(timestamp.UnixNano()),
Event: event,
}
// Convert the htlc event type to a rpc event.
switch eventType {
case htlcswitch.HtlcEventTypeSend:
rpcEvent.EventType = HtlcEvent_SEND
case htlcswitch.HtlcEventTypeReceive:
rpcEvent.EventType = HtlcEvent_RECEIVE
case htlcswitch.HtlcEventTypeForward:
rpcEvent.EventType = HtlcEvent_FORWARD
default:
return nil, fmt.Errorf("unknown event type: %v", eventType)
}
return rpcEvent, nil
}
// rpcInfo returns a rpc struct containing the htlc information from the
// switch's htlc info struct.
func rpcInfo(info htlcswitch.HtlcInfo) *HtlcInfo {
return &HtlcInfo{
IncomingTimelock: info.IncomingTimeLock,
OutgoingTimelock: info.OutgoingTimeLock,
IncomingAmtMsat: uint64(info.IncomingAmt),
OutgoingAmtMsat: uint64(info.OutgoingAmt),
}
}
// rpcFailReason maps a lnwire failure message and failure detail to a rpc
// failure code and detail.
func rpcFailReason(linkErr *htlcswitch.LinkError) (lnrpc.Failure_FailureCode,
FailureDetail, error) {
wireErr, err := marshallError(linkErr)
if err != nil {
return 0, 0, err
}
switch failureDetail := linkErr.FailureDetail.(type) {
case invoices.FailResolutionResult:
fd, err := rpcFailureResolution(failureDetail)
return wireErr.GetCode(), fd, err
case htlcswitch.OutgoingFailure:
fd, err := rpcOutgoingFailure(failureDetail)
return wireErr.GetCode(), fd, err
default:
return 0, 0, fmt.Errorf("unknown failure "+
"detail type: %T", linkErr.FailureDetail)
}
}
// rpcFailureResolution maps an invoice failure resolution to a rpc failure
// detail. Invoice failures have no zero resolution results (every failure
// is accompanied with a result), so we error if we fail to match the result
// type.
func rpcFailureResolution(invoiceFailure invoices.FailResolutionResult) (
FailureDetail, error) {
switch invoiceFailure {
case invoices.ResultReplayToCanceled:
return FailureDetail_INVOICE_CANCELED, nil
case invoices.ResultInvoiceAlreadyCanceled:
return FailureDetail_INVOICE_CANCELED, nil
case invoices.ResultAmountTooLow:
return FailureDetail_INVOICE_UNDERPAID, nil
case invoices.ResultExpiryTooSoon:
return FailureDetail_INVOICE_EXPIRY_TOO_SOON, nil
case invoices.ResultCanceled:
return FailureDetail_INVOICE_CANCELED, nil
case invoices.ResultInvoiceNotOpen:
return FailureDetail_INVOICE_NOT_OPEN, nil
case invoices.ResultMppTimeout:
return FailureDetail_MPP_INVOICE_TIMEOUT, nil
case invoices.ResultAddressMismatch:
return FailureDetail_ADDRESS_MISMATCH, nil
case invoices.ResultHtlcSetTotalMismatch:
return FailureDetail_SET_TOTAL_MISMATCH, nil
case invoices.ResultHtlcSetTotalTooLow:
return FailureDetail_SET_TOTAL_TOO_LOW, nil
case invoices.ResultHtlcSetOverpayment:
return FailureDetail_SET_OVERPAID, nil
case invoices.ResultInvoiceNotFound:
return FailureDetail_UNKNOWN_INVOICE, nil
case invoices.ResultKeySendError:
return FailureDetail_INVALID_KEYSEND, nil
case invoices.ResultMppInProgress:
return FailureDetail_MPP_IN_PROGRESS, nil
default:
return 0, fmt.Errorf("unknown fail resolution: %v",
invoiceFailure.FailureString())
}
}
// rpcOutgoingFailure maps an outgoing failure to a rpc FailureDetail. If the
// failure detail is FailureDetailNone, which indicates that the failure was
// a wire message which required no further failure detail, we return a no
// detail failure detail to indicate that there was no additional information.
func rpcOutgoingFailure(failureDetail htlcswitch.OutgoingFailure) (
FailureDetail, error) {
switch failureDetail {
case htlcswitch.OutgoingFailureNone:
return FailureDetail_NO_DETAIL, nil
case htlcswitch.OutgoingFailureDecodeError:
return FailureDetail_ONION_DECODE, nil
case htlcswitch.OutgoingFailureLinkNotEligible:
return FailureDetail_LINK_NOT_ELIGIBLE, nil
case htlcswitch.OutgoingFailureOnChainTimeout:
return FailureDetail_ON_CHAIN_TIMEOUT, nil
case htlcswitch.OutgoingFailureHTLCExceedsMax:
return FailureDetail_HTLC_EXCEEDS_MAX, nil
case htlcswitch.OutgoingFailureInsufficientBalance:
return FailureDetail_INSUFFICIENT_BALANCE, nil
case htlcswitch.OutgoingFailureCircularRoute:
return FailureDetail_CIRCULAR_ROUTE, nil
case htlcswitch.OutgoingFailureIncompleteForward:
return FailureDetail_INCOMPLETE_FORWARD, nil
case htlcswitch.OutgoingFailureDownstreamHtlcAdd:
return FailureDetail_HTLC_ADD_FAILED, nil
case htlcswitch.OutgoingFailureForwardsDisabled:
return FailureDetail_FORWARDS_DISABLED, nil
default:
return 0, fmt.Errorf("unknown outgoing failure "+
"detail: %v", failureDetail.FailureString())
}
}