aljaz/electronwall
1
1
Fork 0
mirror of https://github.com/callebtc/electronwall.git synced 2026-02-11 10:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

htlc interceptor works

Browse Source
This commit is contained in:
callebtc
2022-07-08 12:05:01 +02:00
parent 4cd3bc9d6a
commit ab0edab364
3 changed files with 23 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
channelAcceptor.go
View File

@@ -60,7 +60,7 @@ func dispatchChannelAcceptor(ctx context.Context, conn *grpc.ClientConn, client
}
} else {
log.Infof("❌ [%s mode] Deny channel from %s", Configuration.Mode, trimPubKey(req.NodePubkey))
log.Infof("❌ [%s mode] Reject channel from %s", Configuration.Mode, trimPubKey(req.NodePubkey))
res = lnrpc.ChannelAcceptResponse{Accept: false,
Error: Configuration.RejectMessage}
}

96
htlcInterceptor.go
View File

@@ -1,79 +1,10 @@
package main
import (
"context"
"encoding/hex"
"sync"
"github.com/lightningnetwork/lnd/lnrpc"
"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
log "github.com/sirupsen/logrus"
"google.golang.org/grpc"
)
func dispatchHTLCInterceptor(ctx context.Context, conn *grpc.ClientConn) {
// wait group for channel acceptor
defer ctx.Value(ctxKeyWaitGroup).(*sync.WaitGroup).Done()
// get the lnd grpc connection
client := lnrpc.NewLightningClient(conn)
acceptClient, err := client.ChannelAcceptor(ctx)
if err != nil {
panic(err)
}
log.Infof("Listening for incoming channel requests")
for {
req := lnrpc.ChannelAcceptRequest{}
err = acceptClient.RecvMsg(&req)
if err != nil {
log.Errorf(err.Error())
}
log.Infof("New channel request from %s", hex.EncodeToString(req.NodePubkey))
var accept bool
if Configuration.Mode == "whitelist" {
accept = false
for _, pubkey := range Configuration.Whitelist {
if hex.EncodeToString(req.NodePubkey) == pubkey {
accept = true
break
}
}
} else if Configuration.Mode == "blacklist" {
accept = true
for _, pubkey := range Configuration.Blacklist {
if hex.EncodeToString(req.NodePubkey) == pubkey {
accept = false
break
}
}
}
res := lnrpc.ChannelAcceptResponse{}
if accept {
log.Infof("✅ [%s mode] Allow channel from %s", Configuration.Mode, trimPubKey(req.NodePubkey))
res = lnrpc.ChannelAcceptResponse{Accept: true,
PendingChanId: req.PendingChanId,
CsvDelay: req.CsvDelay,
MaxHtlcCount: req.MaxAcceptedHtlcs,
ReserveSat: req.ChannelReserve,
InFlightMaxMsat: req.MaxValueInFlight,
MinHtlcIn: req.MinHtlc,
}
} else {
log.Infof("❌ [%s mode] Deny channel from %s", Configuration.Mode, trimPubKey(req.NodePubkey))
res = lnrpc.ChannelAcceptResponse{Accept: false,
Error: Configuration.RejectMessage}
}
err = acceptClient.Send(&res)
if err != nil {
log.Errorf(err.Error())
}
}
}
func processHtlcEvents(stream routerrpc.Router_SubscribeHtlcEventsClient) error {
for {
event, err := stream.Recv()
@@ -87,10 +18,10 @@ func processHtlcEvents(stream routerrpc.Router_SubscribeHtlcEventsClient) error
switch event.Event.(type) {
case *routerrpc.HtlcEvent_SettleEvent:
log.Infof("Settle %s %s", event.IncomingChannelId, event.IncomingHtlcId)
log.Infof("Event: Settle %d %d", event.IncomingChannelId, event.IncomingHtlcId)
case *routerrpc.HtlcEvent_ForwardFailEvent:
log.Infof("ForwardFail %s %s", event.IncomingChannelId, event.IncomingHtlcId)
log.Infof("Event: ForwardFail %d %d", event.IncomingChannelId, event.IncomingHtlcId)
}
}
}
@@ -102,30 +33,17 @@ func processInterceptor(interceptor routerrpc.Router_HtlcInterceptorClient) erro
return err
}
// resumeChan := make(chan bool)
print("I'm here")
// p.interceptChan <- interceptEvent{
// circuitKey: circuitKey{
// channel: event.IncomingCircuitKey.ChanId,
// htlc: event.IncomingCircuitKey.HtlcId,
// },
// valueMsat: int64(event.OutgoingAmountMsat),
// resume: resumeChan,
// }
// resume, ok := <-resumeChan
// if !ok {
// return errors.New("resume channel closed")
// }
resume := true
// decision for routing
accept := false
response := &routerrpc.ForwardHtlcInterceptResponse{
IncomingCircuitKey: event.IncomingCircuitKey,
}
if resume {
if accept {
log.Infof("✅ Accept HTLC (%d sat, %s)", event.IncomingAmountMsat/1000, event.IncomingCircuitKey.String())
response.Action = routerrpc.ResolveHoldForwardAction_RESUME
} else {
log.Infof("❌ Reject HTLC (%d sat, %s)", event.IncomingAmountMsat/1000, event.IncomingCircuitKey.String())
response.Action = routerrpc.ResolveHoldForwardAction_FAIL
}

28
main.go
View File

@@ -60,30 +60,24 @@ func trimPubKey(pubkey []byte) string {
func main() {
ctx := context.Background()
// conn, err := getClientConnection(ctx)
// if err != nil {
// panic(err)
// }
conn, err := getClientConnection(ctx)
if err != nil {
panic(err)
}
var wg sync.WaitGroup
ctx = context.WithValue(ctx, ctxKeyWaitGroup, &wg)
wg.Add(1)
// client := lnrpc.NewLightningClient(conn)
// channel acceptor
// go dispatchChannelAcceptor(ctx, conn, client)
// htlc interceptor
var router routerrpc.RouterClient
// htlc event subscriber, reports on incoming htlc events
router := routerrpc.NewRouterClient(conn)
stream, err := router.SubscribeHtlcEvents(ctx, &routerrpc.SubscribeHtlcEventsRequest{})
if err != nil {
return
}
interceptor, err := router.HtlcInterceptor(ctx)
if err != nil {
return
}
log.Info("HTLC Interceptor registered")
go func() {
err := processHtlcEvents(stream)
@@ -93,6 +87,14 @@ func main() {
}
}()
// interceptor, decide whether to accept or reject
interceptor, err := router.HtlcInterceptor(ctx)
if err != nil {
return
}
log.Info("HTLC Interceptor registered")
go func() {
err := processInterceptor(interceptor)
if err != nil {