From 2aa93fd882a8bc2376a9a95dddcda04dd8340b06 Mon Sep 17 00:00:00 2001 From: Yang Yang Date: Thu, 8 Oct 2020 16:40:26 +0800 Subject: [PATCH] feat: add status API (#1) * tmp * boltz done * arby done * webui done * connext done * geth native done * geth done * xud done * switch to gin * load lnd.conf from filesystem * lnd mostly done * lnd done * add socket.io * remove hardcoded testnet * fix xud ports * excludes bitcoind, litecoind, geth, boltz on simnet * add xud tradinglimits * disabled status * gin 404 405 * fix bitcoind status syncing * fetch status in parallel * add since and tail * return service logs as attachment * unlock with lncli * fix litecoind status * use xucli connext status --- .dockerignore | 1 + Dockerfile | 11 +- cmd/proxy/main.go | 198 + cmd/proxy/manager.go | 349 + go.mod | 25 +- go.sum | 158 +- main.go | 117 - scripts/run.sh | 17 + service/abstract_service.go | 53 + service/arby/arby.go | 30 + service/bitcoind/bitcoind.go | 150 + service/bitcoind/jsonrpc.go | 23 + service/boltz/boltz.go | 77 + service/connext/connext.go | 58 + service/container.go | 175 + service/docker.go | 44 + service/geth/geth.go | 295 + service/interface.go | 17 + service/litecoind/litecoind.go | 19 + service/lnd/lnd.go | 241 + service/lnd/lnrpc/rpc.pb.go | 16136 ++++++++++++++++ service/lnd/proto/rpc.proto | 3599 ++++ service/rpc.go | 47 + service/single_container_service.go | 115 + service/webui/webui.go | 32 + .../xud/proto}/annotations.proto | 0 .../xud/proto}/google/api/http.proto | 0 .../proto}/google/protobuf/descriptor.proto | 0 {proto => service/xud/proto}/xudrpc.proto | 0 service/xud/xud.go | 267 + {xudrpc => service/xud/xudrpc}/xudrpc.pb.go | 0 utils/utils.go | 13 + xud.go | 94 - 33 files changed, 22141 insertions(+), 220 deletions(-) create mode 100644 .dockerignore create mode 100644 cmd/proxy/main.go create mode 100644 cmd/proxy/manager.go delete mode 100644 main.go create mode 100755 scripts/run.sh create mode 100644 service/abstract_service.go create mode 100644 service/arby/arby.go create mode 100644 service/bitcoind/bitcoind.go create mode 100644 service/bitcoind/jsonrpc.go create mode 100644 service/boltz/boltz.go create mode 100644 service/connext/connext.go create mode 100644 service/container.go create mode 100644 service/docker.go create mode 100644 service/geth/geth.go create mode 100644 service/interface.go create mode 100644 service/litecoind/litecoind.go create mode 100644 service/lnd/lnd.go create mode 100644 service/lnd/lnrpc/rpc.pb.go create mode 100644 service/lnd/proto/rpc.proto create mode 100644 service/rpc.go create mode 100644 service/single_container_service.go create mode 100644 service/webui/webui.go rename {proto => service/xud/proto}/annotations.proto (100%) rename {proto => service/xud/proto}/google/api/http.proto (100%) rename {proto => service/xud/proto}/google/protobuf/descriptor.proto (100%) rename {proto => service/xud/proto}/xudrpc.proto (100%) create mode 100644 service/xud/xud.go rename {xudrpc => service/xud/xudrpc}/xudrpc.pb.go (100%) create mode 100644 utils/utils.go delete mode 100644 xud.go diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..5093a29 --- /dev/null +++ b/.dockerignore @@ -0,0 +1 @@ +scripts/ diff --git a/Dockerfile b/Dockerfile index d5cfd38..f69bec2 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,8 +1,11 @@ -FROM golang:1.15.2-alpine3.12 as builder -ADD . github.com/ExchangeUnion/xud-docker-api-poc +FROM golang:1.15-alpine3.12 as builder WORKDIR github.com/ExchangeUnion/xud-docker-api-poc -RUN go build +COPY go.mod . +COPY go.sum . +RUN go mod download +ADD . . +RUN go build ./cmd/proxy FROM alpine:3.12 -COPY --from=builder /go/github.com/ExchangeUnion/xud-docker-api-poc/xud-docker-api-poc /usr/local/bin/proxy +COPY --from=builder /go/github.com/ExchangeUnion/xud-docker-api-poc/proxy /usr/local/bin/proxy ENTRYPOINT ["proxy"] diff --git a/cmd/proxy/main.go b/cmd/proxy/main.go new file mode 100644 index 0000000..aa1eb27 --- /dev/null +++ b/cmd/proxy/main.go @@ -0,0 +1,198 @@ +package main + +import ( + "fmt" + "github.com/ExchangeUnion/xud-docker-api-poc/service/xud" + "github.com/gin-contrib/cors" + "github.com/gin-gonic/gin" + socketio "github.com/googollee/go-socket.io" + "github.com/googollee/go-socket.io/engineio" + "github.com/googollee/go-socket.io/engineio/transport" + polling2 "github.com/googollee/go-socket.io/engineio/transport/polling" + "github.com/googollee/go-socket.io/engineio/transport/websocket" + "github.com/joho/godotenv" + "github.com/sirupsen/logrus" + "github.com/urfave/cli/v2" + "log" + "net/http" + "os" + "strings" +) + +func main() { + logger := logrus.New() + + err := godotenv.Load("/root/config.sh") + if err != nil { + logger.Fatal("Failed to load /root/config.sh") + } + + var port int + //xudRpc := XudRpc{} + + app := &cli.App{ + Flags: []cli.Flag{ + &cli.StringFlag{ + Name: "xud.rpchost", + }, + &cli.IntFlag{ + Name: "xud.rpcport", + }, + &cli.StringFlag{ + Name: "xud.rpccert", + }, + &cli.IntFlag{ + Name: "port, p", + Value: 8080, + }, + }, + Action: func(c *cli.Context) error { + //xudRpc.Host = c.String("xud.rpchost") + //xudRpc.Port = c.Int("xud.rpcport") + //xudRpc.Cert = c.String("xud.rpccert") + port = c.Int("port") + return nil + }, + } + + logger.Info("Parsing command-line arguments") + err = app.Run(os.Args) + if err != nil { + log.Fatal(err) + } + + logger.Info("Creating service manager") + + network := os.Getenv("NETWORK") + + manager, err := NewManager(network) + if err != nil { + log.Fatal(err) + } + defer manager.Close() + + logger.Info("Creating router") + r := gin.Default() + + pt := polling2.Default + wt := websocket.Default + wt.CheckOrigin = func(r *http.Request) bool { + return true + } + + logger.Info("Configuring SocketIO") + server, err := socketio.NewServer(&engineio.Options{ + Transports: []transport.Transport{ + pt, + wt, + }, + }) + if err != nil { + log.Fatal(err) + } + server.OnConnect("/", func(s socketio.Conn) error { + s.SetContext("") + logger.Infof("[SocketIO] New client connected: ID=%v, RemoteAddr=%v", s.ID(), s.RemoteAddr()) + return nil + }) + server.OnError("/", func(s socketio.Conn, e error) { + logger.Errorf("[SocketIO] Client %v got an error: %v", s.ID(), e) + }) + server.OnDisconnect("/", func(s socketio.Conn, reason string) { + logger.Infof("[SocketIO] Client %v disconnected: %v", s.ID(), reason) + }) + server.OnEvent("/", "console", func(s socketio.Conn, msg string) { + logger.Infof("[CONSOLE] %s", msg) + + parts := strings.Split(msg, " ") + + switch parts[0] { + case "open": + s.Join("exec") + openConsole("xud", server, logger, manager) + // open console + case "close": + // close console + case "resize": + // resize console + } + }) + go server.Serve() + defer server.Close() + r.GET("/socket.io/", gin.WrapH(server)) + //r.POST("/socket.io/", gin.WrapH(server)) + r.Handle("WS", "/socket.io/", gin.WrapH(server)) + + // Configuring CORS + // - No origin allowed by default + // - GET,POST, PUT, HEAD methods + // - Credentials share disabled + // - Preflight requests cached for 12 hours + config := cors.DefaultConfig() + config.AllowOrigins = []string{"http://localhost:3000"} + + r.Use(cors.New(config)) + + r.NoRoute(func(c *gin.Context) { + c.JSON(404, gin.H{"message": "not found"}) + }) + r.NoMethod(func(c *gin.Context) { + c.JSON(405, gin.H{"message": "method not allowed"}) + }) + + logger.Info("Configuring router") + manager.ConfigureRouter(r) + + logger.Infof("Serving at :%d", port) + addr := fmt.Sprintf(":%d", port) + err = r.Run(addr) + if err != nil { + log.Fatal(err) + } + //err = http.ListenAndServe(addr, r) + //if err != nil { + // log.Fatal(err) + //} +} + +func openConsole(service string, server *socketio.Server, logger *logrus.Logger, manager *Manager) { + s, err := manager.GetService(service) + if err != nil { + log.Fatal(err) + } + ss, ok := s.(*xud.XudService) + if !ok { + log.Fatal("Failed to convert to SingleContainerService") + } + c, err := ss.SingleContainerService.GetContainer() + if err != nil { + log.Fatal(err) + } + execId, reader, writer, err := c.ExecInteractive([]string{"bash"}) + if err != nil { + log.Fatal(err) + } + logger.Infof("Created execId %v", execId) + + server.OnEvent("/", "input", func(s socketio.Conn, msg string) { + logger.Infof("[INPUT] %v", msg) + _, err = writer.Write([]byte(msg)) + if err != nil { + logger.Errorf("Failed to write: %v", err) + } + }) + + go func() { + buf := make([]byte, 1024) + for { + n, err := reader.Read(buf) + if err != nil { + logger.Errorf("Failed to read: %v", err) + break + } else { + logger.Infof("Read %d bytes: %v", n, buf[:n]) + } + server.BroadcastToRoom("/", "exec", "output", string(buf[:n])) + } + }() +} diff --git a/cmd/proxy/manager.go b/cmd/proxy/manager.go new file mode 100644 index 0000000..b0d1592 --- /dev/null +++ b/cmd/proxy/manager.go @@ -0,0 +1,349 @@ +package main + +import ( + "errors" + "fmt" + . "github.com/ExchangeUnion/xud-docker-api-poc/service" + "github.com/ExchangeUnion/xud-docker-api-poc/service/arby" + "github.com/ExchangeUnion/xud-docker-api-poc/service/bitcoind" + "github.com/ExchangeUnion/xud-docker-api-poc/service/boltz" + "github.com/ExchangeUnion/xud-docker-api-poc/service/connext" + "github.com/ExchangeUnion/xud-docker-api-poc/service/geth" + "github.com/ExchangeUnion/xud-docker-api-poc/service/litecoind" + "github.com/ExchangeUnion/xud-docker-api-poc/service/lnd" + "github.com/ExchangeUnion/xud-docker-api-poc/service/webui" + "github.com/ExchangeUnion/xud-docker-api-poc/service/xud" + "github.com/ExchangeUnion/xud-docker-api-poc/utils" + "github.com/gin-gonic/gin" + "net/http" +) + +type Manager struct { + network string + services []Service + optionalServices []string +} + +func containerName(network string, service string) string { + return fmt.Sprintf("%s_%s_1", network, service) +} + +func NewManager(network string) (*Manager, error) { + lightProviders := map[string][]string{ + "testnet": { + "http://eth.kilrau.com:52041", + "http://michael1011.at:8546", + "http://gethxudxv2k4pv5t5a5lswq2hcv3icmj3uwg7m2n2vuykiyv77legiad.onion:8546", + }, + "mainnet": { + "http://eth.kilrau.com:41007", + "http://michael1011.at:8545", + "http://gethxudxv2k4pv5t5a5lswq2hcv3icmj3uwg7m2n2vuykiyv77legiad.onion:8545", + }, + } + + xudSvc := xud.New("xud", containerName(network, "xud")) + + lndbtcSvc, err := lnd.New("lndbtc", containerName(network, "lndbtc"), "bitcoin") + if err != nil { + return nil, err + } + + lndltcSvc, err := lnd.New("lndltc", containerName(network, "lndltc"), "litecoin") + if err != nil { + return nil, err + } + + connextSvc := connext.New("connext", containerName(network, "connext")) + + bitcoindSvc := bitcoind.New("bitcoind", containerName(network, "bitcoind"), "lndbtc") + litecoindSvc := litecoind.New("litecoind", containerName(network, "litecoind"), "lndltc") + gethSvc := geth.New("geth", containerName(network, "geth"), "connext", lightProviders[network]) + + arbySvc := arby.New("arby", containerName(network, "arby")) + boltzSvc := boltz.New("boltz", containerName(network, "boltz")) + webuiSvc := webui.New("webui", containerName(network, "webui")) + + var services []Service + var optionalServices []string + + if network == "simnet" { + services = []Service{ + lndbtcSvc, + lndltcSvc, + connextSvc, + xudSvc, + arbySvc, + webuiSvc, + } + optionalServices = []string{ + "arby", + "webui", + } + } else { + services = []Service{ + bitcoindSvc, + litecoindSvc, + gethSvc, + lndbtcSvc, + lndltcSvc, + connextSvc, + xudSvc, + arbySvc, + boltzSvc, + webuiSvc, + } + optionalServices = []string{ + "arby", + "boltz", + "webui", + } + } + + manager := Manager{ + network: network, + services: services, + optionalServices: optionalServices, + } + + dockerClientFactory, err := NewClientFactory() + if err != nil { + return nil, err + } + + xudSvc.SetServiceManager(&manager) + xudSvc.SetDockerClientFactory(dockerClientFactory) + + var xudRpcPort int16 + var bitcoindRpcPort int16 + var litecoindRpcPort int16 + + if network == "simnet" { + xudRpcPort = 28886 + bitcoindRpcPort = 28332 + litecoindRpcPort = 29332 + } else if network == "testnet" { + xudRpcPort = 18886 + bitcoindRpcPort = 18332 + litecoindRpcPort = 19332 + } else if network == "mainnet" { + xudRpcPort = 8886 + bitcoindRpcPort = 8332 + litecoindRpcPort = 9332 + } + + xudRpc := RpcOptions{ + Host: "xud", + Port: xudRpcPort, + TlsCert: "/root/.xud/tls.cert", + } + xudSvc.ConfigureRpc(&xudRpc) + + lndbtcSvc.SetServiceManager(&manager) + lndbtcSvc.SetDockerClientFactory(dockerClientFactory) + lndbtcRpc := RpcOptions{ + Host: "lndbtc", + Port: 10009, + TlsCert: "/root/.lndbtc/tls.cert", + Credential: MacaroonCredential{ + Readonly: fmt.Sprintf("/root/.lndbtc/data/chain/bitcoin/%s/readonly.macaroon", network), + }, + } + lndbtcSvc.ConfigureRpc(&lndbtcRpc) + + lndltcSvc.SetServiceManager(&manager) + lndltcSvc.SetDockerClientFactory(dockerClientFactory) + lndltcRpc := RpcOptions{ + Host: "lndltc", + Port: 10009, + TlsCert: "/root/.lndltc/tls.cert", + Credential: MacaroonCredential{ + Readonly: fmt.Sprintf("/root/.lndltc/data/chain/litecoin/%s/readonly.macaroon", network), + }, + } + lndltcSvc.ConfigureRpc(&lndltcRpc) + + connextSvc.SetServiceManager(&manager) + connextSvc.SetDockerClientFactory(dockerClientFactory) + + if network != "simnet" { + bitcoindSvc.SetServiceManager(&manager) + bitcoindSvc.SetDockerClientFactory(dockerClientFactory) + bitcoindRpc := RpcOptions{ + Host: "bitcoind", + Port: bitcoindRpcPort, + Credential: UsernamePasswordCredential{ + Username: "xu", + Password: "xu", + }, + } + bitcoindSvc.ConfigureRpc(&bitcoindRpc) + } + + if network != "simnet" { + litecoindSvc.SetServiceManager(&manager) + litecoindSvc.SetDockerClientFactory(dockerClientFactory) + litecoindRpc := RpcOptions{ + Host: "litecoind", + Port: litecoindRpcPort, + Credential: UsernamePasswordCredential{ + Username: "xu", + Password: "xu", + }, + } + litecoindSvc.ConfigureRpc(&litecoindRpc) + } + + if network != "simnet" { + gethSvc.SetServiceManager(&manager) + gethSvc.SetDockerClientFactory(dockerClientFactory) + gethRpc := RpcOptions{ + Host: "geth", + Port: 8545, + } + gethSvc.ConfigureRpc(&gethRpc) + } + + arbySvc.SetServiceManager(&manager) + arbySvc.SetDockerClientFactory(dockerClientFactory) + + if network != "simnet" { + boltzSvc.SetServiceManager(&manager) + boltzSvc.SetDockerClientFactory(dockerClientFactory) + } + + webuiSvc.SetServiceManager(&manager) + webuiSvc.SetDockerClientFactory(dockerClientFactory) + + return &manager, nil +} + +func (t *Manager) getServices() []Service { + return t.services +} + +type StatusResult struct { + Service string + Status string +} + +func (t *Manager) GetStatus() map[string]string { + result := map[string]string{} + ch := make(chan StatusResult) + for _, svc := range t.services { + s := svc + go func() { + status, err := s.GetStatus() + if err != nil { + status = fmt.Sprintf("Error: %s", err) + } + ch <- StatusResult{Service: s.GetName(), Status: status} + }() + } + + for i := 0; i < cap(t.services); i++ { + r := <-ch + result[r.Service] = r.Status + } + + return result +} + +func (t *Manager) GetService(name string) (Service, error) { + for _, svc := range t.services { + if svc.GetName() == name { + return svc, nil + } + } + return nil, errors.New("service not found: " + name) +} + +type ServiceEntry struct { + Id string `json:"id"` + Name string `json:"name"` +} + +type ServiceStatus struct { + Service string `json:"service"` + Status string `json:"status"` +} + +func (t *Manager) ConfigureRouter(r *gin.Engine) { + + r.GET("/api/v1/services", func(c *gin.Context) { + var result []ServiceEntry + + result = append(result, ServiceEntry{"xud", "XUD"}) + result = append(result, ServiceEntry{"lndbtc", "LND (Bitcoin)"}) + result = append(result, ServiceEntry{"lndltc", "LND (Litecoin)"}) + result = append(result, ServiceEntry{"connext", "Connext"}) + result = append(result, ServiceEntry{"bitcoind", "Bitcoind"}) + result = append(result, ServiceEntry{"litecoind", "Litecoind"}) + result = append(result, ServiceEntry{"geth", "Geth"}) + result = append(result, ServiceEntry{"arby", "Arby"}) + result = append(result, ServiceEntry{"boltz", "Boltz"}) + result = append(result, ServiceEntry{"webui", "Web UI"}) + + c.JSON(http.StatusOK, result) + }) + + r.GET("/api/v1/status", func(c *gin.Context) { + status := t.GetStatus() + + var result []ServiceStatus + + for _, svc := range t.services { + result = append(result, ServiceStatus{Service: svc.GetName(), Status: status[svc.GetName()]}) + } + + c.JSON(http.StatusOK, result) + }) + + r.GET("/api/v1/status/:service", func(c *gin.Context) { + service := c.Param("service") + s, err := t.GetService(service) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusNotFound) + return + } + status, err := s.GetStatus() + if err != nil { + status = fmt.Sprintf("Error: %s", err) + } + c.JSON(http.StatusOK, ServiceStatus{Service: service, Status: status}) + }) + + r.GET("/api/v1/logs/:service", func(c *gin.Context) { + service := c.Param("service") + s, err := t.GetService(service) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusNotFound) + return + } + since := c.DefaultQuery("since", "1h") + tail := c.DefaultQuery("tail", "all") + logs, err := s.GetLogs(since, tail) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "text/plain") + c.Header("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s.log\"", service)) + for line := range logs { + _, err = c.Writer.WriteString(line + "\n") + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + } + } + }) + + for _, svc := range t.services { + svc.ConfigureRouter(r) + } +} + +func (t *Manager) Close() { + for _, svc := range t.services { + svc.Close() + } +} diff --git a/go.mod b/go.mod index 704b351..f574fea 100644 --- a/go.mod +++ b/go.mod @@ -3,10 +3,31 @@ module github.com/ExchangeUnion/xud-docker-api-poc go 1.15 require ( - github.com/golang/protobuf v1.4.1 - github.com/gorilla/mux v1.8.0 + github.com/Microsoft/go-winio v0.4.14 // indirect + github.com/docker/distribution v2.7.1+incompatible // indirect + github.com/docker/docker v1.13.1 + github.com/docker/go-connections v0.4.0 // indirect + github.com/docker/go-units v0.4.0 // indirect + github.com/gin-contrib/cors v1.3.1 // indirect + github.com/gin-gonic/gin v1.6.3 + github.com/go-playground/validator/v10 v10.3.0 // indirect + github.com/golang/protobuf v1.4.2 + github.com/googollee/go-socket.io v1.4.4 // indirect + github.com/joho/godotenv v1.3.0 // indirect + github.com/json-iterator/go v1.1.10 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.1 // indirect + github.com/onsi/gomega v1.10.2 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/sirupsen/logrus v1.6.0 + github.com/smartystreets/goconvey v1.6.4 // indirect + github.com/ugorji/go v1.1.8 // indirect github.com/urfave/cli/v2 v2.2.0 + github.com/ybbus/jsonrpc v2.1.2+incompatible + golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d // indirect google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 google.golang.org/grpc v1.32.0 google.golang.org/protobuf v1.25.0 + gopkg.in/ini.v1 v1.61.0 ) diff --git a/go.sum b/go.sum index 5419289..d64ca8c 100644 --- a/go.sum +++ b/go.sum @@ -1,14 +1,49 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/Microsoft/go-winio v0.4.14 h1:+hMXMk01us9KgxGb7ftKQt2Xpf5hH/yky+TDA+qxleU= +github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/docker/distribution v2.7.1+incompatible h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug= +github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= +github.com/docker/docker v1.13.1 h1:IkZjBSIc8hBjLpqeAbeE5mca5mNgeatLHBy3GO78BWo= +github.com/docker/docker v1.13.1/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ= +github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec= +github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw= +github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/gin-contrib/cors v1.3.1 h1:doAsuITavI4IOcd0Y19U4B+O0dNWihRyX//nn4sEmgA= +github.com/gin-contrib/cors v1.3.1/go.mod h1:jjEJ4268OPZUcU7k9Pm653S7lXUGcqMADzFA61xsmDk= +github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= +github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= +github.com/gin-gonic/gin v1.5.0/go.mod h1:Nd6IXA8m5kNZdNEHMBd93KT+mdY3+bewLgRvmCsR2Do= +github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14= +github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M= +github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A= +github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= +github.com/go-playground/locales v0.12.1/go.mod h1:IUMDtCfWo/w/mtMfIE/IG2K+Ey3ygWanZIBtBW0W2TM= +github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q= +github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= +github.com/go-playground/universal-translator v0.16.0/go.mod h1:1AnU7NaIRDWWzGEKwgtJRd2xk99HeFyHw3yid4rvQIY= +github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no= +github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= +github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY= +github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI= +github.com/go-playground/validator/v10 v10.3.0 h1:nZU+7q+yJoFmwvNgv/LnPUkwPal62+b2xXj0AU1Es7o= +github.com/go-playground/validator/v10 v10.3.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -22,22 +57,103 @@ github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:W github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= github.com/golang/protobuf v1.4.1 h1:ZFgWrT+bLgsYPirOnRfKLYJLvssAegOj/hgyMFdJZe0= github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w= github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= -github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/googollee/go-socket.io v1.4.4 h1:UWOy//wzcT1ENMDeeVsrXwcCY49XOvC/YHVMZJDfy9M= +github.com/googollee/go-socket.io v1.4.4/go.mod h1:2lMkHRm5GLg158lACi6Zj6535AQaXuyA+IKbfqKzTOM= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM= +github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc= +github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= +github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns= +github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68= +github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8= +github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/labstack/echo v3.3.10+incompatible/go.mod h1:0INS7j/VjnFxD4E2wkz67b8cVwCLbBmJyDaka6Cmk1s= +github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= +github.com/leodido/go-urn v1.1.0/go.mod h1:+cyI34gQWZcE1eQU7NVgKkkzdXDQHr1dBMtdAPozLkw= +github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= +github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= +github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1 h1:mFwc4LvZ0xpSvDZ3E+k8Yte0hLOMxXUlP+yXtJqkYfQ= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.2 h1:aY/nuoWlKJud2J6U0E3NWsjlg+0GtwXxgEqthRdzlcs= +github.com/onsi/gomega v1.10.2/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/urfave/cli v1.22.4 h1:u7tSpNPPswAFymm8IehJhy4uJMlUuU/GmqSkvJ1InXA= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= +github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I= +github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s= +github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo= +github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= +github.com/ugorji/go v1.1.8 h1:/D9x7IRpfMHDlizVOgxrag5Fh+/NY+LtI8bsr+AswRA= +github.com/ugorji/go v1.1.8/go.mod h1:0lNM99SwWUIRhCXnigEMClngXBk/EmpTXa7mgiewYWA= +github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs= +github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= +github.com/ugorji/go/codec v1.1.8 h1:4dryPvxMP9OtkjIbuNeK2nb27M38XMHLGlfNSNph/5s= +github.com/ugorji/go/codec v1.1.8/go.mod h1:X00B19HDtwvKbQY2DcYjvZxKQp8mzrJoQ6EgoIY/D2E= github.com/urfave/cli/v2 v2.2.0 h1:JTTnM6wKzdA0Jqodd966MVj4vWbbquZykeX1sKbe2C4= github.com/urfave/cli/v2 v2.2.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= +github.com/ybbus/jsonrpc v2.1.2+incompatible h1:V4mkE9qhbDQ92/MLMIhlhMSbz8jNXdagC3xBR5NDwaQ= +github.com/ybbus/jsonrpc v2.1.2+incompatible/go.mod h1:XJrh1eMSzdIYFbM08flv0wp5G35eRniyeGut1z+LSiE= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -45,22 +161,44 @@ golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvx golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7 h1:AeiKBIuRw3UomYXSbLy0Mc2dDLfdtbT/IVn4keq83P0= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b h1:ag/x1USPSsqHud38I9BAC88qdNLDHHtQ4mlgQIZPPNA= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d h1:L/IKR6COd7ubZrs2oTnTi73IhgqJ71c9s80WsQnh0Es= +golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -81,10 +219,24 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= +gopkg.in/go-playground/validator.v9 v9.29.1/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ= +gopkg.in/ini.v1 v1.61.0 h1:LBCdW4FmFYL4s/vDZD1RQYX7oAR6IjujCYgMdbHBR10= +gopkg.in/ini.v1 v1.61.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/main.go b/main.go deleted file mode 100644 index 0e6fe13..0000000 --- a/main.go +++ /dev/null @@ -1,117 +0,0 @@ -package main - -import ( - "encoding/json" - "fmt" - pb "github.com/ExchangeUnion/xud-docker-api-poc/xudrpc" - "github.com/gorilla/mux" - "google.golang.org/grpc" - "google.golang.org/grpc/credentials" - "log" - "net/http" - "os" - - "github.com/urfave/cli/v2" -) - -type XudRpc struct { - Host string - Port int - Cert string -} - -type Restful404Handler struct{} -type Restful405Handler struct{} - -func (Restful404Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "application/json; charset=utf-8") - w.Header().Set("X-Content-Type-Options", "nosniff") - w.WriteHeader(http.StatusNotFound) - err := json.NewEncoder(w).Encode(map[string]string{"message": "not found"}) - if err != nil { - http.Error(w, err.Error(), http.StatusInternalServerError) - } -} - -func (Restful405Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - w.Header().Set("Content-Type", "application/json; charset=utf-8") - w.Header().Set("X-Content-Type-Options", "nosniff") - w.WriteHeader(http.StatusMethodNotAllowed) - err := json.NewEncoder(w).Encode(map[string]string{"message": "method not allowed"}) - if err != nil { - http.Error(w, err.Error(), http.StatusInternalServerError) - } -} - -func main() { - var port int - xudRpc := XudRpc{} - - app := &cli.App{ - Flags: []cli.Flag{ - &cli.StringFlag{ - Name: "xud.rpchost", - }, - &cli.IntFlag{ - Name: "xud.rpcport", - }, - &cli.StringFlag{ - Name: "xud.rpccert", - }, - &cli.IntFlag{ - Name: "port, p", - Value: 8080, - }, - }, - Action: func(c *cli.Context) error { - xudRpc.Host = c.String("xud.rpchost") - xudRpc.Port = c.Int("xud.rpcport") - xudRpc.Cert = c.String("xud.rpccert") - port = c.Int("port") - return nil - }, - } - - err := app.Run(os.Args) - if err != nil { - log.Fatal(err) - } - - var opts []grpc.DialOption - - //creds, err := credentials.NewClientTLSFromFile("/root/.xud/tls.cert", "localhost") - //creds, err := credentials.NewClientTLSFromFile("/Users/yy/.xud-docker/simnet/data/xud/tls.cert", "") - creds, err := credentials.NewClientTLSFromFile(xudRpc.Cert, "localhost") - if err != nil { - log.Fatal(err) - } - - opts = append(opts, grpc.WithTransportCredentials(creds)) - opts = append(opts, grpc.WithBlock()) - //opts = append(opts, grpc.WithTimeout(time.Duration(10000))) - - //conn, err := grpc.Dial("xud:28886", opts...) - //conn, err := grpc.Dial("127.0.0.1:28886", opts...) - conn, err := grpc.Dial(fmt.Sprintf("%s:%d", xudRpc.Host, xudRpc.Port), opts...) - if err != nil { - log.Fatal(err) - } - defer conn.Close() - - client := pb.NewXudClient(conn) - - r := mux.NewRouter() - r.NotFoundHandler = Restful404Handler{} - r.MethodNotAllowedHandler = Restful405Handler{} - - xud := NewXudService(client) - - r.HandleFunc("/api/v1/xud/getinfo", xud.GetInfo).Methods("GET") - r.HandleFunc("/api/v1/xud/getbalance", xud.GetBalance).Methods("GET") - r.HandleFunc("/api/v1/xud/getbalance/{currency}", xud.GetBalance).Methods("GET") - r.HandleFunc("/api/v1/xud/tradehistory", xud.GetTradeHistory).Queries("limit", "{limit}").Methods("GET") - r.HandleFunc("/api/v1/xud/tradehistory", xud.GetTradeHistory).Methods("GET") - - addr := fmt.Sprintf(":%d", port) - log.Fatal(http.ListenAndServe(addr, r)) -} diff --git a/scripts/run.sh b/scripts/run.sh new file mode 100755 index 0000000..76711d5 --- /dev/null +++ b/scripts/run.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +set -euo pipefail + +NETWORK=${1:-testnet} + +docker build . -t proxy +docker run -it --rm --name proxy \ +-e "NETWORK=$NETWORK" \ +--net "${NETWORK}_default" \ +-p 8080:8080 \ +-v /var/run/docker.sock:/var/run/docker.sock \ +-v "$HOME/.xud-docker/$NETWORK/data/xud:/root/.xud" \ +-v "$HOME/.xud-docker/$NETWORK/data/lndbtc:/root/.lndbtc" \ +-v "$HOME/.xud-docker/$NETWORK/data/lndltc:/root/.lndltc" \ +-v "$HOME/.xud-docker/$NETWORK/logs/config.sh:/root/config.sh" \ +proxy \ No newline at end of file diff --git a/service/abstract_service.go b/service/abstract_service.go new file mode 100644 index 0000000..a65b54d --- /dev/null +++ b/service/abstract_service.go @@ -0,0 +1,53 @@ +package service + +import ( + "github.com/gin-gonic/gin" + "github.com/sirupsen/logrus" +) + +type AbstractService struct { + name string + serviceManager ServiceManager + logger *logrus.Logger +} + +func NewAbstractService(name string) *AbstractService { + return &AbstractService{ + name: name, + logger: logrus.New(), + } +} + +func (t *AbstractService) GetName() string { + return t.name +} + +func (t *AbstractService) GetStatus() (string, error) { + return "Unknown", nil +} + +func (t *AbstractService) ConfigureRouter(r *gin.Engine) { +} + +func (t *AbstractService) Close() { +} + +func (t *AbstractService) GetLogs(since string, tail string) (<-chan string, error) { + ch := make(chan string) + go func() { + close(ch) + }() + return ch, nil +} + +func (t *AbstractService) SetServiceManager(serviceManager ServiceManager) { + t.serviceManager = serviceManager +} + +func (t *AbstractService) GetServiceManager() ServiceManager { + return t.serviceManager +} + +func (t *AbstractService) GetLogger() *logrus.Logger { + return t.logger +} diff --git a/service/arby/arby.go b/service/arby/arby.go new file mode 100644 index 0000000..eadeb3b --- /dev/null +++ b/service/arby/arby.go @@ -0,0 +1,30 @@ +package arby + +import ( + "github.com/ExchangeUnion/xud-docker-api-poc/service" +) + +type ArbyService struct { + *service.SingleContainerService +} + +func New( + name string, + containerName string, +) *ArbyService { + return &ArbyService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + } +} + +func (t *ArbyService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + return "Ready", nil + } else { + return status, nil + } +} diff --git a/service/bitcoind/bitcoind.go b/service/bitcoind/bitcoind.go new file mode 100644 index 0000000..22f8217 --- /dev/null +++ b/service/bitcoind/bitcoind.go @@ -0,0 +1,150 @@ +package bitcoind + +import ( + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "github.com/ExchangeUnion/xud-docker-api-poc/service" + "github.com/ExchangeUnion/xud-docker-api-poc/service/lnd" + "github.com/ybbus/jsonrpc" +) + +type BitcoindService struct { + *service.SingleContainerService + rpcOptions *service.RpcOptions + rpcClient jsonrpc.RPCClient + l2ServiceName string +} + +type Mode string + +const ( + Native Mode = "native" + External Mode = "external" + Light Mode = "light" + Unknown Mode = "unknown" +) + +func New( + name string, + containerName string, + l2ServiceName string, +) *BitcoindService { + return &BitcoindService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + l2ServiceName: l2ServiceName, + } +} + +func (t *BitcoindService) ConfigureRpc(options *service.RpcOptions) { + t.rpcOptions = options +} + +func (t *BitcoindService) getRpcClient() jsonrpc.RPCClient { + if t.rpcClient == nil { + addr := fmt.Sprintf("http://%s:%d", t.rpcOptions.Host, t.rpcOptions.Port) + t.rpcClient = jsonrpc.NewClientWithOpts(addr, &jsonrpc.RPCClientOpts{ + CustomHeaders: map[string]string{ + "Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte("xu"+":"+"xu")), + }, + }) + } + return t.rpcClient +} + +func (t *BitcoindService) GetBlockchainInfo() (*jsonrpc.RPCResponse, error) { + client := t.getRpcClient() + response, err := client.Call("getblockchaininfo") + if err != nil { + return nil, err + } + return response, nil +} + +func (t *BitcoindService) getL2Service() (*lnd.LndService, error) { + s, err := t.GetServiceManager().GetService(t.l2ServiceName) + if err != nil { + return nil, err + } + lndSvc, ok := s.(*lnd.LndService) + if !ok { + return nil, errors.New("cannot convert to LndService") + } + return lndSvc, nil +} + +func (t *BitcoindService) getMode() (Mode, error) { + lndSvc, err := t.getL2Service() + if err != nil { + return Unknown, err + } + backend, err := lndSvc.GetBackendNode() + if err != nil { + return Unknown, err + } + if backend == "bitcoind" || backend == "litecoind" { + // could be native or external + values, err := lndSvc.GetConfigValues(fmt.Sprintf("%s.rpchost", backend)) + if err != nil { + return Unknown, err + } + host := values[0] + if host == backend { + return Native, nil + } else { + return External, nil + } + } else if backend == "neutrino" { + return Light, nil + } + return Unknown, nil +} + +func (t *BitcoindService) GetStatus() (string, error) { + mode, err := t.getMode() + if err != nil { + return "", err + } + switch mode { + case Native: + status, err := t.SingleContainerService.GetStatus() + if status != "Container running" { + return status, nil + } + resp, err := t.GetBlockchainInfo() + if err != nil { + return fmt.Sprintf("Waiting for %s to come up...", t.GetName()), nil + } + if resp.Error != nil { + // Loading block index... + return resp.Error.Message, nil + } + r := resp.Result.(map[string]interface{}) + current, err := r["blocks"].(json.Number).Int64() + if err != nil { + return "", err + } + total, err := r["headers"].(json.Number).Int64() + if err != nil { + return "", err + } + if current > 0 && current == total { + return "Ready", nil + } else { + if total == 0 { + return "Syncing 0.00% (0/0)", nil + } else { + p := float32(current) / float32(total) * 100.0 + return fmt.Sprintf("Syncing %.2f%% (%d/%d)", p, current, total), nil + } + } + case External: + // TODO Unavailable (connection to external failed) + return "Ready (connected to external)", nil + case Light: + return "Ready (light mode)", nil + default: + return "Error: Unknown mode", nil + } +} diff --git a/service/bitcoind/jsonrpc.go b/service/bitcoind/jsonrpc.go new file mode 100644 index 0000000..2b9c489 --- /dev/null +++ b/service/bitcoind/jsonrpc.go @@ -0,0 +1,23 @@ +package bitcoind + +type Fork struct { + Type string + Active bool + Height int32 +} + +type BlockchainInfo struct { + Chain string + Blocks int32 + Headers int32 + BestBlockHash string + Difficulty float64 + MedianTime int32 + VerificationProgress float32 + InitialBlockDownload bool + ChainWork string + SizeOnDisk int32 + Pruned bool + SoftForks map[string]Fork + Warnings string +} diff --git a/service/boltz/boltz.go b/service/boltz/boltz.go new file mode 100644 index 0000000..04fe00e --- /dev/null +++ b/service/boltz/boltz.go @@ -0,0 +1,77 @@ +package boltz + +import ( + "encoding/json" + "github.com/ExchangeUnion/xud-docker-api-poc/service" +) + +type BoltzService struct { + *service.SingleContainerService +} + +type Node string + +const ( + BTC Node = "btc" + LTC Node = "ltc" +) + +func New( + name string, + containerName string, +) *BoltzService { + return &BoltzService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + } +} + +// { +// "symbol": "BTC", +// "lnd_pubkey": "02c882fbd75ba7c0e3175a0b86037b4d056599a694fcfad56589fc05d081b62774", +// "block_height": 1835961 +// } +func (t *BoltzService) GetInfo(node Node) (map[string]interface{}, error) { + output, err := t.Exec1([]string{"wrapper", string(node), "getinfo"}) + if err != nil { + return nil, err + } + var result map[string]interface{} + err = json.Unmarshal([]byte(output), &result) + if err != nil { + return nil, err + } + return result, nil +} + +type NodeStatus struct { + Status string + IsUp bool +} + +func (t *BoltzService) checkNode(node Node) NodeStatus { + _, err := t.GetInfo(node) + if err == nil { + return NodeStatus{Status: string(node) + " up", IsUp: true} + } else { + return NodeStatus{Status: string(node) + " down", IsUp: false} + } +} + +func (t *BoltzService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status != "Container running" { + return status, err + } + + btcStatus := t.checkNode(BTC) + ltcStatus := t.checkNode(LTC) + + if btcStatus.IsUp && ltcStatus.IsUp { + return "Ready", nil + } else { + return btcStatus.Status + "; " + ltcStatus.Status, nil + } +} diff --git a/service/connext/connext.go b/service/connext/connext.go new file mode 100644 index 0000000..ca29aff --- /dev/null +++ b/service/connext/connext.go @@ -0,0 +1,58 @@ +package connext + +import ( + "errors" + "github.com/ExchangeUnion/xud-docker-api-poc/service" + "github.com/ExchangeUnion/xud-docker-api-poc/service/xud" + "net/http" +) + +type ConnextService struct { + *service.SingleContainerService +} + +func New(name string, containerName string) *ConnextService { + return &ConnextService{ + service.NewSingleContainerService(name, containerName), + } +} + +func (t *ConnextService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + svc, err := t.GetServiceManager().GetService("xud") + if err == nil { + xudSvc := svc.(*xud.XudService) + info, err := xudSvc.GetInfo() + if err == nil { + return info.Connext.Status, nil + } + } + + resp, err := http.Get("http://connext:5040/health") + if err != nil { + return "", err + } + // TODO defer resp.Body.Close() + if resp.StatusCode == http.StatusNoContent { + return "Ready", nil + } + return "Starting...", nil + } else { + return status, nil + } +} + +func (t *ConnextService) GetEthProvider() (string, error) { + value, err := t.Getenv("CONNEXT_ETH_PROVIDER_URL") + if err != nil { + return "", err + } + if value == "" { + return "", errors.New("CONNEXT_ETH_PROVIDER_URL not found") + } + return value, nil +} diff --git a/service/container.go b/service/container.go new file mode 100644 index 0000000..f94f00e --- /dev/null +++ b/service/container.go @@ -0,0 +1,175 @@ +package service + +import ( + "bufio" + "context" + "errors" + "github.com/docker/docker/api/types" + docker "github.com/docker/docker/client" + "github.com/docker/docker/pkg/stdcopy" + "github.com/sirupsen/logrus" + "io" + "strings" +) + +type Container struct { + c *types.ContainerJSON + client *docker.Client + logger *logrus.Logger +} + +func (t *Container) Unwrap() *types.ContainerJSON { + return t.c +} + +func (t *Container) GetStatus() string { + return t.c.State.Status +} + +func (t *Container) Exec(command []string) (string, error) { + ctx := context.Background() + createResp, err := t.client.ContainerExecCreate(ctx, t.c.ID, types.ExecConfig{ + Cmd: command, + Tty: false, + AttachStdin: false, + AttachStdout: true, + AttachStderr: true, + }) + if err != nil { + return "", err + } + + execId := createResp.ID + + // ContainerExecAttach = ContainerExecStart + attachResp, err := t.client.ContainerExecAttach(ctx, execId, types.ExecConfig{ + AttachStdout: true, + AttachStderr: true, + }) + if err != nil { + return "", err + } + + output := new(strings.Builder) + _, err = stdcopy.StdCopy(output, output, attachResp.Reader) + if err != nil { + return "", err + } + + inspectResp, err := t.client.ContainerExecInspect(ctx, execId) + if err != nil { + return "", err + } + + exitCode := inspectResp.ExitCode + + if exitCode != 0 { + return output.String(), errors.New("non-zero exit code") + } + + return output.String(), nil +} + +func (t *Container) ExecInteractive(command []string) (string, io.Reader, io.Writer, error) { + + ctx := context.Background() + createResp, err := t.client.ContainerExecCreate(ctx, t.c.ID, types.ExecConfig{ + Cmd: command, + Tty: true, + AttachStdin: true, + AttachStdout: true, + AttachStderr: true, + }) + if err != nil { + return "", nil, nil, err + } + + execId := createResp.ID + + t.logger.Infof("Created exec: %v", execId) + + // ContainerExecAttach = ContainerExecStart + attachResp, err := t.client.ContainerExecAttach(ctx, execId, types.ExecConfig{}) + if err != nil { + return execId, nil, nil, err + } + + t.logger.Infof("Attached %v", attachResp) + + r, w := io.Pipe() + + go func() { + _, err = stdcopy.StdCopy(w, w, attachResp.Reader) + if err != nil { + t.logger.Errorf("StdCopy failed: %v", err) + } + attachResp.Close() + }() + + return execId, r, attachResp.Conn, nil +} + +func (t *Container) GetLogs(since string, tail string) (<-chan string, error) { + reader, err := t.client.ContainerLogs(context.Background(), t.c.ID, types.ContainerLogsOptions{ + ShowStdout: true, + ShowStderr: true, + Since: since, + Tail: tail, + }) + + if err != nil { + return nil, err + } + + ch := make(chan string) + + r, w := io.Pipe() + + go func() { + n, err := stdcopy.StdCopy(w, w, reader) + if err != nil { + t.logger.Errorf("StdCopy error: %v", err) + } + t.logger.Infof("StdCopy %d bytes", n) + err = reader.Close() + if err != nil { + t.logger.Errorf("Failed to close reader: %v", err) + } + err = w.Close() + if err != nil { + t.logger.Errorf("Failed to close pipe writer: %v", err) + } + }() + + go func() { + bufReader := bufio.NewReader(r) + + for { + line, _, err := bufReader.ReadLine() + if err != nil { + break + } + ch <- string(line) + } + + err = reader.Close() + if err != nil { + ch <- "Error: " + err.Error() + } + + close(ch) + }() + + return ch, nil +} + +func (t *Container) Getenv(key string) string { + prefix := key + "=" + for _, env := range t.c.Config.Env { + if strings.HasPrefix(env, prefix) { + value := strings.Replace(env, prefix, "", 1) + return value + } + } + return "" +} diff --git a/service/docker.go b/service/docker.go new file mode 100644 index 0000000..b98434c --- /dev/null +++ b/service/docker.go @@ -0,0 +1,44 @@ +package service + +import ( + docker "github.com/docker/docker/client" +) + +type DockerClientFactory interface { + GetSharedInstance() *docker.Client + NewInstance() (*docker.Client, error) +} + +type ClientFactory struct { + shared *docker.Client +} + +func NewClientFactory() (*ClientFactory, error) { + client, err := createClient() + if err != nil { + return nil, err + } + return &ClientFactory{ + shared: client, + }, nil +} + +func createClient() (*docker.Client, error) { + client, err := docker.NewEnvClient() + if err != nil { + return nil, err + } + return client, nil +} + +func (t *ClientFactory) GetSharedInstance() *docker.Client { + return t.shared +} + +func (t *ClientFactory) NewInstance() (*docker.Client, error) { + client, err := createClient() + if err != nil { + return nil, err + } + return client, nil +} diff --git a/service/geth/geth.go b/service/geth/geth.go new file mode 100644 index 0000000..bf62bc8 --- /dev/null +++ b/service/geth/geth.go @@ -0,0 +1,295 @@ +package geth + +import ( + "errors" + "fmt" + "github.com/ExchangeUnion/xud-docker-api-poc/service" + "github.com/ExchangeUnion/xud-docker-api-poc/service/connext" + "github.com/ybbus/jsonrpc" + "strconv" + "strings" +) + +type GethService struct { + *service.SingleContainerService + rpcOptions *service.RpcOptions + rpcClient jsonrpc.RPCClient + l2ServiceName string + lightProviders []string +} + +type Mode string + +const ( + Native Mode = "native" + External Mode = "external" + Infura Mode = "infura" + Light Mode = "light" + Unknown Mode = "unknown" +) + +func New(name string, containerName string, l2ServiceName string, lightProviders []string) *GethService { + return &GethService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + l2ServiceName: l2ServiceName, + lightProviders: lightProviders, + } +} + +func (t *GethService) ConfigureRpc(options *service.RpcOptions) { + t.rpcOptions = options +} + +func (t *GethService) getRpcClient() jsonrpc.RPCClient { + if t.rpcClient == nil { + addr := fmt.Sprintf("http://%s:%d", t.rpcOptions.Host, t.rpcOptions.Port) + t.rpcClient = jsonrpc.NewClientWithOpts(addr, &jsonrpc.RPCClientOpts{}) + } + return t.rpcClient +} + +type Syncing struct { + CurrentBlock int64 + HighestBlock int64 + KnownStates int64 + PulledStates int64 + StartingBlock int64 +} + +func parseHex(value string) (int64, error) { + value = strings.Replace(value, "0x", "", 1) + i64, err := strconv.ParseInt(value, 16, 32) + if err != nil { + return 0, err + } + return i64, nil +} + +func (t *GethService) EthSyncing() (*Syncing, error) { + result, err := t.getRpcClient().Call("eth_syncing") + if err != nil { + return nil, err + } + + var syncing map[string]string + err = result.GetObject(&syncing) + if err != nil { + _, err := result.GetBool() + if err != nil { + return nil, err + } + return nil, nil + } + + currentBlock, err := parseHex(syncing["currentBlock"]) + if err != nil { + return nil, err + } + + highestBlock, err := parseHex(syncing["highestBlock"]) + if err != nil { + return nil, err + } + + knownStates, err := parseHex(syncing["knownStates"]) + if err != nil { + return nil, err + } + + pulledStates, err := parseHex(syncing["pulledStates"]) + if err != nil { + return nil, err + } + + startingBlock, err := parseHex(syncing["startingBlock"]) + if err != nil { + return nil, err + } + + return &Syncing{ + CurrentBlock: currentBlock, + HighestBlock: highestBlock, + KnownStates: knownStates, + PulledStates: pulledStates, + StartingBlock: startingBlock, + }, nil +} + +func (t *GethService) EthBlockNumber() (int64, error) { + result, err := t.getRpcClient().Call("eth_blockNumber") + if err != nil { + return 0, err + } + s, err := result.GetString() + if err != nil { + return 0, err + } + blockNumber, err := parseHex(s) + if err != nil { + return 0, err + } + return blockNumber, nil +} + +func explainNetVersion(version string) string { + switch version { + case "1": + return "Mainnet" + case "2": + return "Testnet (Morden, deprecated!)" + case "3": + return "Testnet (Ropsten)" + case "4": + return "Testnet (Rinkeby)" + case "42": + return "Testnet (Kovan)" + default: + return version + } +} + +func (t *GethService) checkEthRpc(url string) bool { + client := jsonrpc.NewClientWithOpts(url, &jsonrpc.RPCClientOpts{}) + result, err := client.Call("net_version") + if err != nil { + return false + } + version, err := result.GetString() + if err != nil { + return false + } + t.GetLogger().Infof("Ethereum provider %s net_version is %s", url, explainNetVersion(version)) + return true +} + +func (t *GethService) getL2Service() (*connext.ConnextService, error) { + s, err := t.GetServiceManager().GetService(t.l2ServiceName) + if err != nil { + return nil, err + } + connextSvc, ok := s.(*connext.ConnextService) + if !ok { + return nil, errors.New("cannot convert to ConnextService") + } + return connextSvc, nil +} + +func (t *GethService) isLightProvider(provider string) bool { + for _, item := range t.lightProviders { + if item == provider { + return true + } + } + return false +} + +func (t *GethService) getProvider() (string, error) { + connextSvc, err := t.getL2Service() + if err != nil { + return "", err + } + + provider, err := connextSvc.GetEthProvider() + if err != nil { + return "", err + } + + return provider, nil +} + +func (t *GethService) getMode() (Mode, error) { + provider, err := t.getProvider() + if err != nil { + return Unknown, err + } + + if provider == "http://geth:8545" { + return Native, nil + } else if strings.Contains(provider, "infura") { + return Infura, nil + } else if t.isLightProvider(provider) { + return Light, nil + } else { + return External, nil + } +} + +func (t *GethService) getExternalStatus() (string, error) { + provider, err := t.getProvider() + if err != nil { + return "No provider", err + } + if t.checkEthRpc(provider) { + return "Ready (connected to external)", nil + } else { + return "Unavailable (connection to external failed)", nil + } +} + +func (t *GethService) getInfuraStatus() (string, error) { + provider, err := t.getProvider() + if err != nil { + return "No provider", err + } + if t.checkEthRpc(provider) { + return "Ready (connected to Infura)", nil + } else { + return "Unavailable (connection to Infura failed)", nil + } +} + +func (t *GethService) getLightStatus() (string, error) { + provider, err := t.getProvider() + if err != nil { + return "No provider", err + } + if t.checkEthRpc(provider) { + return "Ready (light mode)", nil + } else { + return "Unavailable (light mode failed)", nil + } +} + +func (t *GethService) GetStatus() (string, error) { + mode, err := t.getMode() + if err != nil { + return "", err + } + + if mode == External { + return t.getExternalStatus() + } else if mode == Infura { + return t.getInfuraStatus() + } else if mode == Light { + return t.getLightStatus() + } + + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + syncing, err := t.EthSyncing() + if err != nil { + return "Waiting for geth to come up...", err + } + if syncing != nil { + current := syncing.CurrentBlock + total := syncing.HighestBlock + p := float32(current) / float32(total) * 100.0 + return fmt.Sprintf("Syncing %.2f%% (%d/%d)", p, current, total), nil + } else { + blockNumber, err := t.EthBlockNumber() + if err != nil { + return "Waiting for geth to come up...", err + } + if blockNumber == 0 { + return "Waiting for sync", nil + } else { + return "Ready", nil + } + } + } else { + return status, nil + } +} diff --git a/service/interface.go b/service/interface.go new file mode 100644 index 0000000..232e80e --- /dev/null +++ b/service/interface.go @@ -0,0 +1,17 @@ +package service + +import ( + "github.com/gin-gonic/gin" +) + +type Service interface { + GetName() string + GetStatus() (string, error) + ConfigureRouter(r *gin.Engine) + Close() + GetLogs(since string, tail string) (<-chan string, error) +} + +type ServiceManager interface { + GetService(name string) (Service, error) +} diff --git a/service/litecoind/litecoind.go b/service/litecoind/litecoind.go new file mode 100644 index 0000000..b2beb26 --- /dev/null +++ b/service/litecoind/litecoind.go @@ -0,0 +1,19 @@ +package litecoind + +import ( + "github.com/ExchangeUnion/xud-docker-api-poc/service/bitcoind" +) + +type LitecoindService struct{ + *bitcoind.BitcoindService +} + +func New( + name string, + containerName string, + l2ServiceName string, +) *LitecoindService { + return &LitecoindService{ + bitcoind.New(name, containerName, l2ServiceName), + } +} \ No newline at end of file diff --git a/service/lnd/lnd.go b/service/lnd/lnd.go new file mode 100644 index 0000000..2fad0e1 --- /dev/null +++ b/service/lnd/lnd.go @@ -0,0 +1,241 @@ +package lnd + +import ( + "context" + "errors" + "fmt" + "github.com/ExchangeUnion/xud-docker-api-poc/service" + pb "github.com/ExchangeUnion/xud-docker-api-poc/service/lnd/lnrpc" + "github.com/ExchangeUnion/xud-docker-api-poc/utils" + "github.com/gin-gonic/gin" + "github.com/golang/protobuf/jsonpb" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" + "gopkg.in/ini.v1" + "io/ioutil" + "net/http" + "regexp" + "strconv" + "strings" +) + +type LndService struct { + *service.SingleContainerService + rpcOptions *service.RpcOptions + rpcClient pb.LightningClient + chain string + p *regexp.Regexp +} + +func (t *LndService) GetBackendNode() (string, error) { + key := fmt.Sprintf("%s.node", t.chain) + values, err := t.GetConfigValues(key) + if err != nil { + return "", err + } + return values[0], err +} + +func New(name string, containerName string, chain string) (*LndService, error) { + p, err := regexp.Compile("^.*NTFN: New block: height=(\\d+), sha=(.+)$") + if err != nil { + return nil, err + } + + return &LndService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + chain: chain, + p: p, + }, nil +} + +func (t *LndService) ConfigureRpc(options *service.RpcOptions) { + t.rpcOptions = options +} + +func (t *LndService) getRpcClient() (pb.LightningClient, error) { + if t.rpcClient == nil { + creds, err := credentials.NewClientTLSFromFile(t.rpcOptions.TlsCert, "localhost") + if err != nil { + return nil, err + } + + addr := fmt.Sprintf("%s:%d", t.rpcOptions.Host, t.rpcOptions.Port) + var opts []grpc.DialOption + opts = append(opts, grpc.WithTransportCredentials(creds)) + opts = append(opts, grpc.WithBlock()) + //opts = append(opts, grpc.WithTimeout(time.Duration(10000))) + + macaroonCred, ok := t.rpcOptions.Credential.(service.MacaroonCredential) + if !ok { + return nil, errors.New("MacaroonCredential is required") + } + + opts = append(opts, grpc.WithPerRPCCredentials(macaroonCred)) + + conn, err := grpc.Dial(addr, opts...) + if err != nil { + return nil, err + } + + t.rpcClient = pb.NewLightningClient(conn) + } + return t.rpcClient, nil +} + +func (t *LndService) loadConfFile() (string, error) { + confFile := fmt.Sprintf("/root/.%s/lnd.conf", t.GetName()) + content, err := ioutil.ReadFile(confFile) + if err != nil { + return "", err + } + return string(content), nil +} + +func (t *LndService) GetConfigValues(key string) ([]string, error) { + var result []string + //c, err := t.GetContainer() + //if err != nil { + // return result, err + //} + //for k, v := range c.Config.Volumes { + // log.Printf("lndbtc volume %s: %v", k, v) + //} + //for _, bind := range c.HostConfig.Binds { + // log.Printf("lndbtc bind %s", bind) + //} + + conf, err := t.loadConfFile() + + config, err := ini.ShadowLoad([]byte(conf)) + if err != nil { + return result, err + } + + parts := strings.Split(key, ".") + + if cap(parts) == 2 { + section, err := config.GetSection(strings.Title(parts[0])) + if err != nil { + return result, err + } + + iniKey, err := section.GetKey(key) + if err != nil { + return result, err + } + value := iniKey.Value() + result = append(result, value) + } else if cap(parts) == 1 { + section, err := config.GetSection(ini.DefaultSection) + if err != nil { + return result, err + } + + iniKey, err := section.GetKey(key) + if err != nil { + return result, err + } + values := iniKey.ValueWithShadows() + result = append(result, values...) + } + + return result, nil +} + +func (t *LndService) GetInfo() (*pb.GetInfoResponse, error) { + client, err := t.getRpcClient() + if err != nil { + return nil, err + } + + req := pb.GetInfoRequest{} + + return client.GetInfo(context.Background(), &req) +} + +func (t *LndService) ConfigureRouter(r *gin.Engine) { + r.GET(fmt.Sprintf("/api/v1/%s/getinfo", t.GetName()), func(c *gin.Context) { + resp, err := t.GetInfo() + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) +} + +func (t *LndService) getCurrentHeight() (uint32, error) { + logs, err := t.GetLogs("10m", "all") + if err != nil { + return 0, nil + } + + var height string + + for line := range logs { + if t.p.MatchString(line) { + height = t.p.ReplaceAllString(line, "$1") + } + } + + if height != "" { + i64, err := strconv.ParseInt(height, 10, 32) + if err != nil { + return 0, nil + } + return uint32(i64), nil + } + + return 0, nil +} + +func (t *LndService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + info, err := t.GetInfo() + if err != nil { + if strings.Contains(err.Error(), "Wallet is encrypted") { + return "Wallet locked. Unlock with lncli unlock.", nil + } + return "", err + } + + syncedToChain := info.SyncedToChain + total := info.BlockHeight + current, err := t.getCurrentHeight() + + t.GetLogger().Infof("Current height is %d", current) + + if err == nil && current > 0 { + if total <= current { + return "Ready", nil + } else { + p := float32(current) / float32(total) * 100.0 + if p > 0.005 { + p = p - 0.005 + } else { + p = 0 + } + return fmt.Sprintf("Syncing %.2f%% (%d/%d)", p, current, total), nil + } + } else { + if syncedToChain { + return "Ready", nil + } else { + return "Syncing", nil + } + } + } else { + return status, nil + } +} diff --git a/service/lnd/lnrpc/rpc.pb.go b/service/lnd/lnrpc/rpc.pb.go new file mode 100644 index 0000000..5de14d0 --- /dev/null +++ b/service/lnd/lnrpc/rpc.pb.go @@ -0,0 +1,16136 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: rpc.proto + +package lnrpc + +import ( + context "context" + fmt "fmt" + proto "github.com/golang/protobuf/proto" + grpc "google.golang.org/grpc" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +// +//`AddressType` has to be one of: +// +//- `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) +//- `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1) +type AddressType int32 + +const ( + AddressType_WITNESS_PUBKEY_HASH AddressType = 0 + AddressType_NESTED_PUBKEY_HASH AddressType = 1 + AddressType_UNUSED_WITNESS_PUBKEY_HASH AddressType = 2 + AddressType_UNUSED_NESTED_PUBKEY_HASH AddressType = 3 +) + +var AddressType_name = map[int32]string{ + 0: "WITNESS_PUBKEY_HASH", + 1: "NESTED_PUBKEY_HASH", + 2: "UNUSED_WITNESS_PUBKEY_HASH", + 3: "UNUSED_NESTED_PUBKEY_HASH", +} + +var AddressType_value = map[string]int32{ + "WITNESS_PUBKEY_HASH": 0, + "NESTED_PUBKEY_HASH": 1, + "UNUSED_WITNESS_PUBKEY_HASH": 2, + "UNUSED_NESTED_PUBKEY_HASH": 3, +} + +func (x AddressType) String() string { + return proto.EnumName(AddressType_name, int32(x)) +} + +func (AddressType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{0} +} + +type CommitmentType int32 + +const ( + // + //A channel using the legacy commitment format having tweaked to_remote + //keys. + CommitmentType_LEGACY CommitmentType = 0 + // + //A channel that uses the modern commitment format where the key in the + //output of the remote party does not change each state. This makes back + //up and recovery easier as when the channel is closed, the funds go + //directly to that key. + CommitmentType_STATIC_REMOTE_KEY CommitmentType = 1 + // + //A channel that uses a commitment format that has anchor outputs on the + //commitments, allowing fee bumping after a force close transaction has + //been broadcast. + CommitmentType_ANCHORS CommitmentType = 2 + // + //Returned when the commitment type isn't known or unavailable. + CommitmentType_UNKNOWN_COMMITMENT_TYPE CommitmentType = 999 +) + +var CommitmentType_name = map[int32]string{ + 0: "LEGACY", + 1: "STATIC_REMOTE_KEY", + 2: "ANCHORS", + 999: "UNKNOWN_COMMITMENT_TYPE", +} + +var CommitmentType_value = map[string]int32{ + "LEGACY": 0, + "STATIC_REMOTE_KEY": 1, + "ANCHORS": 2, + "UNKNOWN_COMMITMENT_TYPE": 999, +} + +func (x CommitmentType) String() string { + return proto.EnumName(CommitmentType_name, int32(x)) +} + +func (CommitmentType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{1} +} + +type Initiator int32 + +const ( + Initiator_INITIATOR_UNKNOWN Initiator = 0 + Initiator_INITIATOR_LOCAL Initiator = 1 + Initiator_INITIATOR_REMOTE Initiator = 2 + Initiator_INITIATOR_BOTH Initiator = 3 +) + +var Initiator_name = map[int32]string{ + 0: "INITIATOR_UNKNOWN", + 1: "INITIATOR_LOCAL", + 2: "INITIATOR_REMOTE", + 3: "INITIATOR_BOTH", +} + +var Initiator_value = map[string]int32{ + "INITIATOR_UNKNOWN": 0, + "INITIATOR_LOCAL": 1, + "INITIATOR_REMOTE": 2, + "INITIATOR_BOTH": 3, +} + +func (x Initiator) String() string { + return proto.EnumName(Initiator_name, int32(x)) +} + +func (Initiator) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{2} +} + +type ResolutionType int32 + +const ( + ResolutionType_TYPE_UNKNOWN ResolutionType = 0 + // We resolved an anchor output. + ResolutionType_ANCHOR ResolutionType = 1 + // + //We are resolving an incoming htlc on chain. This if this htlc is + //claimed, we swept the incoming htlc with the preimage. If it is timed + //out, our peer swept the timeout path. + ResolutionType_INCOMING_HTLC ResolutionType = 2 + // + //We are resolving an outgoing htlc on chain. If this htlc is claimed, + //the remote party swept the htlc with the preimage. If it is timed out, + //we swept it with the timeout path. + ResolutionType_OUTGOING_HTLC ResolutionType = 3 + // We force closed and need to sweep our time locked commitment output. + ResolutionType_COMMIT ResolutionType = 4 +) + +var ResolutionType_name = map[int32]string{ + 0: "TYPE_UNKNOWN", + 1: "ANCHOR", + 2: "INCOMING_HTLC", + 3: "OUTGOING_HTLC", + 4: "COMMIT", +} + +var ResolutionType_value = map[string]int32{ + "TYPE_UNKNOWN": 0, + "ANCHOR": 1, + "INCOMING_HTLC": 2, + "OUTGOING_HTLC": 3, + "COMMIT": 4, +} + +func (x ResolutionType) String() string { + return proto.EnumName(ResolutionType_name, int32(x)) +} + +func (ResolutionType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{3} +} + +type ResolutionOutcome int32 + +const ( + // Outcome unknown. + ResolutionOutcome_OUTCOME_UNKNOWN ResolutionOutcome = 0 + // An output was claimed on chain. + ResolutionOutcome_CLAIMED ResolutionOutcome = 1 + // An output was left unclaimed on chain. + ResolutionOutcome_UNCLAIMED ResolutionOutcome = 2 + // + //ResolverOutcomeAbandoned indicates that an output that we did not + //claim on chain, for example an anchor that we did not sweep and a + //third party claimed on chain, or a htlc that we could not decode + //so left unclaimed. + ResolutionOutcome_ABANDONED ResolutionOutcome = 3 + // + //If we force closed our channel, our htlcs need to be claimed in two + //stages. This outcome represents the broadcast of a timeout or success + //transaction for this two stage htlc claim. + ResolutionOutcome_FIRST_STAGE ResolutionOutcome = 4 + // A htlc was timed out on chain. + ResolutionOutcome_TIMEOUT ResolutionOutcome = 5 +) + +var ResolutionOutcome_name = map[int32]string{ + 0: "OUTCOME_UNKNOWN", + 1: "CLAIMED", + 2: "UNCLAIMED", + 3: "ABANDONED", + 4: "FIRST_STAGE", + 5: "TIMEOUT", +} + +var ResolutionOutcome_value = map[string]int32{ + "OUTCOME_UNKNOWN": 0, + "CLAIMED": 1, + "UNCLAIMED": 2, + "ABANDONED": 3, + "FIRST_STAGE": 4, + "TIMEOUT": 5, +} + +func (x ResolutionOutcome) String() string { + return proto.EnumName(ResolutionOutcome_name, int32(x)) +} + +func (ResolutionOutcome) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{4} +} + +type NodeMetricType int32 + +const ( + NodeMetricType_UNKNOWN NodeMetricType = 0 + NodeMetricType_BETWEENNESS_CENTRALITY NodeMetricType = 1 +) + +var NodeMetricType_name = map[int32]string{ + 0: "UNKNOWN", + 1: "BETWEENNESS_CENTRALITY", +} + +var NodeMetricType_value = map[string]int32{ + "UNKNOWN": 0, + "BETWEENNESS_CENTRALITY": 1, +} + +func (x NodeMetricType) String() string { + return proto.EnumName(NodeMetricType_name, int32(x)) +} + +func (NodeMetricType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{5} +} + +type InvoiceHTLCState int32 + +const ( + InvoiceHTLCState_ACCEPTED InvoiceHTLCState = 0 + InvoiceHTLCState_SETTLED InvoiceHTLCState = 1 + InvoiceHTLCState_CANCELED InvoiceHTLCState = 2 +) + +var InvoiceHTLCState_name = map[int32]string{ + 0: "ACCEPTED", + 1: "SETTLED", + 2: "CANCELED", +} + +var InvoiceHTLCState_value = map[string]int32{ + "ACCEPTED": 0, + "SETTLED": 1, + "CANCELED": 2, +} + +func (x InvoiceHTLCState) String() string { + return proto.EnumName(InvoiceHTLCState_name, int32(x)) +} + +func (InvoiceHTLCState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{6} +} + +type PaymentFailureReason int32 + +const ( + // + //Payment isn't failed (yet). + PaymentFailureReason_FAILURE_REASON_NONE PaymentFailureReason = 0 + // + //There are more routes to try, but the payment timeout was exceeded. + PaymentFailureReason_FAILURE_REASON_TIMEOUT PaymentFailureReason = 1 + // + //All possible routes were tried and failed permanently. Or were no + //routes to the destination at all. + PaymentFailureReason_FAILURE_REASON_NO_ROUTE PaymentFailureReason = 2 + // + //A non-recoverable error has occured. + PaymentFailureReason_FAILURE_REASON_ERROR PaymentFailureReason = 3 + // + //Payment details incorrect (unknown hash, invalid amt or + //invalid final cltv delta) + PaymentFailureReason_FAILURE_REASON_INCORRECT_PAYMENT_DETAILS PaymentFailureReason = 4 + // + //Insufficient local balance. + PaymentFailureReason_FAILURE_REASON_INSUFFICIENT_BALANCE PaymentFailureReason = 5 +) + +var PaymentFailureReason_name = map[int32]string{ + 0: "FAILURE_REASON_NONE", + 1: "FAILURE_REASON_TIMEOUT", + 2: "FAILURE_REASON_NO_ROUTE", + 3: "FAILURE_REASON_ERROR", + 4: "FAILURE_REASON_INCORRECT_PAYMENT_DETAILS", + 5: "FAILURE_REASON_INSUFFICIENT_BALANCE", +} + +var PaymentFailureReason_value = map[string]int32{ + "FAILURE_REASON_NONE": 0, + "FAILURE_REASON_TIMEOUT": 1, + "FAILURE_REASON_NO_ROUTE": 2, + "FAILURE_REASON_ERROR": 3, + "FAILURE_REASON_INCORRECT_PAYMENT_DETAILS": 4, + "FAILURE_REASON_INSUFFICIENT_BALANCE": 5, +} + +func (x PaymentFailureReason) String() string { + return proto.EnumName(PaymentFailureReason_name, int32(x)) +} + +func (PaymentFailureReason) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{7} +} + +type FeatureBit int32 + +const ( + FeatureBit_DATALOSS_PROTECT_REQ FeatureBit = 0 + FeatureBit_DATALOSS_PROTECT_OPT FeatureBit = 1 + FeatureBit_INITIAL_ROUING_SYNC FeatureBit = 3 + FeatureBit_UPFRONT_SHUTDOWN_SCRIPT_REQ FeatureBit = 4 + FeatureBit_UPFRONT_SHUTDOWN_SCRIPT_OPT FeatureBit = 5 + FeatureBit_GOSSIP_QUERIES_REQ FeatureBit = 6 + FeatureBit_GOSSIP_QUERIES_OPT FeatureBit = 7 + FeatureBit_TLV_ONION_REQ FeatureBit = 8 + FeatureBit_TLV_ONION_OPT FeatureBit = 9 + FeatureBit_EXT_GOSSIP_QUERIES_REQ FeatureBit = 10 + FeatureBit_EXT_GOSSIP_QUERIES_OPT FeatureBit = 11 + FeatureBit_STATIC_REMOTE_KEY_REQ FeatureBit = 12 + FeatureBit_STATIC_REMOTE_KEY_OPT FeatureBit = 13 + FeatureBit_PAYMENT_ADDR_REQ FeatureBit = 14 + FeatureBit_PAYMENT_ADDR_OPT FeatureBit = 15 + FeatureBit_MPP_REQ FeatureBit = 16 + FeatureBit_MPP_OPT FeatureBit = 17 +) + +var FeatureBit_name = map[int32]string{ + 0: "DATALOSS_PROTECT_REQ", + 1: "DATALOSS_PROTECT_OPT", + 3: "INITIAL_ROUING_SYNC", + 4: "UPFRONT_SHUTDOWN_SCRIPT_REQ", + 5: "UPFRONT_SHUTDOWN_SCRIPT_OPT", + 6: "GOSSIP_QUERIES_REQ", + 7: "GOSSIP_QUERIES_OPT", + 8: "TLV_ONION_REQ", + 9: "TLV_ONION_OPT", + 10: "EXT_GOSSIP_QUERIES_REQ", + 11: "EXT_GOSSIP_QUERIES_OPT", + 12: "STATIC_REMOTE_KEY_REQ", + 13: "STATIC_REMOTE_KEY_OPT", + 14: "PAYMENT_ADDR_REQ", + 15: "PAYMENT_ADDR_OPT", + 16: "MPP_REQ", + 17: "MPP_OPT", +} + +var FeatureBit_value = map[string]int32{ + "DATALOSS_PROTECT_REQ": 0, + "DATALOSS_PROTECT_OPT": 1, + "INITIAL_ROUING_SYNC": 3, + "UPFRONT_SHUTDOWN_SCRIPT_REQ": 4, + "UPFRONT_SHUTDOWN_SCRIPT_OPT": 5, + "GOSSIP_QUERIES_REQ": 6, + "GOSSIP_QUERIES_OPT": 7, + "TLV_ONION_REQ": 8, + "TLV_ONION_OPT": 9, + "EXT_GOSSIP_QUERIES_REQ": 10, + "EXT_GOSSIP_QUERIES_OPT": 11, + "STATIC_REMOTE_KEY_REQ": 12, + "STATIC_REMOTE_KEY_OPT": 13, + "PAYMENT_ADDR_REQ": 14, + "PAYMENT_ADDR_OPT": 15, + "MPP_REQ": 16, + "MPP_OPT": 17, +} + +func (x FeatureBit) String() string { + return proto.EnumName(FeatureBit_name, int32(x)) +} + +func (FeatureBit) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{8} +} + +type ChannelCloseSummary_ClosureType int32 + +const ( + ChannelCloseSummary_COOPERATIVE_CLOSE ChannelCloseSummary_ClosureType = 0 + ChannelCloseSummary_LOCAL_FORCE_CLOSE ChannelCloseSummary_ClosureType = 1 + ChannelCloseSummary_REMOTE_FORCE_CLOSE ChannelCloseSummary_ClosureType = 2 + ChannelCloseSummary_BREACH_CLOSE ChannelCloseSummary_ClosureType = 3 + ChannelCloseSummary_FUNDING_CANCELED ChannelCloseSummary_ClosureType = 4 + ChannelCloseSummary_ABANDONED ChannelCloseSummary_ClosureType = 5 +) + +var ChannelCloseSummary_ClosureType_name = map[int32]string{ + 0: "COOPERATIVE_CLOSE", + 1: "LOCAL_FORCE_CLOSE", + 2: "REMOTE_FORCE_CLOSE", + 3: "BREACH_CLOSE", + 4: "FUNDING_CANCELED", + 5: "ABANDONED", +} + +var ChannelCloseSummary_ClosureType_value = map[string]int32{ + "COOPERATIVE_CLOSE": 0, + "LOCAL_FORCE_CLOSE": 1, + "REMOTE_FORCE_CLOSE": 2, + "BREACH_CLOSE": 3, + "FUNDING_CANCELED": 4, + "ABANDONED": 5, +} + +func (x ChannelCloseSummary_ClosureType) String() string { + return proto.EnumName(ChannelCloseSummary_ClosureType_name, int32(x)) +} + +func (ChannelCloseSummary_ClosureType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{36, 0} +} + +type Peer_SyncType int32 + +const ( + // + //Denotes that we cannot determine the peer's current sync type. + Peer_UNKNOWN_SYNC Peer_SyncType = 0 + // + //Denotes that we are actively receiving new graph updates from the peer. + Peer_ACTIVE_SYNC Peer_SyncType = 1 + // + //Denotes that we are not receiving new graph updates from the peer. + Peer_PASSIVE_SYNC Peer_SyncType = 2 +) + +var Peer_SyncType_name = map[int32]string{ + 0: "UNKNOWN_SYNC", + 1: "ACTIVE_SYNC", + 2: "PASSIVE_SYNC", +} + +var Peer_SyncType_value = map[string]int32{ + "UNKNOWN_SYNC": 0, + "ACTIVE_SYNC": 1, + "PASSIVE_SYNC": 2, +} + +func (x Peer_SyncType) String() string { + return proto.EnumName(Peer_SyncType_name, int32(x)) +} + +func (Peer_SyncType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{40, 0} +} + +type PeerEvent_EventType int32 + +const ( + PeerEvent_PEER_ONLINE PeerEvent_EventType = 0 + PeerEvent_PEER_OFFLINE PeerEvent_EventType = 1 +) + +var PeerEvent_EventType_name = map[int32]string{ + 0: "PEER_ONLINE", + 1: "PEER_OFFLINE", +} + +var PeerEvent_EventType_value = map[string]int32{ + "PEER_ONLINE": 0, + "PEER_OFFLINE": 1, +} + +func (x PeerEvent_EventType) String() string { + return proto.EnumName(PeerEvent_EventType_name, int32(x)) +} + +func (PeerEvent_EventType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{45, 0} +} + +type PendingChannelsResponse_ForceClosedChannel_AnchorState int32 + +const ( + PendingChannelsResponse_ForceClosedChannel_LIMBO PendingChannelsResponse_ForceClosedChannel_AnchorState = 0 + PendingChannelsResponse_ForceClosedChannel_RECOVERED PendingChannelsResponse_ForceClosedChannel_AnchorState = 1 + PendingChannelsResponse_ForceClosedChannel_LOST PendingChannelsResponse_ForceClosedChannel_AnchorState = 2 +) + +var PendingChannelsResponse_ForceClosedChannel_AnchorState_name = map[int32]string{ + 0: "LIMBO", + 1: "RECOVERED", + 2: "LOST", +} + +var PendingChannelsResponse_ForceClosedChannel_AnchorState_value = map[string]int32{ + "LIMBO": 0, + "RECOVERED": 1, + "LOST": 2, +} + +func (x PendingChannelsResponse_ForceClosedChannel_AnchorState) String() string { + return proto.EnumName(PendingChannelsResponse_ForceClosedChannel_AnchorState_name, int32(x)) +} + +func (PendingChannelsResponse_ForceClosedChannel_AnchorState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 5, 0} +} + +type ChannelEventUpdate_UpdateType int32 + +const ( + ChannelEventUpdate_OPEN_CHANNEL ChannelEventUpdate_UpdateType = 0 + ChannelEventUpdate_CLOSED_CHANNEL ChannelEventUpdate_UpdateType = 1 + ChannelEventUpdate_ACTIVE_CHANNEL ChannelEventUpdate_UpdateType = 2 + ChannelEventUpdate_INACTIVE_CHANNEL ChannelEventUpdate_UpdateType = 3 + ChannelEventUpdate_PENDING_OPEN_CHANNEL ChannelEventUpdate_UpdateType = 4 +) + +var ChannelEventUpdate_UpdateType_name = map[int32]string{ + 0: "OPEN_CHANNEL", + 1: "CLOSED_CHANNEL", + 2: "ACTIVE_CHANNEL", + 3: "INACTIVE_CHANNEL", + 4: "PENDING_OPEN_CHANNEL", +} + +var ChannelEventUpdate_UpdateType_value = map[string]int32{ + "OPEN_CHANNEL": 0, + "CLOSED_CHANNEL": 1, + "ACTIVE_CHANNEL": 2, + "INACTIVE_CHANNEL": 3, + "PENDING_OPEN_CHANNEL": 4, +} + +func (x ChannelEventUpdate_UpdateType) String() string { + return proto.EnumName(ChannelEventUpdate_UpdateType_name, int32(x)) +} + +func (ChannelEventUpdate_UpdateType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{74, 0} +} + +type Invoice_InvoiceState int32 + +const ( + Invoice_OPEN Invoice_InvoiceState = 0 + Invoice_SETTLED Invoice_InvoiceState = 1 + Invoice_CANCELED Invoice_InvoiceState = 2 + Invoice_ACCEPTED Invoice_InvoiceState = 3 +) + +var Invoice_InvoiceState_name = map[int32]string{ + 0: "OPEN", + 1: "SETTLED", + 2: "CANCELED", + 3: "ACCEPTED", +} + +var Invoice_InvoiceState_value = map[string]int32{ + "OPEN": 0, + "SETTLED": 1, + "CANCELED": 2, + "ACCEPTED": 3, +} + +func (x Invoice_InvoiceState) String() string { + return proto.EnumName(Invoice_InvoiceState_name, int32(x)) +} + +func (Invoice_InvoiceState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{109, 0} +} + +type Payment_PaymentStatus int32 + +const ( + Payment_UNKNOWN Payment_PaymentStatus = 0 + Payment_IN_FLIGHT Payment_PaymentStatus = 1 + Payment_SUCCEEDED Payment_PaymentStatus = 2 + Payment_FAILED Payment_PaymentStatus = 3 +) + +var Payment_PaymentStatus_name = map[int32]string{ + 0: "UNKNOWN", + 1: "IN_FLIGHT", + 2: "SUCCEEDED", + 3: "FAILED", +} + +var Payment_PaymentStatus_value = map[string]int32{ + "UNKNOWN": 0, + "IN_FLIGHT": 1, + "SUCCEEDED": 2, + "FAILED": 3, +} + +func (x Payment_PaymentStatus) String() string { + return proto.EnumName(Payment_PaymentStatus_name, int32(x)) +} + +func (Payment_PaymentStatus) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{116, 0} +} + +type HTLCAttempt_HTLCStatus int32 + +const ( + HTLCAttempt_IN_FLIGHT HTLCAttempt_HTLCStatus = 0 + HTLCAttempt_SUCCEEDED HTLCAttempt_HTLCStatus = 1 + HTLCAttempt_FAILED HTLCAttempt_HTLCStatus = 2 +) + +var HTLCAttempt_HTLCStatus_name = map[int32]string{ + 0: "IN_FLIGHT", + 1: "SUCCEEDED", + 2: "FAILED", +} + +var HTLCAttempt_HTLCStatus_value = map[string]int32{ + "IN_FLIGHT": 0, + "SUCCEEDED": 1, + "FAILED": 2, +} + +func (x HTLCAttempt_HTLCStatus) String() string { + return proto.EnumName(HTLCAttempt_HTLCStatus_name, int32(x)) +} + +func (HTLCAttempt_HTLCStatus) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{117, 0} +} + +type Failure_FailureCode int32 + +const ( + // + //The numbers assigned in this enumeration match the failure codes as + //defined in BOLT #4. Because protobuf 3 requires enums to start with 0, + //a RESERVED value is added. + Failure_RESERVED Failure_FailureCode = 0 + Failure_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS Failure_FailureCode = 1 + Failure_INCORRECT_PAYMENT_AMOUNT Failure_FailureCode = 2 + Failure_FINAL_INCORRECT_CLTV_EXPIRY Failure_FailureCode = 3 + Failure_FINAL_INCORRECT_HTLC_AMOUNT Failure_FailureCode = 4 + Failure_FINAL_EXPIRY_TOO_SOON Failure_FailureCode = 5 + Failure_INVALID_REALM Failure_FailureCode = 6 + Failure_EXPIRY_TOO_SOON Failure_FailureCode = 7 + Failure_INVALID_ONION_VERSION Failure_FailureCode = 8 + Failure_INVALID_ONION_HMAC Failure_FailureCode = 9 + Failure_INVALID_ONION_KEY Failure_FailureCode = 10 + Failure_AMOUNT_BELOW_MINIMUM Failure_FailureCode = 11 + Failure_FEE_INSUFFICIENT Failure_FailureCode = 12 + Failure_INCORRECT_CLTV_EXPIRY Failure_FailureCode = 13 + Failure_CHANNEL_DISABLED Failure_FailureCode = 14 + Failure_TEMPORARY_CHANNEL_FAILURE Failure_FailureCode = 15 + Failure_REQUIRED_NODE_FEATURE_MISSING Failure_FailureCode = 16 + Failure_REQUIRED_CHANNEL_FEATURE_MISSING Failure_FailureCode = 17 + Failure_UNKNOWN_NEXT_PEER Failure_FailureCode = 18 + Failure_TEMPORARY_NODE_FAILURE Failure_FailureCode = 19 + Failure_PERMANENT_NODE_FAILURE Failure_FailureCode = 20 + Failure_PERMANENT_CHANNEL_FAILURE Failure_FailureCode = 21 + Failure_EXPIRY_TOO_FAR Failure_FailureCode = 22 + Failure_MPP_TIMEOUT Failure_FailureCode = 23 + // + //An internal error occurred. + Failure_INTERNAL_FAILURE Failure_FailureCode = 997 + // + //The error source is known, but the failure itself couldn't be decoded. + Failure_UNKNOWN_FAILURE Failure_FailureCode = 998 + // + //An unreadable failure result is returned if the received failure message + //cannot be decrypted. In that case the error source is unknown. + Failure_UNREADABLE_FAILURE Failure_FailureCode = 999 +) + +var Failure_FailureCode_name = map[int32]string{ + 0: "RESERVED", + 1: "INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS", + 2: "INCORRECT_PAYMENT_AMOUNT", + 3: "FINAL_INCORRECT_CLTV_EXPIRY", + 4: "FINAL_INCORRECT_HTLC_AMOUNT", + 5: "FINAL_EXPIRY_TOO_SOON", + 6: "INVALID_REALM", + 7: "EXPIRY_TOO_SOON", + 8: "INVALID_ONION_VERSION", + 9: "INVALID_ONION_HMAC", + 10: "INVALID_ONION_KEY", + 11: "AMOUNT_BELOW_MINIMUM", + 12: "FEE_INSUFFICIENT", + 13: "INCORRECT_CLTV_EXPIRY", + 14: "CHANNEL_DISABLED", + 15: "TEMPORARY_CHANNEL_FAILURE", + 16: "REQUIRED_NODE_FEATURE_MISSING", + 17: "REQUIRED_CHANNEL_FEATURE_MISSING", + 18: "UNKNOWN_NEXT_PEER", + 19: "TEMPORARY_NODE_FAILURE", + 20: "PERMANENT_NODE_FAILURE", + 21: "PERMANENT_CHANNEL_FAILURE", + 22: "EXPIRY_TOO_FAR", + 23: "MPP_TIMEOUT", + 997: "INTERNAL_FAILURE", + 998: "UNKNOWN_FAILURE", + 999: "UNREADABLE_FAILURE", +} + +var Failure_FailureCode_value = map[string]int32{ + "RESERVED": 0, + "INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS": 1, + "INCORRECT_PAYMENT_AMOUNT": 2, + "FINAL_INCORRECT_CLTV_EXPIRY": 3, + "FINAL_INCORRECT_HTLC_AMOUNT": 4, + "FINAL_EXPIRY_TOO_SOON": 5, + "INVALID_REALM": 6, + "EXPIRY_TOO_SOON": 7, + "INVALID_ONION_VERSION": 8, + "INVALID_ONION_HMAC": 9, + "INVALID_ONION_KEY": 10, + "AMOUNT_BELOW_MINIMUM": 11, + "FEE_INSUFFICIENT": 12, + "INCORRECT_CLTV_EXPIRY": 13, + "CHANNEL_DISABLED": 14, + "TEMPORARY_CHANNEL_FAILURE": 15, + "REQUIRED_NODE_FEATURE_MISSING": 16, + "REQUIRED_CHANNEL_FEATURE_MISSING": 17, + "UNKNOWN_NEXT_PEER": 18, + "TEMPORARY_NODE_FAILURE": 19, + "PERMANENT_NODE_FAILURE": 20, + "PERMANENT_CHANNEL_FAILURE": 21, + "EXPIRY_TOO_FAR": 22, + "MPP_TIMEOUT": 23, + "INTERNAL_FAILURE": 997, + "UNKNOWN_FAILURE": 998, + "UNREADABLE_FAILURE": 999, +} + +func (x Failure_FailureCode) String() string { + return proto.EnumName(Failure_FailureCode_name, int32(x)) +} + +func (Failure_FailureCode) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{157, 0} +} + +type Utxo struct { + // The type of address + AddressType AddressType `protobuf:"varint,1,opt,name=address_type,json=addressType,proto3,enum=lnrpc.AddressType" json:"address_type,omitempty"` + // The address + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + // The value of the unspent coin in satoshis + AmountSat int64 `protobuf:"varint,3,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"` + // The pkscript in hex + PkScript string `protobuf:"bytes,4,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"` + // The outpoint in format txid:n + Outpoint *OutPoint `protobuf:"bytes,5,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + // The number of confirmations for the Utxo + Confirmations int64 `protobuf:"varint,6,opt,name=confirmations,proto3" json:"confirmations,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Utxo) Reset() { *m = Utxo{} } +func (m *Utxo) String() string { return proto.CompactTextString(m) } +func (*Utxo) ProtoMessage() {} +func (*Utxo) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{0} +} + +func (m *Utxo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Utxo.Unmarshal(m, b) +} +func (m *Utxo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Utxo.Marshal(b, m, deterministic) +} +func (m *Utxo) XXX_Merge(src proto.Message) { + xxx_messageInfo_Utxo.Merge(m, src) +} +func (m *Utxo) XXX_Size() int { + return xxx_messageInfo_Utxo.Size(m) +} +func (m *Utxo) XXX_DiscardUnknown() { + xxx_messageInfo_Utxo.DiscardUnknown(m) +} + +var xxx_messageInfo_Utxo proto.InternalMessageInfo + +func (m *Utxo) GetAddressType() AddressType { + if m != nil { + return m.AddressType + } + return AddressType_WITNESS_PUBKEY_HASH +} + +func (m *Utxo) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *Utxo) GetAmountSat() int64 { + if m != nil { + return m.AmountSat + } + return 0 +} + +func (m *Utxo) GetPkScript() string { + if m != nil { + return m.PkScript + } + return "" +} + +func (m *Utxo) GetOutpoint() *OutPoint { + if m != nil { + return m.Outpoint + } + return nil +} + +func (m *Utxo) GetConfirmations() int64 { + if m != nil { + return m.Confirmations + } + return 0 +} + +type Transaction struct { + // The transaction hash + TxHash string `protobuf:"bytes,1,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"` + // The transaction amount, denominated in satoshis + Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` + // The number of confirmations + NumConfirmations int32 `protobuf:"varint,3,opt,name=num_confirmations,json=numConfirmations,proto3" json:"num_confirmations,omitempty"` + // The hash of the block this transaction was included in + BlockHash string `protobuf:"bytes,4,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` + // The height of the block this transaction was included in + BlockHeight int32 `protobuf:"varint,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + // Timestamp of this transaction + TimeStamp int64 `protobuf:"varint,6,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"` + // Fees paid for this transaction + TotalFees int64 `protobuf:"varint,7,opt,name=total_fees,json=totalFees,proto3" json:"total_fees,omitempty"` + // Addresses that received funds for this transaction + DestAddresses []string `protobuf:"bytes,8,rep,name=dest_addresses,json=destAddresses,proto3" json:"dest_addresses,omitempty"` + // The raw transaction hex. + RawTxHex string `protobuf:"bytes,9,opt,name=raw_tx_hex,json=rawTxHex,proto3" json:"raw_tx_hex,omitempty"` + // A label that was optionally set on transaction broadcast. + Label string `protobuf:"bytes,10,opt,name=label,proto3" json:"label,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Transaction) Reset() { *m = Transaction{} } +func (m *Transaction) String() string { return proto.CompactTextString(m) } +func (*Transaction) ProtoMessage() {} +func (*Transaction) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{1} +} + +func (m *Transaction) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Transaction.Unmarshal(m, b) +} +func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Transaction.Marshal(b, m, deterministic) +} +func (m *Transaction) XXX_Merge(src proto.Message) { + xxx_messageInfo_Transaction.Merge(m, src) +} +func (m *Transaction) XXX_Size() int { + return xxx_messageInfo_Transaction.Size(m) +} +func (m *Transaction) XXX_DiscardUnknown() { + xxx_messageInfo_Transaction.DiscardUnknown(m) +} + +var xxx_messageInfo_Transaction proto.InternalMessageInfo + +func (m *Transaction) GetTxHash() string { + if m != nil { + return m.TxHash + } + return "" +} + +func (m *Transaction) GetAmount() int64 { + if m != nil { + return m.Amount + } + return 0 +} + +func (m *Transaction) GetNumConfirmations() int32 { + if m != nil { + return m.NumConfirmations + } + return 0 +} + +func (m *Transaction) GetBlockHash() string { + if m != nil { + return m.BlockHash + } + return "" +} + +func (m *Transaction) GetBlockHeight() int32 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +func (m *Transaction) GetTimeStamp() int64 { + if m != nil { + return m.TimeStamp + } + return 0 +} + +func (m *Transaction) GetTotalFees() int64 { + if m != nil { + return m.TotalFees + } + return 0 +} + +func (m *Transaction) GetDestAddresses() []string { + if m != nil { + return m.DestAddresses + } + return nil +} + +func (m *Transaction) GetRawTxHex() string { + if m != nil { + return m.RawTxHex + } + return "" +} + +func (m *Transaction) GetLabel() string { + if m != nil { + return m.Label + } + return "" +} + +type GetTransactionsRequest struct { + // + //The height from which to list transactions, inclusive. If this value is + //greater than end_height, transactions will be read in reverse. + StartHeight int32 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` + // + //The height until which to list transactions, inclusive. To include + //unconfirmed transactions, this value should be set to -1, which will + //return transactions from start_height until the current chain tip and + //unconfirmed transactions. If no end_height is provided, the call will + //default to this option. + EndHeight int32 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetTransactionsRequest) Reset() { *m = GetTransactionsRequest{} } +func (m *GetTransactionsRequest) String() string { return proto.CompactTextString(m) } +func (*GetTransactionsRequest) ProtoMessage() {} +func (*GetTransactionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{2} +} + +func (m *GetTransactionsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetTransactionsRequest.Unmarshal(m, b) +} +func (m *GetTransactionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetTransactionsRequest.Marshal(b, m, deterministic) +} +func (m *GetTransactionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTransactionsRequest.Merge(m, src) +} +func (m *GetTransactionsRequest) XXX_Size() int { + return xxx_messageInfo_GetTransactionsRequest.Size(m) +} +func (m *GetTransactionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetTransactionsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetTransactionsRequest proto.InternalMessageInfo + +func (m *GetTransactionsRequest) GetStartHeight() int32 { + if m != nil { + return m.StartHeight + } + return 0 +} + +func (m *GetTransactionsRequest) GetEndHeight() int32 { + if m != nil { + return m.EndHeight + } + return 0 +} + +type TransactionDetails struct { + // The list of transactions relevant to the wallet. + Transactions []*Transaction `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TransactionDetails) Reset() { *m = TransactionDetails{} } +func (m *TransactionDetails) String() string { return proto.CompactTextString(m) } +func (*TransactionDetails) ProtoMessage() {} +func (*TransactionDetails) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{3} +} + +func (m *TransactionDetails) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TransactionDetails.Unmarshal(m, b) +} +func (m *TransactionDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TransactionDetails.Marshal(b, m, deterministic) +} +func (m *TransactionDetails) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionDetails.Merge(m, src) +} +func (m *TransactionDetails) XXX_Size() int { + return xxx_messageInfo_TransactionDetails.Size(m) +} +func (m *TransactionDetails) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionDetails.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionDetails proto.InternalMessageInfo + +func (m *TransactionDetails) GetTransactions() []*Transaction { + if m != nil { + return m.Transactions + } + return nil +} + +type FeeLimit struct { + // Types that are valid to be assigned to Limit: + // *FeeLimit_Fixed + // *FeeLimit_FixedMsat + // *FeeLimit_Percent + Limit isFeeLimit_Limit `protobuf_oneof:"limit"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FeeLimit) Reset() { *m = FeeLimit{} } +func (m *FeeLimit) String() string { return proto.CompactTextString(m) } +func (*FeeLimit) ProtoMessage() {} +func (*FeeLimit) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{4} +} + +func (m *FeeLimit) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FeeLimit.Unmarshal(m, b) +} +func (m *FeeLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FeeLimit.Marshal(b, m, deterministic) +} +func (m *FeeLimit) XXX_Merge(src proto.Message) { + xxx_messageInfo_FeeLimit.Merge(m, src) +} +func (m *FeeLimit) XXX_Size() int { + return xxx_messageInfo_FeeLimit.Size(m) +} +func (m *FeeLimit) XXX_DiscardUnknown() { + xxx_messageInfo_FeeLimit.DiscardUnknown(m) +} + +var xxx_messageInfo_FeeLimit proto.InternalMessageInfo + +type isFeeLimit_Limit interface { + isFeeLimit_Limit() +} + +type FeeLimit_Fixed struct { + Fixed int64 `protobuf:"varint,1,opt,name=fixed,proto3,oneof"` +} + +type FeeLimit_FixedMsat struct { + FixedMsat int64 `protobuf:"varint,3,opt,name=fixed_msat,json=fixedMsat,proto3,oneof"` +} + +type FeeLimit_Percent struct { + Percent int64 `protobuf:"varint,2,opt,name=percent,proto3,oneof"` +} + +func (*FeeLimit_Fixed) isFeeLimit_Limit() {} + +func (*FeeLimit_FixedMsat) isFeeLimit_Limit() {} + +func (*FeeLimit_Percent) isFeeLimit_Limit() {} + +func (m *FeeLimit) GetLimit() isFeeLimit_Limit { + if m != nil { + return m.Limit + } + return nil +} + +func (m *FeeLimit) GetFixed() int64 { + if x, ok := m.GetLimit().(*FeeLimit_Fixed); ok { + return x.Fixed + } + return 0 +} + +func (m *FeeLimit) GetFixedMsat() int64 { + if x, ok := m.GetLimit().(*FeeLimit_FixedMsat); ok { + return x.FixedMsat + } + return 0 +} + +func (m *FeeLimit) GetPercent() int64 { + if x, ok := m.GetLimit().(*FeeLimit_Percent); ok { + return x.Percent + } + return 0 +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*FeeLimit) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*FeeLimit_Fixed)(nil), + (*FeeLimit_FixedMsat)(nil), + (*FeeLimit_Percent)(nil), + } +} + +type SendRequest struct { + // + //The identity pubkey of the payment recipient. When using REST, this field + //must be encoded as base64. + Dest []byte `protobuf:"bytes,1,opt,name=dest,proto3" json:"dest,omitempty"` + // + //The hex-encoded identity pubkey of the payment recipient. Deprecated now + //that the REST gateway supports base64 encoding of bytes fields. + DestString string `protobuf:"bytes,2,opt,name=dest_string,json=destString,proto3" json:"dest_string,omitempty"` // Deprecated: Do not use. + // + //The amount to send expressed in satoshis. + // + //The fields amt and amt_msat are mutually exclusive. + Amt int64 `protobuf:"varint,3,opt,name=amt,proto3" json:"amt,omitempty"` + // + //The amount to send expressed in millisatoshis. + // + //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 hash to use within the payment's HTLC. When using REST, this field + //must be encoded as base64. + PaymentHash []byte `protobuf:"bytes,4,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + // + //The hex-encoded hash to use within the payment's HTLC. Deprecated now + //that the REST gateway supports base64 encoding of bytes fields. + PaymentHashString string `protobuf:"bytes,5,opt,name=payment_hash_string,json=paymentHashString,proto3" json:"payment_hash_string,omitempty"` // Deprecated: Do not use. + // + //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. + PaymentRequest string `protobuf:"bytes,6,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` + // + //The CLTV delta from the current height that should be used to set the + //timelock for the final hop. + FinalCltvDelta int32 `protobuf:"varint,7,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"` + // + //The maximum number of satoshis that will be paid as a fee of the payment. + //This value can be represented either as a percentage of the amount being + //sent, or as a fixed amount of the maximum fee the user is willing the pay to + //send the payment. + FeeLimit *FeeLimit `protobuf:"bytes,8,opt,name=fee_limit,json=feeLimit,proto3" json:"fee_limit,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,9,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"` + // + //The pubkey of the last hop of the route. If empty, any hop may be used. + LastHopPubkey []byte `protobuf:"bytes,13,opt,name=last_hop_pubkey,json=lastHopPubkey,proto3" json:"last_hop_pubkey,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 uint32 `protobuf:"varint,10,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,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 `protobuf:"bytes,11,rep,name=dest_custom_records,json=destCustomRecords,proto3" json:"dest_custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // If set, circular payments to self are permitted. + AllowSelfPayment bool `protobuf:"varint,14,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 []FeatureBit `protobuf:"varint,15,rep,packed,name=dest_features,json=destFeatures,proto3,enum=lnrpc.FeatureBit" json:"dest_features,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendRequest) Reset() { *m = SendRequest{} } +func (m *SendRequest) String() string { return proto.CompactTextString(m) } +func (*SendRequest) ProtoMessage() {} +func (*SendRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{5} +} + +func (m *SendRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendRequest.Unmarshal(m, b) +} +func (m *SendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendRequest.Marshal(b, m, deterministic) +} +func (m *SendRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendRequest.Merge(m, src) +} +func (m *SendRequest) XXX_Size() int { + return xxx_messageInfo_SendRequest.Size(m) +} +func (m *SendRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SendRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SendRequest proto.InternalMessageInfo + +func (m *SendRequest) GetDest() []byte { + if m != nil { + return m.Dest + } + return nil +} + +// Deprecated: Do not use. +func (m *SendRequest) GetDestString() string { + if m != nil { + return m.DestString + } + return "" +} + +func (m *SendRequest) GetAmt() int64 { + if m != nil { + return m.Amt + } + return 0 +} + +func (m *SendRequest) GetAmtMsat() int64 { + if m != nil { + return m.AmtMsat + } + return 0 +} + +func (m *SendRequest) GetPaymentHash() []byte { + if m != nil { + return m.PaymentHash + } + return nil +} + +// Deprecated: Do not use. +func (m *SendRequest) GetPaymentHashString() string { + if m != nil { + return m.PaymentHashString + } + return "" +} + +func (m *SendRequest) GetPaymentRequest() string { + if m != nil { + return m.PaymentRequest + } + return "" +} + +func (m *SendRequest) GetFinalCltvDelta() int32 { + if m != nil { + return m.FinalCltvDelta + } + return 0 +} + +func (m *SendRequest) GetFeeLimit() *FeeLimit { + if m != nil { + return m.FeeLimit + } + return nil +} + +func (m *SendRequest) GetOutgoingChanId() uint64 { + if m != nil { + return m.OutgoingChanId + } + return 0 +} + +func (m *SendRequest) GetLastHopPubkey() []byte { + if m != nil { + return m.LastHopPubkey + } + return nil +} + +func (m *SendRequest) GetCltvLimit() uint32 { + if m != nil { + return m.CltvLimit + } + return 0 +} + +func (m *SendRequest) GetDestCustomRecords() map[uint64][]byte { + if m != nil { + return m.DestCustomRecords + } + return nil +} + +func (m *SendRequest) GetAllowSelfPayment() bool { + if m != nil { + return m.AllowSelfPayment + } + return false +} + +func (m *SendRequest) GetDestFeatures() []FeatureBit { + if m != nil { + return m.DestFeatures + } + return nil +} + +type SendResponse struct { + PaymentError string `protobuf:"bytes,1,opt,name=payment_error,json=paymentError,proto3" json:"payment_error,omitempty"` + PaymentPreimage []byte `protobuf:"bytes,2,opt,name=payment_preimage,json=paymentPreimage,proto3" json:"payment_preimage,omitempty"` + PaymentRoute *Route `protobuf:"bytes,3,opt,name=payment_route,json=paymentRoute,proto3" json:"payment_route,omitempty"` + PaymentHash []byte `protobuf:"bytes,4,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendResponse) Reset() { *m = SendResponse{} } +func (m *SendResponse) String() string { return proto.CompactTextString(m) } +func (*SendResponse) ProtoMessage() {} +func (*SendResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{6} +} + +func (m *SendResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendResponse.Unmarshal(m, b) +} +func (m *SendResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendResponse.Marshal(b, m, deterministic) +} +func (m *SendResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendResponse.Merge(m, src) +} +func (m *SendResponse) XXX_Size() int { + return xxx_messageInfo_SendResponse.Size(m) +} +func (m *SendResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SendResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SendResponse proto.InternalMessageInfo + +func (m *SendResponse) GetPaymentError() string { + if m != nil { + return m.PaymentError + } + return "" +} + +func (m *SendResponse) GetPaymentPreimage() []byte { + if m != nil { + return m.PaymentPreimage + } + return nil +} + +func (m *SendResponse) GetPaymentRoute() *Route { + if m != nil { + return m.PaymentRoute + } + return nil +} + +func (m *SendResponse) GetPaymentHash() []byte { + if m != nil { + return m.PaymentHash + } + return nil +} + +type SendToRouteRequest struct { + // + //The payment hash to use for the HTLC. When using REST, this field must be + //encoded as base64. + PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + // + //An optional hex-encoded payment hash to be used for the HTLC. Deprecated now + //that the REST gateway supports base64 encoding of bytes fields. + PaymentHashString string `protobuf:"bytes,2,opt,name=payment_hash_string,json=paymentHashString,proto3" json:"payment_hash_string,omitempty"` // Deprecated: Do not use. + // Route that should be used to attempt to complete the payment. + Route *Route `protobuf:"bytes,4,opt,name=route,proto3" json:"route,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendToRouteRequest) Reset() { *m = SendToRouteRequest{} } +func (m *SendToRouteRequest) String() string { return proto.CompactTextString(m) } +func (*SendToRouteRequest) ProtoMessage() {} +func (*SendToRouteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{7} +} + +func (m *SendToRouteRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendToRouteRequest.Unmarshal(m, b) +} +func (m *SendToRouteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendToRouteRequest.Marshal(b, m, deterministic) +} +func (m *SendToRouteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendToRouteRequest.Merge(m, src) +} +func (m *SendToRouteRequest) XXX_Size() int { + return xxx_messageInfo_SendToRouteRequest.Size(m) +} +func (m *SendToRouteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SendToRouteRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SendToRouteRequest proto.InternalMessageInfo + +func (m *SendToRouteRequest) GetPaymentHash() []byte { + if m != nil { + return m.PaymentHash + } + return nil +} + +// Deprecated: Do not use. +func (m *SendToRouteRequest) GetPaymentHashString() string { + if m != nil { + return m.PaymentHashString + } + return "" +} + +func (m *SendToRouteRequest) GetRoute() *Route { + if m != nil { + return m.Route + } + return nil +} + +type ChannelAcceptRequest struct { + // The pubkey of the node that wishes to open an inbound channel. + NodePubkey []byte `protobuf:"bytes,1,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"` + // The hash of the genesis block that the proposed channel resides in. + ChainHash []byte `protobuf:"bytes,2,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` + // The pending channel id. + PendingChanId []byte `protobuf:"bytes,3,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + // The funding amount in satoshis that initiator wishes to use in the + // channel. + FundingAmt uint64 `protobuf:"varint,4,opt,name=funding_amt,json=fundingAmt,proto3" json:"funding_amt,omitempty"` + // The push amount of the proposed channel in millisatoshis. + PushAmt uint64 `protobuf:"varint,5,opt,name=push_amt,json=pushAmt,proto3" json:"push_amt,omitempty"` + // The dust limit of the initiator's commitment tx. + DustLimit uint64 `protobuf:"varint,6,opt,name=dust_limit,json=dustLimit,proto3" json:"dust_limit,omitempty"` + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + MaxValueInFlight uint64 `protobuf:"varint,7,opt,name=max_value_in_flight,json=maxValueInFlight,proto3" json:"max_value_in_flight,omitempty"` + // The minimum amount of satoshis the initiator requires us to have at all + // times. + ChannelReserve uint64 `protobuf:"varint,8,opt,name=channel_reserve,json=channelReserve,proto3" json:"channel_reserve,omitempty"` + // The smallest HTLC in millisatoshis that the initiator will accept. + MinHtlc uint64 `protobuf:"varint,9,opt,name=min_htlc,json=minHtlc,proto3" json:"min_htlc,omitempty"` + // The initial fee rate that the initiator suggests for both commitment + // transactions. + FeePerKw uint64 `protobuf:"varint,10,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` + // + //The number of blocks to use for the relative time lock in the pay-to-self + //output of both commitment transactions. + CsvDelay uint32 `protobuf:"varint,11,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` + // The total number of incoming HTLC's that the initiator will accept. + MaxAcceptedHtlcs uint32 `protobuf:"varint,12,opt,name=max_accepted_htlcs,json=maxAcceptedHtlcs,proto3" json:"max_accepted_htlcs,omitempty"` + // A bit-field which the initiator uses to specify proposed channel + // behavior. + ChannelFlags uint32 `protobuf:"varint,13,opt,name=channel_flags,json=channelFlags,proto3" json:"channel_flags,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelAcceptRequest) Reset() { *m = ChannelAcceptRequest{} } +func (m *ChannelAcceptRequest) String() string { return proto.CompactTextString(m) } +func (*ChannelAcceptRequest) ProtoMessage() {} +func (*ChannelAcceptRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{8} +} + +func (m *ChannelAcceptRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelAcceptRequest.Unmarshal(m, b) +} +func (m *ChannelAcceptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelAcceptRequest.Marshal(b, m, deterministic) +} +func (m *ChannelAcceptRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelAcceptRequest.Merge(m, src) +} +func (m *ChannelAcceptRequest) XXX_Size() int { + return xxx_messageInfo_ChannelAcceptRequest.Size(m) +} +func (m *ChannelAcceptRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelAcceptRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelAcceptRequest proto.InternalMessageInfo + +func (m *ChannelAcceptRequest) GetNodePubkey() []byte { + if m != nil { + return m.NodePubkey + } + return nil +} + +func (m *ChannelAcceptRequest) GetChainHash() []byte { + if m != nil { + return m.ChainHash + } + return nil +} + +func (m *ChannelAcceptRequest) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +func (m *ChannelAcceptRequest) GetFundingAmt() uint64 { + if m != nil { + return m.FundingAmt + } + return 0 +} + +func (m *ChannelAcceptRequest) GetPushAmt() uint64 { + if m != nil { + return m.PushAmt + } + return 0 +} + +func (m *ChannelAcceptRequest) GetDustLimit() uint64 { + if m != nil { + return m.DustLimit + } + return 0 +} + +func (m *ChannelAcceptRequest) GetMaxValueInFlight() uint64 { + if m != nil { + return m.MaxValueInFlight + } + return 0 +} + +func (m *ChannelAcceptRequest) GetChannelReserve() uint64 { + if m != nil { + return m.ChannelReserve + } + return 0 +} + +func (m *ChannelAcceptRequest) GetMinHtlc() uint64 { + if m != nil { + return m.MinHtlc + } + return 0 +} + +func (m *ChannelAcceptRequest) GetFeePerKw() uint64 { + if m != nil { + return m.FeePerKw + } + return 0 +} + +func (m *ChannelAcceptRequest) GetCsvDelay() uint32 { + if m != nil { + return m.CsvDelay + } + return 0 +} + +func (m *ChannelAcceptRequest) GetMaxAcceptedHtlcs() uint32 { + if m != nil { + return m.MaxAcceptedHtlcs + } + return 0 +} + +func (m *ChannelAcceptRequest) GetChannelFlags() uint32 { + if m != nil { + return m.ChannelFlags + } + return 0 +} + +type ChannelAcceptResponse struct { + // Whether or not the client accepts the channel. + Accept bool `protobuf:"varint,1,opt,name=accept,proto3" json:"accept,omitempty"` + // The pending channel id to which this response applies. + PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelAcceptResponse) Reset() { *m = ChannelAcceptResponse{} } +func (m *ChannelAcceptResponse) String() string { return proto.CompactTextString(m) } +func (*ChannelAcceptResponse) ProtoMessage() {} +func (*ChannelAcceptResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{9} +} + +func (m *ChannelAcceptResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelAcceptResponse.Unmarshal(m, b) +} +func (m *ChannelAcceptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelAcceptResponse.Marshal(b, m, deterministic) +} +func (m *ChannelAcceptResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelAcceptResponse.Merge(m, src) +} +func (m *ChannelAcceptResponse) XXX_Size() int { + return xxx_messageInfo_ChannelAcceptResponse.Size(m) +} +func (m *ChannelAcceptResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelAcceptResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelAcceptResponse proto.InternalMessageInfo + +func (m *ChannelAcceptResponse) GetAccept() bool { + if m != nil { + return m.Accept + } + return false +} + +func (m *ChannelAcceptResponse) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +type ChannelPoint struct { + // Types that are valid to be assigned to FundingTxid: + // *ChannelPoint_FundingTxidBytes + // *ChannelPoint_FundingTxidStr + FundingTxid isChannelPoint_FundingTxid `protobuf_oneof:"funding_txid"` + // The index of the output of the funding transaction + OutputIndex uint32 `protobuf:"varint,3,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelPoint) Reset() { *m = ChannelPoint{} } +func (m *ChannelPoint) String() string { return proto.CompactTextString(m) } +func (*ChannelPoint) ProtoMessage() {} +func (*ChannelPoint) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{10} +} + +func (m *ChannelPoint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelPoint.Unmarshal(m, b) +} +func (m *ChannelPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelPoint.Marshal(b, m, deterministic) +} +func (m *ChannelPoint) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelPoint.Merge(m, src) +} +func (m *ChannelPoint) XXX_Size() int { + return xxx_messageInfo_ChannelPoint.Size(m) +} +func (m *ChannelPoint) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelPoint.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelPoint proto.InternalMessageInfo + +type isChannelPoint_FundingTxid interface { + isChannelPoint_FundingTxid() +} + +type ChannelPoint_FundingTxidBytes struct { + FundingTxidBytes []byte `protobuf:"bytes,1,opt,name=funding_txid_bytes,json=fundingTxidBytes,proto3,oneof"` +} + +type ChannelPoint_FundingTxidStr struct { + FundingTxidStr string `protobuf:"bytes,2,opt,name=funding_txid_str,json=fundingTxidStr,proto3,oneof"` +} + +func (*ChannelPoint_FundingTxidBytes) isChannelPoint_FundingTxid() {} + +func (*ChannelPoint_FundingTxidStr) isChannelPoint_FundingTxid() {} + +func (m *ChannelPoint) GetFundingTxid() isChannelPoint_FundingTxid { + if m != nil { + return m.FundingTxid + } + return nil +} + +func (m *ChannelPoint) GetFundingTxidBytes() []byte { + if x, ok := m.GetFundingTxid().(*ChannelPoint_FundingTxidBytes); ok { + return x.FundingTxidBytes + } + return nil +} + +func (m *ChannelPoint) GetFundingTxidStr() string { + if x, ok := m.GetFundingTxid().(*ChannelPoint_FundingTxidStr); ok { + return x.FundingTxidStr + } + return "" +} + +func (m *ChannelPoint) GetOutputIndex() uint32 { + if m != nil { + return m.OutputIndex + } + return 0 +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ChannelPoint) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ChannelPoint_FundingTxidBytes)(nil), + (*ChannelPoint_FundingTxidStr)(nil), + } +} + +type OutPoint struct { + // Raw bytes representing the transaction id. + TxidBytes []byte `protobuf:"bytes,1,opt,name=txid_bytes,json=txidBytes,proto3" json:"txid_bytes,omitempty"` + // Reversed, hex-encoded string representing the transaction id. + TxidStr string `protobuf:"bytes,2,opt,name=txid_str,json=txidStr,proto3" json:"txid_str,omitempty"` + // The index of the output on the transaction. + OutputIndex uint32 `protobuf:"varint,3,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *OutPoint) Reset() { *m = OutPoint{} } +func (m *OutPoint) String() string { return proto.CompactTextString(m) } +func (*OutPoint) ProtoMessage() {} +func (*OutPoint) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{11} +} + +func (m *OutPoint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_OutPoint.Unmarshal(m, b) +} +func (m *OutPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_OutPoint.Marshal(b, m, deterministic) +} +func (m *OutPoint) XXX_Merge(src proto.Message) { + xxx_messageInfo_OutPoint.Merge(m, src) +} +func (m *OutPoint) XXX_Size() int { + return xxx_messageInfo_OutPoint.Size(m) +} +func (m *OutPoint) XXX_DiscardUnknown() { + xxx_messageInfo_OutPoint.DiscardUnknown(m) +} + +var xxx_messageInfo_OutPoint proto.InternalMessageInfo + +func (m *OutPoint) GetTxidBytes() []byte { + if m != nil { + return m.TxidBytes + } + return nil +} + +func (m *OutPoint) GetTxidStr() string { + if m != nil { + return m.TxidStr + } + return "" +} + +func (m *OutPoint) GetOutputIndex() uint32 { + if m != nil { + return m.OutputIndex + } + return 0 +} + +type LightningAddress struct { + // The identity pubkey of the Lightning node + Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` + // The network location of the lightning node, e.g. `69.69.69.69:1337` or + // `localhost:10011` + Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LightningAddress) Reset() { *m = LightningAddress{} } +func (m *LightningAddress) String() string { return proto.CompactTextString(m) } +func (*LightningAddress) ProtoMessage() {} +func (*LightningAddress) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{12} +} + +func (m *LightningAddress) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LightningAddress.Unmarshal(m, b) +} +func (m *LightningAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LightningAddress.Marshal(b, m, deterministic) +} +func (m *LightningAddress) XXX_Merge(src proto.Message) { + xxx_messageInfo_LightningAddress.Merge(m, src) +} +func (m *LightningAddress) XXX_Size() int { + return xxx_messageInfo_LightningAddress.Size(m) +} +func (m *LightningAddress) XXX_DiscardUnknown() { + xxx_messageInfo_LightningAddress.DiscardUnknown(m) +} + +var xxx_messageInfo_LightningAddress proto.InternalMessageInfo + +func (m *LightningAddress) GetPubkey() string { + if m != nil { + return m.Pubkey + } + return "" +} + +func (m *LightningAddress) GetHost() string { + if m != nil { + return m.Host + } + return "" +} + +type EstimateFeeRequest struct { + // The map from addresses to amounts for the transaction. + AddrToAmount map[string]int64 `protobuf:"bytes,1,rep,name=AddrToAmount,proto3" json:"AddrToAmount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + // The target number of blocks that this transaction should be confirmed + // by. + TargetConf int32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EstimateFeeRequest) Reset() { *m = EstimateFeeRequest{} } +func (m *EstimateFeeRequest) String() string { return proto.CompactTextString(m) } +func (*EstimateFeeRequest) ProtoMessage() {} +func (*EstimateFeeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{13} +} + +func (m *EstimateFeeRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EstimateFeeRequest.Unmarshal(m, b) +} +func (m *EstimateFeeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EstimateFeeRequest.Marshal(b, m, deterministic) +} +func (m *EstimateFeeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EstimateFeeRequest.Merge(m, src) +} +func (m *EstimateFeeRequest) XXX_Size() int { + return xxx_messageInfo_EstimateFeeRequest.Size(m) +} +func (m *EstimateFeeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_EstimateFeeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_EstimateFeeRequest proto.InternalMessageInfo + +func (m *EstimateFeeRequest) GetAddrToAmount() map[string]int64 { + if m != nil { + return m.AddrToAmount + } + return nil +} + +func (m *EstimateFeeRequest) GetTargetConf() int32 { + if m != nil { + return m.TargetConf + } + return 0 +} + +type EstimateFeeResponse struct { + // The total fee in satoshis. + FeeSat int64 `protobuf:"varint,1,opt,name=fee_sat,json=feeSat,proto3" json:"fee_sat,omitempty"` + // The fee rate in satoshi/byte. + FeerateSatPerByte int64 `protobuf:"varint,2,opt,name=feerate_sat_per_byte,json=feerateSatPerByte,proto3" json:"feerate_sat_per_byte,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EstimateFeeResponse) Reset() { *m = EstimateFeeResponse{} } +func (m *EstimateFeeResponse) String() string { return proto.CompactTextString(m) } +func (*EstimateFeeResponse) ProtoMessage() {} +func (*EstimateFeeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{14} +} + +func (m *EstimateFeeResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EstimateFeeResponse.Unmarshal(m, b) +} +func (m *EstimateFeeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EstimateFeeResponse.Marshal(b, m, deterministic) +} +func (m *EstimateFeeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EstimateFeeResponse.Merge(m, src) +} +func (m *EstimateFeeResponse) XXX_Size() int { + return xxx_messageInfo_EstimateFeeResponse.Size(m) +} +func (m *EstimateFeeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_EstimateFeeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_EstimateFeeResponse proto.InternalMessageInfo + +func (m *EstimateFeeResponse) GetFeeSat() int64 { + if m != nil { + return m.FeeSat + } + return 0 +} + +func (m *EstimateFeeResponse) GetFeerateSatPerByte() int64 { + if m != nil { + return m.FeerateSatPerByte + } + return 0 +} + +type SendManyRequest struct { + // The map from addresses to amounts + AddrToAmount map[string]int64 `protobuf:"bytes,1,rep,name=AddrToAmount,proto3" json:"AddrToAmount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + // The target number of blocks that this transaction should be confirmed + // by. + TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` + // A manual fee rate set in sat/byte that should be used when crafting the + // transaction. + SatPerByte int64 `protobuf:"varint,5,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` + // An optional label for the transaction, limited to 500 characters. + Label string `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendManyRequest) Reset() { *m = SendManyRequest{} } +func (m *SendManyRequest) String() string { return proto.CompactTextString(m) } +func (*SendManyRequest) ProtoMessage() {} +func (*SendManyRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{15} +} + +func (m *SendManyRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendManyRequest.Unmarshal(m, b) +} +func (m *SendManyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendManyRequest.Marshal(b, m, deterministic) +} +func (m *SendManyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendManyRequest.Merge(m, src) +} +func (m *SendManyRequest) XXX_Size() int { + return xxx_messageInfo_SendManyRequest.Size(m) +} +func (m *SendManyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SendManyRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SendManyRequest proto.InternalMessageInfo + +func (m *SendManyRequest) GetAddrToAmount() map[string]int64 { + if m != nil { + return m.AddrToAmount + } + return nil +} + +func (m *SendManyRequest) GetTargetConf() int32 { + if m != nil { + return m.TargetConf + } + return 0 +} + +func (m *SendManyRequest) GetSatPerByte() int64 { + if m != nil { + return m.SatPerByte + } + return 0 +} + +func (m *SendManyRequest) GetLabel() string { + if m != nil { + return m.Label + } + return "" +} + +type SendManyResponse struct { + // The id of the transaction + Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendManyResponse) Reset() { *m = SendManyResponse{} } +func (m *SendManyResponse) String() string { return proto.CompactTextString(m) } +func (*SendManyResponse) ProtoMessage() {} +func (*SendManyResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{16} +} + +func (m *SendManyResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendManyResponse.Unmarshal(m, b) +} +func (m *SendManyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendManyResponse.Marshal(b, m, deterministic) +} +func (m *SendManyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendManyResponse.Merge(m, src) +} +func (m *SendManyResponse) XXX_Size() int { + return xxx_messageInfo_SendManyResponse.Size(m) +} +func (m *SendManyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SendManyResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SendManyResponse proto.InternalMessageInfo + +func (m *SendManyResponse) GetTxid() string { + if m != nil { + return m.Txid + } + return "" +} + +type SendCoinsRequest struct { + // The address to send coins to + Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"` + // The amount in satoshis to send + Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` + // The target number of blocks that this transaction should be confirmed + // by. + TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` + // A manual fee rate set in sat/byte that should be used when crafting the + // transaction. + SatPerByte int64 `protobuf:"varint,5,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` + // + //If set, then the amount field will be ignored, and lnd will attempt to + //send all the coins under control of the internal wallet to the specified + //address. + SendAll bool `protobuf:"varint,6,opt,name=send_all,json=sendAll,proto3" json:"send_all,omitempty"` + // An optional label for the transaction, limited to 500 characters. + Label string `protobuf:"bytes,7,opt,name=label,proto3" json:"label,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendCoinsRequest) Reset() { *m = SendCoinsRequest{} } +func (m *SendCoinsRequest) String() string { return proto.CompactTextString(m) } +func (*SendCoinsRequest) ProtoMessage() {} +func (*SendCoinsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{17} +} + +func (m *SendCoinsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendCoinsRequest.Unmarshal(m, b) +} +func (m *SendCoinsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendCoinsRequest.Marshal(b, m, deterministic) +} +func (m *SendCoinsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendCoinsRequest.Merge(m, src) +} +func (m *SendCoinsRequest) XXX_Size() int { + return xxx_messageInfo_SendCoinsRequest.Size(m) +} +func (m *SendCoinsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SendCoinsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SendCoinsRequest proto.InternalMessageInfo + +func (m *SendCoinsRequest) GetAddr() string { + if m != nil { + return m.Addr + } + return "" +} + +func (m *SendCoinsRequest) GetAmount() int64 { + if m != nil { + return m.Amount + } + return 0 +} + +func (m *SendCoinsRequest) GetTargetConf() int32 { + if m != nil { + return m.TargetConf + } + return 0 +} + +func (m *SendCoinsRequest) GetSatPerByte() int64 { + if m != nil { + return m.SatPerByte + } + return 0 +} + +func (m *SendCoinsRequest) GetSendAll() bool { + if m != nil { + return m.SendAll + } + return false +} + +func (m *SendCoinsRequest) GetLabel() string { + if m != nil { + return m.Label + } + return "" +} + +type SendCoinsResponse struct { + // The transaction ID of the transaction + Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SendCoinsResponse) Reset() { *m = SendCoinsResponse{} } +func (m *SendCoinsResponse) String() string { return proto.CompactTextString(m) } +func (*SendCoinsResponse) ProtoMessage() {} +func (*SendCoinsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{18} +} + +func (m *SendCoinsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SendCoinsResponse.Unmarshal(m, b) +} +func (m *SendCoinsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SendCoinsResponse.Marshal(b, m, deterministic) +} +func (m *SendCoinsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SendCoinsResponse.Merge(m, src) +} +func (m *SendCoinsResponse) XXX_Size() int { + return xxx_messageInfo_SendCoinsResponse.Size(m) +} +func (m *SendCoinsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SendCoinsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SendCoinsResponse proto.InternalMessageInfo + +func (m *SendCoinsResponse) GetTxid() string { + if m != nil { + return m.Txid + } + return "" +} + +type ListUnspentRequest struct { + // The minimum number of confirmations to be included. + MinConfs int32 `protobuf:"varint,1,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` + // The maximum number of confirmations to be included. + MaxConfs int32 `protobuf:"varint,2,opt,name=max_confs,json=maxConfs,proto3" json:"max_confs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListUnspentRequest) Reset() { *m = ListUnspentRequest{} } +func (m *ListUnspentRequest) String() string { return proto.CompactTextString(m) } +func (*ListUnspentRequest) ProtoMessage() {} +func (*ListUnspentRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{19} +} + +func (m *ListUnspentRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListUnspentRequest.Unmarshal(m, b) +} +func (m *ListUnspentRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListUnspentRequest.Marshal(b, m, deterministic) +} +func (m *ListUnspentRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListUnspentRequest.Merge(m, src) +} +func (m *ListUnspentRequest) XXX_Size() int { + return xxx_messageInfo_ListUnspentRequest.Size(m) +} +func (m *ListUnspentRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListUnspentRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListUnspentRequest proto.InternalMessageInfo + +func (m *ListUnspentRequest) GetMinConfs() int32 { + if m != nil { + return m.MinConfs + } + return 0 +} + +func (m *ListUnspentRequest) GetMaxConfs() int32 { + if m != nil { + return m.MaxConfs + } + return 0 +} + +type ListUnspentResponse struct { + // A list of utxos + Utxos []*Utxo `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListUnspentResponse) Reset() { *m = ListUnspentResponse{} } +func (m *ListUnspentResponse) String() string { return proto.CompactTextString(m) } +func (*ListUnspentResponse) ProtoMessage() {} +func (*ListUnspentResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{20} +} + +func (m *ListUnspentResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListUnspentResponse.Unmarshal(m, b) +} +func (m *ListUnspentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListUnspentResponse.Marshal(b, m, deterministic) +} +func (m *ListUnspentResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListUnspentResponse.Merge(m, src) +} +func (m *ListUnspentResponse) XXX_Size() int { + return xxx_messageInfo_ListUnspentResponse.Size(m) +} +func (m *ListUnspentResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListUnspentResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListUnspentResponse proto.InternalMessageInfo + +func (m *ListUnspentResponse) GetUtxos() []*Utxo { + if m != nil { + return m.Utxos + } + return nil +} + +type NewAddressRequest struct { + // The address type + Type AddressType `protobuf:"varint,1,opt,name=type,proto3,enum=lnrpc.AddressType" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NewAddressRequest) Reset() { *m = NewAddressRequest{} } +func (m *NewAddressRequest) String() string { return proto.CompactTextString(m) } +func (*NewAddressRequest) ProtoMessage() {} +func (*NewAddressRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{21} +} + +func (m *NewAddressRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NewAddressRequest.Unmarshal(m, b) +} +func (m *NewAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NewAddressRequest.Marshal(b, m, deterministic) +} +func (m *NewAddressRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NewAddressRequest.Merge(m, src) +} +func (m *NewAddressRequest) XXX_Size() int { + return xxx_messageInfo_NewAddressRequest.Size(m) +} +func (m *NewAddressRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NewAddressRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NewAddressRequest proto.InternalMessageInfo + +func (m *NewAddressRequest) GetType() AddressType { + if m != nil { + return m.Type + } + return AddressType_WITNESS_PUBKEY_HASH +} + +type NewAddressResponse struct { + // The newly generated wallet address + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NewAddressResponse) Reset() { *m = NewAddressResponse{} } +func (m *NewAddressResponse) String() string { return proto.CompactTextString(m) } +func (*NewAddressResponse) ProtoMessage() {} +func (*NewAddressResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{22} +} + +func (m *NewAddressResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NewAddressResponse.Unmarshal(m, b) +} +func (m *NewAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NewAddressResponse.Marshal(b, m, deterministic) +} +func (m *NewAddressResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_NewAddressResponse.Merge(m, src) +} +func (m *NewAddressResponse) XXX_Size() int { + return xxx_messageInfo_NewAddressResponse.Size(m) +} +func (m *NewAddressResponse) XXX_DiscardUnknown() { + xxx_messageInfo_NewAddressResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_NewAddressResponse proto.InternalMessageInfo + +func (m *NewAddressResponse) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +type SignMessageRequest struct { + // + //The message to be signed. When using REST, this field must be encoded as + //base64. + Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SignMessageRequest) Reset() { *m = SignMessageRequest{} } +func (m *SignMessageRequest) String() string { return proto.CompactTextString(m) } +func (*SignMessageRequest) ProtoMessage() {} +func (*SignMessageRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{23} +} + +func (m *SignMessageRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SignMessageRequest.Unmarshal(m, b) +} +func (m *SignMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SignMessageRequest.Marshal(b, m, deterministic) +} +func (m *SignMessageRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignMessageRequest.Merge(m, src) +} +func (m *SignMessageRequest) XXX_Size() int { + return xxx_messageInfo_SignMessageRequest.Size(m) +} +func (m *SignMessageRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SignMessageRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SignMessageRequest proto.InternalMessageInfo + +func (m *SignMessageRequest) GetMsg() []byte { + if m != nil { + return m.Msg + } + return nil +} + +type SignMessageResponse struct { + // The signature for the given message + Signature string `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SignMessageResponse) Reset() { *m = SignMessageResponse{} } +func (m *SignMessageResponse) String() string { return proto.CompactTextString(m) } +func (*SignMessageResponse) ProtoMessage() {} +func (*SignMessageResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{24} +} + +func (m *SignMessageResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SignMessageResponse.Unmarshal(m, b) +} +func (m *SignMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SignMessageResponse.Marshal(b, m, deterministic) +} +func (m *SignMessageResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SignMessageResponse.Merge(m, src) +} +func (m *SignMessageResponse) XXX_Size() int { + return xxx_messageInfo_SignMessageResponse.Size(m) +} +func (m *SignMessageResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SignMessageResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SignMessageResponse proto.InternalMessageInfo + +func (m *SignMessageResponse) GetSignature() string { + if m != nil { + return m.Signature + } + return "" +} + +type VerifyMessageRequest struct { + // + //The message over which the signature is to be verified. When using REST, + //this field must be encoded as base64. + Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` + // The signature to be verified over the given message + Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *VerifyMessageRequest) Reset() { *m = VerifyMessageRequest{} } +func (m *VerifyMessageRequest) String() string { return proto.CompactTextString(m) } +func (*VerifyMessageRequest) ProtoMessage() {} +func (*VerifyMessageRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{25} +} + +func (m *VerifyMessageRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_VerifyMessageRequest.Unmarshal(m, b) +} +func (m *VerifyMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_VerifyMessageRequest.Marshal(b, m, deterministic) +} +func (m *VerifyMessageRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyMessageRequest.Merge(m, src) +} +func (m *VerifyMessageRequest) XXX_Size() int { + return xxx_messageInfo_VerifyMessageRequest.Size(m) +} +func (m *VerifyMessageRequest) XXX_DiscardUnknown() { + xxx_messageInfo_VerifyMessageRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_VerifyMessageRequest proto.InternalMessageInfo + +func (m *VerifyMessageRequest) GetMsg() []byte { + if m != nil { + return m.Msg + } + return nil +} + +func (m *VerifyMessageRequest) GetSignature() string { + if m != nil { + return m.Signature + } + return "" +} + +type VerifyMessageResponse struct { + // Whether the signature was valid over the given message + Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"` + // The pubkey recovered from the signature + Pubkey string `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *VerifyMessageResponse) Reset() { *m = VerifyMessageResponse{} } +func (m *VerifyMessageResponse) String() string { return proto.CompactTextString(m) } +func (*VerifyMessageResponse) ProtoMessage() {} +func (*VerifyMessageResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{26} +} + +func (m *VerifyMessageResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_VerifyMessageResponse.Unmarshal(m, b) +} +func (m *VerifyMessageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_VerifyMessageResponse.Marshal(b, m, deterministic) +} +func (m *VerifyMessageResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyMessageResponse.Merge(m, src) +} +func (m *VerifyMessageResponse) XXX_Size() int { + return xxx_messageInfo_VerifyMessageResponse.Size(m) +} +func (m *VerifyMessageResponse) XXX_DiscardUnknown() { + xxx_messageInfo_VerifyMessageResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_VerifyMessageResponse proto.InternalMessageInfo + +func (m *VerifyMessageResponse) GetValid() bool { + if m != nil { + return m.Valid + } + return false +} + +func (m *VerifyMessageResponse) GetPubkey() string { + if m != nil { + return m.Pubkey + } + return "" +} + +type ConnectPeerRequest struct { + // Lightning address of the peer, in the format `@host` + Addr *LightningAddress `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"` + // If set, the daemon will attempt to persistently connect to the target + // peer. Otherwise, the call will be synchronous. + Perm bool `protobuf:"varint,2,opt,name=perm,proto3" json:"perm,omitempty"` + // + //The connection timeout value (in seconds) for this request. It won't affect + //other requests. + Timeout uint64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConnectPeerRequest) Reset() { *m = ConnectPeerRequest{} } +func (m *ConnectPeerRequest) String() string { return proto.CompactTextString(m) } +func (*ConnectPeerRequest) ProtoMessage() {} +func (*ConnectPeerRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{27} +} + +func (m *ConnectPeerRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ConnectPeerRequest.Unmarshal(m, b) +} +func (m *ConnectPeerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ConnectPeerRequest.Marshal(b, m, deterministic) +} +func (m *ConnectPeerRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConnectPeerRequest.Merge(m, src) +} +func (m *ConnectPeerRequest) XXX_Size() int { + return xxx_messageInfo_ConnectPeerRequest.Size(m) +} +func (m *ConnectPeerRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ConnectPeerRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ConnectPeerRequest proto.InternalMessageInfo + +func (m *ConnectPeerRequest) GetAddr() *LightningAddress { + if m != nil { + return m.Addr + } + return nil +} + +func (m *ConnectPeerRequest) GetPerm() bool { + if m != nil { + return m.Perm + } + return false +} + +func (m *ConnectPeerRequest) GetTimeout() uint64 { + if m != nil { + return m.Timeout + } + return 0 +} + +type ConnectPeerResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConnectPeerResponse) Reset() { *m = ConnectPeerResponse{} } +func (m *ConnectPeerResponse) String() string { return proto.CompactTextString(m) } +func (*ConnectPeerResponse) ProtoMessage() {} +func (*ConnectPeerResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{28} +} + +func (m *ConnectPeerResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ConnectPeerResponse.Unmarshal(m, b) +} +func (m *ConnectPeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ConnectPeerResponse.Marshal(b, m, deterministic) +} +func (m *ConnectPeerResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConnectPeerResponse.Merge(m, src) +} +func (m *ConnectPeerResponse) XXX_Size() int { + return xxx_messageInfo_ConnectPeerResponse.Size(m) +} +func (m *ConnectPeerResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ConnectPeerResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ConnectPeerResponse proto.InternalMessageInfo + +type DisconnectPeerRequest struct { + // The pubkey of the node to disconnect from + PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DisconnectPeerRequest) Reset() { *m = DisconnectPeerRequest{} } +func (m *DisconnectPeerRequest) String() string { return proto.CompactTextString(m) } +func (*DisconnectPeerRequest) ProtoMessage() {} +func (*DisconnectPeerRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{29} +} + +func (m *DisconnectPeerRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DisconnectPeerRequest.Unmarshal(m, b) +} +func (m *DisconnectPeerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DisconnectPeerRequest.Marshal(b, m, deterministic) +} +func (m *DisconnectPeerRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DisconnectPeerRequest.Merge(m, src) +} +func (m *DisconnectPeerRequest) XXX_Size() int { + return xxx_messageInfo_DisconnectPeerRequest.Size(m) +} +func (m *DisconnectPeerRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DisconnectPeerRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DisconnectPeerRequest proto.InternalMessageInfo + +func (m *DisconnectPeerRequest) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +type DisconnectPeerResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DisconnectPeerResponse) Reset() { *m = DisconnectPeerResponse{} } +func (m *DisconnectPeerResponse) String() string { return proto.CompactTextString(m) } +func (*DisconnectPeerResponse) ProtoMessage() {} +func (*DisconnectPeerResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{30} +} + +func (m *DisconnectPeerResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DisconnectPeerResponse.Unmarshal(m, b) +} +func (m *DisconnectPeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DisconnectPeerResponse.Marshal(b, m, deterministic) +} +func (m *DisconnectPeerResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DisconnectPeerResponse.Merge(m, src) +} +func (m *DisconnectPeerResponse) XXX_Size() int { + return xxx_messageInfo_DisconnectPeerResponse.Size(m) +} +func (m *DisconnectPeerResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DisconnectPeerResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DisconnectPeerResponse proto.InternalMessageInfo + +type HTLC struct { + Incoming bool `protobuf:"varint,1,opt,name=incoming,proto3" json:"incoming,omitempty"` + Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` + HashLock []byte `protobuf:"bytes,3,opt,name=hash_lock,json=hashLock,proto3" json:"hash_lock,omitempty"` + ExpirationHeight uint32 `protobuf:"varint,4,opt,name=expiration_height,json=expirationHeight,proto3" json:"expiration_height,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HTLC) Reset() { *m = HTLC{} } +func (m *HTLC) String() string { return proto.CompactTextString(m) } +func (*HTLC) ProtoMessage() {} +func (*HTLC) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{31} +} + +func (m *HTLC) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HTLC.Unmarshal(m, b) +} +func (m *HTLC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HTLC.Marshal(b, m, deterministic) +} +func (m *HTLC) XXX_Merge(src proto.Message) { + xxx_messageInfo_HTLC.Merge(m, src) +} +func (m *HTLC) XXX_Size() int { + return xxx_messageInfo_HTLC.Size(m) +} +func (m *HTLC) XXX_DiscardUnknown() { + xxx_messageInfo_HTLC.DiscardUnknown(m) +} + +var xxx_messageInfo_HTLC proto.InternalMessageInfo + +func (m *HTLC) GetIncoming() bool { + if m != nil { + return m.Incoming + } + return false +} + +func (m *HTLC) GetAmount() int64 { + if m != nil { + return m.Amount + } + return 0 +} + +func (m *HTLC) GetHashLock() []byte { + if m != nil { + return m.HashLock + } + return nil +} + +func (m *HTLC) GetExpirationHeight() uint32 { + if m != nil { + return m.ExpirationHeight + } + return 0 +} + +type ChannelConstraints struct { + // + //The CSV delay expressed in relative blocks. If the channel is force closed, + //we will need to wait for this many blocks before we can regain our funds. + CsvDelay uint32 `protobuf:"varint,1,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` + // The minimum satoshis this node is required to reserve in its balance. + ChanReserveSat uint64 `protobuf:"varint,2,opt,name=chan_reserve_sat,json=chanReserveSat,proto3" json:"chan_reserve_sat,omitempty"` + // The dust limit (in satoshis) of the initiator's commitment tx. + DustLimitSat uint64 `protobuf:"varint,3,opt,name=dust_limit_sat,json=dustLimitSat,proto3" json:"dust_limit_sat,omitempty"` + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + MaxPendingAmtMsat uint64 `protobuf:"varint,4,opt,name=max_pending_amt_msat,json=maxPendingAmtMsat,proto3" json:"max_pending_amt_msat,omitempty"` + // The smallest HTLC in millisatoshis that the initiator will accept. + MinHtlcMsat uint64 `protobuf:"varint,5,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` + // The total number of incoming HTLC's that the initiator will accept. + MaxAcceptedHtlcs uint32 `protobuf:"varint,6,opt,name=max_accepted_htlcs,json=maxAcceptedHtlcs,proto3" json:"max_accepted_htlcs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelConstraints) Reset() { *m = ChannelConstraints{} } +func (m *ChannelConstraints) String() string { return proto.CompactTextString(m) } +func (*ChannelConstraints) ProtoMessage() {} +func (*ChannelConstraints) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{32} +} + +func (m *ChannelConstraints) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelConstraints.Unmarshal(m, b) +} +func (m *ChannelConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelConstraints.Marshal(b, m, deterministic) +} +func (m *ChannelConstraints) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelConstraints.Merge(m, src) +} +func (m *ChannelConstraints) XXX_Size() int { + return xxx_messageInfo_ChannelConstraints.Size(m) +} +func (m *ChannelConstraints) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelConstraints.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelConstraints proto.InternalMessageInfo + +func (m *ChannelConstraints) GetCsvDelay() uint32 { + if m != nil { + return m.CsvDelay + } + return 0 +} + +func (m *ChannelConstraints) GetChanReserveSat() uint64 { + if m != nil { + return m.ChanReserveSat + } + return 0 +} + +func (m *ChannelConstraints) GetDustLimitSat() uint64 { + if m != nil { + return m.DustLimitSat + } + return 0 +} + +func (m *ChannelConstraints) GetMaxPendingAmtMsat() uint64 { + if m != nil { + return m.MaxPendingAmtMsat + } + return 0 +} + +func (m *ChannelConstraints) GetMinHtlcMsat() uint64 { + if m != nil { + return m.MinHtlcMsat + } + return 0 +} + +func (m *ChannelConstraints) GetMaxAcceptedHtlcs() uint32 { + if m != nil { + return m.MaxAcceptedHtlcs + } + return 0 +} + +type Channel struct { + // Whether this channel is active or not + Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"` + // The identity pubkey of the remote node + RemotePubkey string `protobuf:"bytes,2,opt,name=remote_pubkey,json=remotePubkey,proto3" json:"remote_pubkey,omitempty"` + // + //The outpoint (txid:index) of the funding transaction. With this value, Bob + //will be able to generate a signature for Alice's version of the commitment + //transaction. + ChannelPoint string `protobuf:"bytes,3,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChanId uint64 `protobuf:"varint,4,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // The total amount of funds held in this channel + Capacity int64 `protobuf:"varint,5,opt,name=capacity,proto3" json:"capacity,omitempty"` + // This node's current balance in this channel + LocalBalance int64 `protobuf:"varint,6,opt,name=local_balance,json=localBalance,proto3" json:"local_balance,omitempty"` + // The counterparty's current balance in this channel + RemoteBalance int64 `protobuf:"varint,7,opt,name=remote_balance,json=remoteBalance,proto3" json:"remote_balance,omitempty"` + // + //The amount calculated to be paid in fees for the current set of commitment + //transactions. The fee amount is persisted with the channel in order to + //allow the fee amount to be removed and recalculated with each channel state + //update, including updates that happen after a system restart. + CommitFee int64 `protobuf:"varint,8,opt,name=commit_fee,json=commitFee,proto3" json:"commit_fee,omitempty"` + // The weight of the commitment transaction + CommitWeight int64 `protobuf:"varint,9,opt,name=commit_weight,json=commitWeight,proto3" json:"commit_weight,omitempty"` + // + //The required number of satoshis per kilo-weight that the requester will pay + //at all times, for both the funding transaction and commitment transaction. + //This value can later be updated once the channel is open. + FeePerKw int64 `protobuf:"varint,10,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` + // The unsettled balance in this channel + UnsettledBalance int64 `protobuf:"varint,11,opt,name=unsettled_balance,json=unsettledBalance,proto3" json:"unsettled_balance,omitempty"` + // + //The total number of satoshis we've sent within this channel. + TotalSatoshisSent int64 `protobuf:"varint,12,opt,name=total_satoshis_sent,json=totalSatoshisSent,proto3" json:"total_satoshis_sent,omitempty"` + // + //The total number of satoshis we've received within this channel. + TotalSatoshisReceived int64 `protobuf:"varint,13,opt,name=total_satoshis_received,json=totalSatoshisReceived,proto3" json:"total_satoshis_received,omitempty"` + // + //The total number of updates conducted within this channel. + NumUpdates uint64 `protobuf:"varint,14,opt,name=num_updates,json=numUpdates,proto3" json:"num_updates,omitempty"` + // + //The list of active, uncleared HTLCs currently pending within the channel. + PendingHtlcs []*HTLC `protobuf:"bytes,15,rep,name=pending_htlcs,json=pendingHtlcs,proto3" json:"pending_htlcs,omitempty"` + // + //Deprecated. The CSV delay expressed in relative blocks. If the channel is + //force closed, we will need to wait for this many blocks before we can regain + //our funds. + CsvDelay uint32 `protobuf:"varint,16,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` // Deprecated: Do not use. + // Whether this channel is advertised to the network or not. + Private bool `protobuf:"varint,17,opt,name=private,proto3" json:"private,omitempty"` + // True if we were the ones that created the channel. + Initiator bool `protobuf:"varint,18,opt,name=initiator,proto3" json:"initiator,omitempty"` + // A set of flags showing the current state of the channel. + ChanStatusFlags string `protobuf:"bytes,19,opt,name=chan_status_flags,json=chanStatusFlags,proto3" json:"chan_status_flags,omitempty"` + // Deprecated. The minimum satoshis this node is required to reserve in its + // balance. + LocalChanReserveSat int64 `protobuf:"varint,20,opt,name=local_chan_reserve_sat,json=localChanReserveSat,proto3" json:"local_chan_reserve_sat,omitempty"` // Deprecated: Do not use. + // + //Deprecated. The minimum satoshis the other node is required to reserve in + //its balance. + RemoteChanReserveSat int64 `protobuf:"varint,21,opt,name=remote_chan_reserve_sat,json=remoteChanReserveSat,proto3" json:"remote_chan_reserve_sat,omitempty"` // Deprecated: Do not use. + // Deprecated. Use commitment_type. + StaticRemoteKey bool `protobuf:"varint,22,opt,name=static_remote_key,json=staticRemoteKey,proto3" json:"static_remote_key,omitempty"` // Deprecated: Do not use. + // The commitment type used by this channel. + CommitmentType CommitmentType `protobuf:"varint,26,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` + // + //The number of seconds that the channel has been monitored by the channel + //scoring system. Scores are currently not persisted, so this value may be + //less than the lifetime of the channel [EXPERIMENTAL]. + Lifetime int64 `protobuf:"varint,23,opt,name=lifetime,proto3" json:"lifetime,omitempty"` + // + //The number of seconds that the remote peer has been observed as being online + //by the channel scoring system over the lifetime of the channel + //[EXPERIMENTAL]. + Uptime int64 `protobuf:"varint,24,opt,name=uptime,proto3" json:"uptime,omitempty"` + // + //Close address is the address that we will enforce payout to on cooperative + //close if the channel was opened utilizing option upfront shutdown. This + //value can be set on channel open by setting close_address in an open channel + //request. If this value is not set, you can still choose a payout address by + //cooperatively closing with the delivery_address field set. + CloseAddress string `protobuf:"bytes,25,opt,name=close_address,json=closeAddress,proto3" json:"close_address,omitempty"` + // + //The amount that the initiator of the channel optionally pushed to the remote + //party on channel open. This amount will be zero if the channel initiator did + //not push any funds to the remote peer. If the initiator field is true, we + //pushed this amount to our peer, if it is false, the remote peer pushed this + //amount to us. + PushAmountSat uint64 `protobuf:"varint,27,opt,name=push_amount_sat,json=pushAmountSat,proto3" json:"push_amount_sat,omitempty"` + // + //This uint32 indicates if this channel is to be considered 'frozen'. A + //frozen channel doest not allow a cooperative channel close by the + //initiator. The thaw_height is the height that this restriction stops + //applying to the channel. This field is optional, not setting it or using a + //value of zero will mean the channel has no additional restrictions. The + //height can be interpreted in two ways: as a relative height if the value is + //less than 500,000, or as an absolute height otherwise. + ThawHeight uint32 `protobuf:"varint,28,opt,name=thaw_height,json=thawHeight,proto3" json:"thaw_height,omitempty"` + // List constraints for the local node. + LocalConstraints *ChannelConstraints `protobuf:"bytes,29,opt,name=local_constraints,json=localConstraints,proto3" json:"local_constraints,omitempty"` + // List constraints for the remote node. + RemoteConstraints *ChannelConstraints `protobuf:"bytes,30,opt,name=remote_constraints,json=remoteConstraints,proto3" json:"remote_constraints,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Channel) Reset() { *m = Channel{} } +func (m *Channel) String() string { return proto.CompactTextString(m) } +func (*Channel) ProtoMessage() {} +func (*Channel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{33} +} + +func (m *Channel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Channel.Unmarshal(m, b) +} +func (m *Channel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Channel.Marshal(b, m, deterministic) +} +func (m *Channel) XXX_Merge(src proto.Message) { + xxx_messageInfo_Channel.Merge(m, src) +} +func (m *Channel) XXX_Size() int { + return xxx_messageInfo_Channel.Size(m) +} +func (m *Channel) XXX_DiscardUnknown() { + xxx_messageInfo_Channel.DiscardUnknown(m) +} + +var xxx_messageInfo_Channel proto.InternalMessageInfo + +func (m *Channel) GetActive() bool { + if m != nil { + return m.Active + } + return false +} + +func (m *Channel) GetRemotePubkey() string { + if m != nil { + return m.RemotePubkey + } + return "" +} + +func (m *Channel) GetChannelPoint() string { + if m != nil { + return m.ChannelPoint + } + return "" +} + +func (m *Channel) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *Channel) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *Channel) GetLocalBalance() int64 { + if m != nil { + return m.LocalBalance + } + return 0 +} + +func (m *Channel) GetRemoteBalance() int64 { + if m != nil { + return m.RemoteBalance + } + return 0 +} + +func (m *Channel) GetCommitFee() int64 { + if m != nil { + return m.CommitFee + } + return 0 +} + +func (m *Channel) GetCommitWeight() int64 { + if m != nil { + return m.CommitWeight + } + return 0 +} + +func (m *Channel) GetFeePerKw() int64 { + if m != nil { + return m.FeePerKw + } + return 0 +} + +func (m *Channel) GetUnsettledBalance() int64 { + if m != nil { + return m.UnsettledBalance + } + return 0 +} + +func (m *Channel) GetTotalSatoshisSent() int64 { + if m != nil { + return m.TotalSatoshisSent + } + return 0 +} + +func (m *Channel) GetTotalSatoshisReceived() int64 { + if m != nil { + return m.TotalSatoshisReceived + } + return 0 +} + +func (m *Channel) GetNumUpdates() uint64 { + if m != nil { + return m.NumUpdates + } + return 0 +} + +func (m *Channel) GetPendingHtlcs() []*HTLC { + if m != nil { + return m.PendingHtlcs + } + return nil +} + +// Deprecated: Do not use. +func (m *Channel) GetCsvDelay() uint32 { + if m != nil { + return m.CsvDelay + } + return 0 +} + +func (m *Channel) GetPrivate() bool { + if m != nil { + return m.Private + } + return false +} + +func (m *Channel) GetInitiator() bool { + if m != nil { + return m.Initiator + } + return false +} + +func (m *Channel) GetChanStatusFlags() string { + if m != nil { + return m.ChanStatusFlags + } + return "" +} + +// Deprecated: Do not use. +func (m *Channel) GetLocalChanReserveSat() int64 { + if m != nil { + return m.LocalChanReserveSat + } + return 0 +} + +// Deprecated: Do not use. +func (m *Channel) GetRemoteChanReserveSat() int64 { + if m != nil { + return m.RemoteChanReserveSat + } + return 0 +} + +// Deprecated: Do not use. +func (m *Channel) GetStaticRemoteKey() bool { + if m != nil { + return m.StaticRemoteKey + } + return false +} + +func (m *Channel) GetCommitmentType() CommitmentType { + if m != nil { + return m.CommitmentType + } + return CommitmentType_LEGACY +} + +func (m *Channel) GetLifetime() int64 { + if m != nil { + return m.Lifetime + } + return 0 +} + +func (m *Channel) GetUptime() int64 { + if m != nil { + return m.Uptime + } + return 0 +} + +func (m *Channel) GetCloseAddress() string { + if m != nil { + return m.CloseAddress + } + return "" +} + +func (m *Channel) GetPushAmountSat() uint64 { + if m != nil { + return m.PushAmountSat + } + return 0 +} + +func (m *Channel) GetThawHeight() uint32 { + if m != nil { + return m.ThawHeight + } + return 0 +} + +func (m *Channel) GetLocalConstraints() *ChannelConstraints { + if m != nil { + return m.LocalConstraints + } + return nil +} + +func (m *Channel) GetRemoteConstraints() *ChannelConstraints { + if m != nil { + return m.RemoteConstraints + } + return nil +} + +type ListChannelsRequest struct { + ActiveOnly bool `protobuf:"varint,1,opt,name=active_only,json=activeOnly,proto3" json:"active_only,omitempty"` + InactiveOnly bool `protobuf:"varint,2,opt,name=inactive_only,json=inactiveOnly,proto3" json:"inactive_only,omitempty"` + PublicOnly bool `protobuf:"varint,3,opt,name=public_only,json=publicOnly,proto3" json:"public_only,omitempty"` + PrivateOnly bool `protobuf:"varint,4,opt,name=private_only,json=privateOnly,proto3" json:"private_only,omitempty"` + // + //Filters the response for channels with a target peer's pubkey. If peer is + //empty, all channels will be returned. + Peer []byte `protobuf:"bytes,5,opt,name=peer,proto3" json:"peer,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListChannelsRequest) Reset() { *m = ListChannelsRequest{} } +func (m *ListChannelsRequest) String() string { return proto.CompactTextString(m) } +func (*ListChannelsRequest) ProtoMessage() {} +func (*ListChannelsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{34} +} + +func (m *ListChannelsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListChannelsRequest.Unmarshal(m, b) +} +func (m *ListChannelsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListChannelsRequest.Marshal(b, m, deterministic) +} +func (m *ListChannelsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListChannelsRequest.Merge(m, src) +} +func (m *ListChannelsRequest) XXX_Size() int { + return xxx_messageInfo_ListChannelsRequest.Size(m) +} +func (m *ListChannelsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListChannelsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListChannelsRequest proto.InternalMessageInfo + +func (m *ListChannelsRequest) GetActiveOnly() bool { + if m != nil { + return m.ActiveOnly + } + return false +} + +func (m *ListChannelsRequest) GetInactiveOnly() bool { + if m != nil { + return m.InactiveOnly + } + return false +} + +func (m *ListChannelsRequest) GetPublicOnly() bool { + if m != nil { + return m.PublicOnly + } + return false +} + +func (m *ListChannelsRequest) GetPrivateOnly() bool { + if m != nil { + return m.PrivateOnly + } + return false +} + +func (m *ListChannelsRequest) GetPeer() []byte { + if m != nil { + return m.Peer + } + return nil +} + +type ListChannelsResponse struct { + // The list of active channels + Channels []*Channel `protobuf:"bytes,11,rep,name=channels,proto3" json:"channels,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListChannelsResponse) Reset() { *m = ListChannelsResponse{} } +func (m *ListChannelsResponse) String() string { return proto.CompactTextString(m) } +func (*ListChannelsResponse) ProtoMessage() {} +func (*ListChannelsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{35} +} + +func (m *ListChannelsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListChannelsResponse.Unmarshal(m, b) +} +func (m *ListChannelsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListChannelsResponse.Marshal(b, m, deterministic) +} +func (m *ListChannelsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListChannelsResponse.Merge(m, src) +} +func (m *ListChannelsResponse) XXX_Size() int { + return xxx_messageInfo_ListChannelsResponse.Size(m) +} +func (m *ListChannelsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListChannelsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListChannelsResponse proto.InternalMessageInfo + +func (m *ListChannelsResponse) GetChannels() []*Channel { + if m != nil { + return m.Channels + } + return nil +} + +type ChannelCloseSummary struct { + // The outpoint (txid:index) of the funding transaction. + ChannelPoint string `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + // The unique channel ID for the channel. + ChanId uint64 `protobuf:"varint,2,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // The hash of the genesis block that this channel resides within. + ChainHash string `protobuf:"bytes,3,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` + // The txid of the transaction which ultimately closed this channel. + ClosingTxHash string `protobuf:"bytes,4,opt,name=closing_tx_hash,json=closingTxHash,proto3" json:"closing_tx_hash,omitempty"` + // Public key of the remote peer that we formerly had a channel with. + RemotePubkey string `protobuf:"bytes,5,opt,name=remote_pubkey,json=remotePubkey,proto3" json:"remote_pubkey,omitempty"` + // Total capacity of the channel. + Capacity int64 `protobuf:"varint,6,opt,name=capacity,proto3" json:"capacity,omitempty"` + // Height at which the funding transaction was spent. + CloseHeight uint32 `protobuf:"varint,7,opt,name=close_height,json=closeHeight,proto3" json:"close_height,omitempty"` + // Settled balance at the time of channel closure + SettledBalance int64 `protobuf:"varint,8,opt,name=settled_balance,json=settledBalance,proto3" json:"settled_balance,omitempty"` + // The sum of all the time-locked outputs at the time of channel closure + TimeLockedBalance int64 `protobuf:"varint,9,opt,name=time_locked_balance,json=timeLockedBalance,proto3" json:"time_locked_balance,omitempty"` + // Details on how the channel was closed. + CloseType ChannelCloseSummary_ClosureType `protobuf:"varint,10,opt,name=close_type,json=closeType,proto3,enum=lnrpc.ChannelCloseSummary_ClosureType" json:"close_type,omitempty"` + // + //Open initiator is the party that initiated opening the channel. Note that + //this value may be unknown if the channel was closed before we migrated to + //store open channel information after close. + OpenInitiator Initiator `protobuf:"varint,11,opt,name=open_initiator,json=openInitiator,proto3,enum=lnrpc.Initiator" json:"open_initiator,omitempty"` + // + //Close initiator indicates which party initiated the close. This value will + //be unknown for channels that were cooperatively closed before we started + //tracking cooperative close initiators. Note that this indicates which party + //initiated a close, and it is possible for both to initiate cooperative or + //force closes, although only one party's close will be confirmed on chain. + CloseInitiator Initiator `protobuf:"varint,12,opt,name=close_initiator,json=closeInitiator,proto3,enum=lnrpc.Initiator" json:"close_initiator,omitempty"` + Resolutions []*Resolution `protobuf:"bytes,13,rep,name=resolutions,proto3" json:"resolutions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelCloseSummary) Reset() { *m = ChannelCloseSummary{} } +func (m *ChannelCloseSummary) String() string { return proto.CompactTextString(m) } +func (*ChannelCloseSummary) ProtoMessage() {} +func (*ChannelCloseSummary) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{36} +} + +func (m *ChannelCloseSummary) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelCloseSummary.Unmarshal(m, b) +} +func (m *ChannelCloseSummary) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelCloseSummary.Marshal(b, m, deterministic) +} +func (m *ChannelCloseSummary) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelCloseSummary.Merge(m, src) +} +func (m *ChannelCloseSummary) XXX_Size() int { + return xxx_messageInfo_ChannelCloseSummary.Size(m) +} +func (m *ChannelCloseSummary) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelCloseSummary.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelCloseSummary proto.InternalMessageInfo + +func (m *ChannelCloseSummary) GetChannelPoint() string { + if m != nil { + return m.ChannelPoint + } + return "" +} + +func (m *ChannelCloseSummary) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *ChannelCloseSummary) GetChainHash() string { + if m != nil { + return m.ChainHash + } + return "" +} + +func (m *ChannelCloseSummary) GetClosingTxHash() string { + if m != nil { + return m.ClosingTxHash + } + return "" +} + +func (m *ChannelCloseSummary) GetRemotePubkey() string { + if m != nil { + return m.RemotePubkey + } + return "" +} + +func (m *ChannelCloseSummary) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *ChannelCloseSummary) GetCloseHeight() uint32 { + if m != nil { + return m.CloseHeight + } + return 0 +} + +func (m *ChannelCloseSummary) GetSettledBalance() int64 { + if m != nil { + return m.SettledBalance + } + return 0 +} + +func (m *ChannelCloseSummary) GetTimeLockedBalance() int64 { + if m != nil { + return m.TimeLockedBalance + } + return 0 +} + +func (m *ChannelCloseSummary) GetCloseType() ChannelCloseSummary_ClosureType { + if m != nil { + return m.CloseType + } + return ChannelCloseSummary_COOPERATIVE_CLOSE +} + +func (m *ChannelCloseSummary) GetOpenInitiator() Initiator { + if m != nil { + return m.OpenInitiator + } + return Initiator_INITIATOR_UNKNOWN +} + +func (m *ChannelCloseSummary) GetCloseInitiator() Initiator { + if m != nil { + return m.CloseInitiator + } + return Initiator_INITIATOR_UNKNOWN +} + +func (m *ChannelCloseSummary) GetResolutions() []*Resolution { + if m != nil { + return m.Resolutions + } + return nil +} + +type Resolution struct { + // The type of output we are resolving. + ResolutionType ResolutionType `protobuf:"varint,1,opt,name=resolution_type,json=resolutionType,proto3,enum=lnrpc.ResolutionType" json:"resolution_type,omitempty"` + // The outcome of our on chain action that resolved the outpoint. + Outcome ResolutionOutcome `protobuf:"varint,2,opt,name=outcome,proto3,enum=lnrpc.ResolutionOutcome" json:"outcome,omitempty"` + // The outpoint that was spent by the resolution. + Outpoint *OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + // The amount that was claimed by the resolution. + AmountSat uint64 `protobuf:"varint,4,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"` + // The hex-encoded transaction ID of the sweep transaction that spent the + // output. + SweepTxid string `protobuf:"bytes,5,opt,name=sweep_txid,json=sweepTxid,proto3" json:"sweep_txid,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Resolution) Reset() { *m = Resolution{} } +func (m *Resolution) String() string { return proto.CompactTextString(m) } +func (*Resolution) ProtoMessage() {} +func (*Resolution) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{37} +} + +func (m *Resolution) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Resolution.Unmarshal(m, b) +} +func (m *Resolution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Resolution.Marshal(b, m, deterministic) +} +func (m *Resolution) XXX_Merge(src proto.Message) { + xxx_messageInfo_Resolution.Merge(m, src) +} +func (m *Resolution) XXX_Size() int { + return xxx_messageInfo_Resolution.Size(m) +} +func (m *Resolution) XXX_DiscardUnknown() { + xxx_messageInfo_Resolution.DiscardUnknown(m) +} + +var xxx_messageInfo_Resolution proto.InternalMessageInfo + +func (m *Resolution) GetResolutionType() ResolutionType { + if m != nil { + return m.ResolutionType + } + return ResolutionType_TYPE_UNKNOWN +} + +func (m *Resolution) GetOutcome() ResolutionOutcome { + if m != nil { + return m.Outcome + } + return ResolutionOutcome_OUTCOME_UNKNOWN +} + +func (m *Resolution) GetOutpoint() *OutPoint { + if m != nil { + return m.Outpoint + } + return nil +} + +func (m *Resolution) GetAmountSat() uint64 { + if m != nil { + return m.AmountSat + } + return 0 +} + +func (m *Resolution) GetSweepTxid() string { + if m != nil { + return m.SweepTxid + } + return "" +} + +type ClosedChannelsRequest struct { + Cooperative bool `protobuf:"varint,1,opt,name=cooperative,proto3" json:"cooperative,omitempty"` + LocalForce bool `protobuf:"varint,2,opt,name=local_force,json=localForce,proto3" json:"local_force,omitempty"` + RemoteForce bool `protobuf:"varint,3,opt,name=remote_force,json=remoteForce,proto3" json:"remote_force,omitempty"` + Breach bool `protobuf:"varint,4,opt,name=breach,proto3" json:"breach,omitempty"` + FundingCanceled bool `protobuf:"varint,5,opt,name=funding_canceled,json=fundingCanceled,proto3" json:"funding_canceled,omitempty"` + Abandoned bool `protobuf:"varint,6,opt,name=abandoned,proto3" json:"abandoned,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ClosedChannelsRequest) Reset() { *m = ClosedChannelsRequest{} } +func (m *ClosedChannelsRequest) String() string { return proto.CompactTextString(m) } +func (*ClosedChannelsRequest) ProtoMessage() {} +func (*ClosedChannelsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{38} +} + +func (m *ClosedChannelsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ClosedChannelsRequest.Unmarshal(m, b) +} +func (m *ClosedChannelsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ClosedChannelsRequest.Marshal(b, m, deterministic) +} +func (m *ClosedChannelsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClosedChannelsRequest.Merge(m, src) +} +func (m *ClosedChannelsRequest) XXX_Size() int { + return xxx_messageInfo_ClosedChannelsRequest.Size(m) +} +func (m *ClosedChannelsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ClosedChannelsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ClosedChannelsRequest proto.InternalMessageInfo + +func (m *ClosedChannelsRequest) GetCooperative() bool { + if m != nil { + return m.Cooperative + } + return false +} + +func (m *ClosedChannelsRequest) GetLocalForce() bool { + if m != nil { + return m.LocalForce + } + return false +} + +func (m *ClosedChannelsRequest) GetRemoteForce() bool { + if m != nil { + return m.RemoteForce + } + return false +} + +func (m *ClosedChannelsRequest) GetBreach() bool { + if m != nil { + return m.Breach + } + return false +} + +func (m *ClosedChannelsRequest) GetFundingCanceled() bool { + if m != nil { + return m.FundingCanceled + } + return false +} + +func (m *ClosedChannelsRequest) GetAbandoned() bool { + if m != nil { + return m.Abandoned + } + return false +} + +type ClosedChannelsResponse struct { + Channels []*ChannelCloseSummary `protobuf:"bytes,1,rep,name=channels,proto3" json:"channels,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ClosedChannelsResponse) Reset() { *m = ClosedChannelsResponse{} } +func (m *ClosedChannelsResponse) String() string { return proto.CompactTextString(m) } +func (*ClosedChannelsResponse) ProtoMessage() {} +func (*ClosedChannelsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{39} +} + +func (m *ClosedChannelsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ClosedChannelsResponse.Unmarshal(m, b) +} +func (m *ClosedChannelsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ClosedChannelsResponse.Marshal(b, m, deterministic) +} +func (m *ClosedChannelsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClosedChannelsResponse.Merge(m, src) +} +func (m *ClosedChannelsResponse) XXX_Size() int { + return xxx_messageInfo_ClosedChannelsResponse.Size(m) +} +func (m *ClosedChannelsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ClosedChannelsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ClosedChannelsResponse proto.InternalMessageInfo + +func (m *ClosedChannelsResponse) GetChannels() []*ChannelCloseSummary { + if m != nil { + return m.Channels + } + return nil +} + +type Peer struct { + // The identity pubkey of the peer + PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + // Network address of the peer; eg `127.0.0.1:10011` + Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` + // Bytes of data transmitted to this peer + BytesSent uint64 `protobuf:"varint,4,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"` + // Bytes of data transmitted from this peer + BytesRecv uint64 `protobuf:"varint,5,opt,name=bytes_recv,json=bytesRecv,proto3" json:"bytes_recv,omitempty"` + // Satoshis sent to this peer + SatSent int64 `protobuf:"varint,6,opt,name=sat_sent,json=satSent,proto3" json:"sat_sent,omitempty"` + // Satoshis received from this peer + SatRecv int64 `protobuf:"varint,7,opt,name=sat_recv,json=satRecv,proto3" json:"sat_recv,omitempty"` + // A channel is inbound if the counterparty initiated the channel + Inbound bool `protobuf:"varint,8,opt,name=inbound,proto3" json:"inbound,omitempty"` + // Ping time to this peer + PingTime int64 `protobuf:"varint,9,opt,name=ping_time,json=pingTime,proto3" json:"ping_time,omitempty"` + // The type of sync we are currently performing with this peer. + SyncType Peer_SyncType `protobuf:"varint,10,opt,name=sync_type,json=syncType,proto3,enum=lnrpc.Peer_SyncType" json:"sync_type,omitempty"` + // Features advertised by the remote peer in their init message. + Features map[uint32]*Feature `protobuf:"bytes,11,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // + //The latest errors received from our peer with timestamps, limited to the 10 + //most recent errors. These errors are tracked across peer connections, but + //are not persisted across lnd restarts. Note that these errors are only + //stored for peers that we have channels open with, to prevent peers from + //spamming us with errors at no cost. + Errors []*TimestampedError `protobuf:"bytes,12,rep,name=errors,proto3" json:"errors,omitempty"` + // + //The number of times we have recorded this peer going offline or coming + //online, recorded across restarts. Note that this value is decreased over + //time if the peer has not recently flapped, so that we can forgive peers + //with historically high flap counts. + FlapCount int32 `protobuf:"varint,13,opt,name=flap_count,json=flapCount,proto3" json:"flap_count,omitempty"` + // + //The timestamp of the last flap we observed for this peer. If this value is + //zero, we have not observed any flaps for this peer. + LastFlapNs int64 `protobuf:"varint,14,opt,name=last_flap_ns,json=lastFlapNs,proto3" json:"last_flap_ns,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Peer) Reset() { *m = Peer{} } +func (m *Peer) String() string { return proto.CompactTextString(m) } +func (*Peer) ProtoMessage() {} +func (*Peer) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{40} +} + +func (m *Peer) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Peer.Unmarshal(m, b) +} +func (m *Peer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Peer.Marshal(b, m, deterministic) +} +func (m *Peer) XXX_Merge(src proto.Message) { + xxx_messageInfo_Peer.Merge(m, src) +} +func (m *Peer) XXX_Size() int { + return xxx_messageInfo_Peer.Size(m) +} +func (m *Peer) XXX_DiscardUnknown() { + xxx_messageInfo_Peer.DiscardUnknown(m) +} + +var xxx_messageInfo_Peer proto.InternalMessageInfo + +func (m *Peer) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *Peer) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *Peer) GetBytesSent() uint64 { + if m != nil { + return m.BytesSent + } + return 0 +} + +func (m *Peer) GetBytesRecv() uint64 { + if m != nil { + return m.BytesRecv + } + return 0 +} + +func (m *Peer) GetSatSent() int64 { + if m != nil { + return m.SatSent + } + return 0 +} + +func (m *Peer) GetSatRecv() int64 { + if m != nil { + return m.SatRecv + } + return 0 +} + +func (m *Peer) GetInbound() bool { + if m != nil { + return m.Inbound + } + return false +} + +func (m *Peer) GetPingTime() int64 { + if m != nil { + return m.PingTime + } + return 0 +} + +func (m *Peer) GetSyncType() Peer_SyncType { + if m != nil { + return m.SyncType + } + return Peer_UNKNOWN_SYNC +} + +func (m *Peer) GetFeatures() map[uint32]*Feature { + if m != nil { + return m.Features + } + return nil +} + +func (m *Peer) GetErrors() []*TimestampedError { + if m != nil { + return m.Errors + } + return nil +} + +func (m *Peer) GetFlapCount() int32 { + if m != nil { + return m.FlapCount + } + return 0 +} + +func (m *Peer) GetLastFlapNs() int64 { + if m != nil { + return m.LastFlapNs + } + return 0 +} + +type TimestampedError struct { + // The unix timestamp in seconds when the error occurred. + Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // The string representation of the error sent by our peer. + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TimestampedError) Reset() { *m = TimestampedError{} } +func (m *TimestampedError) String() string { return proto.CompactTextString(m) } +func (*TimestampedError) ProtoMessage() {} +func (*TimestampedError) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{41} +} + +func (m *TimestampedError) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_TimestampedError.Unmarshal(m, b) +} +func (m *TimestampedError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_TimestampedError.Marshal(b, m, deterministic) +} +func (m *TimestampedError) XXX_Merge(src proto.Message) { + xxx_messageInfo_TimestampedError.Merge(m, src) +} +func (m *TimestampedError) XXX_Size() int { + return xxx_messageInfo_TimestampedError.Size(m) +} +func (m *TimestampedError) XXX_DiscardUnknown() { + xxx_messageInfo_TimestampedError.DiscardUnknown(m) +} + +var xxx_messageInfo_TimestampedError proto.InternalMessageInfo + +func (m *TimestampedError) GetTimestamp() uint64 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *TimestampedError) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +type ListPeersRequest struct { + // + //If true, only the last error that our peer sent us will be returned with + //the peer's information, rather than the full set of historic errors we have + //stored. + LatestError bool `protobuf:"varint,1,opt,name=latest_error,json=latestError,proto3" json:"latest_error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPeersRequest) Reset() { *m = ListPeersRequest{} } +func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) } +func (*ListPeersRequest) ProtoMessage() {} +func (*ListPeersRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{42} +} + +func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPeersRequest.Unmarshal(m, b) +} +func (m *ListPeersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPeersRequest.Marshal(b, m, deterministic) +} +func (m *ListPeersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPeersRequest.Merge(m, src) +} +func (m *ListPeersRequest) XXX_Size() int { + return xxx_messageInfo_ListPeersRequest.Size(m) +} +func (m *ListPeersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListPeersRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPeersRequest proto.InternalMessageInfo + +func (m *ListPeersRequest) GetLatestError() bool { + if m != nil { + return m.LatestError + } + return false +} + +type ListPeersResponse struct { + // The list of currently connected peers + Peers []*Peer `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPeersResponse) Reset() { *m = ListPeersResponse{} } +func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) } +func (*ListPeersResponse) ProtoMessage() {} +func (*ListPeersResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{43} +} + +func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPeersResponse.Unmarshal(m, b) +} +func (m *ListPeersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPeersResponse.Marshal(b, m, deterministic) +} +func (m *ListPeersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPeersResponse.Merge(m, src) +} +func (m *ListPeersResponse) XXX_Size() int { + return xxx_messageInfo_ListPeersResponse.Size(m) +} +func (m *ListPeersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListPeersResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPeersResponse proto.InternalMessageInfo + +func (m *ListPeersResponse) GetPeers() []*Peer { + if m != nil { + return m.Peers + } + return nil +} + +type PeerEventSubscription struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PeerEventSubscription) Reset() { *m = PeerEventSubscription{} } +func (m *PeerEventSubscription) String() string { return proto.CompactTextString(m) } +func (*PeerEventSubscription) ProtoMessage() {} +func (*PeerEventSubscription) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{44} +} + +func (m *PeerEventSubscription) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PeerEventSubscription.Unmarshal(m, b) +} +func (m *PeerEventSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PeerEventSubscription.Marshal(b, m, deterministic) +} +func (m *PeerEventSubscription) XXX_Merge(src proto.Message) { + xxx_messageInfo_PeerEventSubscription.Merge(m, src) +} +func (m *PeerEventSubscription) XXX_Size() int { + return xxx_messageInfo_PeerEventSubscription.Size(m) +} +func (m *PeerEventSubscription) XXX_DiscardUnknown() { + xxx_messageInfo_PeerEventSubscription.DiscardUnknown(m) +} + +var xxx_messageInfo_PeerEventSubscription proto.InternalMessageInfo + +type PeerEvent struct { + // The identity pubkey of the peer. + PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + Type PeerEvent_EventType `protobuf:"varint,2,opt,name=type,proto3,enum=lnrpc.PeerEvent_EventType" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PeerEvent) Reset() { *m = PeerEvent{} } +func (m *PeerEvent) String() string { return proto.CompactTextString(m) } +func (*PeerEvent) ProtoMessage() {} +func (*PeerEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{45} +} + +func (m *PeerEvent) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PeerEvent.Unmarshal(m, b) +} +func (m *PeerEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PeerEvent.Marshal(b, m, deterministic) +} +func (m *PeerEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_PeerEvent.Merge(m, src) +} +func (m *PeerEvent) XXX_Size() int { + return xxx_messageInfo_PeerEvent.Size(m) +} +func (m *PeerEvent) XXX_DiscardUnknown() { + xxx_messageInfo_PeerEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_PeerEvent proto.InternalMessageInfo + +func (m *PeerEvent) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *PeerEvent) GetType() PeerEvent_EventType { + if m != nil { + return m.Type + } + return PeerEvent_PEER_ONLINE +} + +type GetInfoRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } +func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } +func (*GetInfoRequest) ProtoMessage() {} +func (*GetInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{46} +} + +func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetInfoRequest.Unmarshal(m, b) +} +func (m *GetInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetInfoRequest.Marshal(b, m, deterministic) +} +func (m *GetInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetInfoRequest.Merge(m, src) +} +func (m *GetInfoRequest) XXX_Size() int { + return xxx_messageInfo_GetInfoRequest.Size(m) +} +func (m *GetInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetInfoRequest proto.InternalMessageInfo + +type GetInfoResponse struct { + // The version of the LND software that the node is running. + Version string `protobuf:"bytes,14,opt,name=version,proto3" json:"version,omitempty"` + // The SHA1 commit hash that the daemon is compiled with. + CommitHash string `protobuf:"bytes,20,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"` + // The identity pubkey of the current node. + IdentityPubkey string `protobuf:"bytes,1,opt,name=identity_pubkey,json=identityPubkey,proto3" json:"identity_pubkey,omitempty"` + // If applicable, the alias of the current node, e.g. "bob" + Alias string `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"` + // The color of the current node in hex code format + Color string `protobuf:"bytes,17,opt,name=color,proto3" json:"color,omitempty"` + // Number of pending channels + NumPendingChannels uint32 `protobuf:"varint,3,opt,name=num_pending_channels,json=numPendingChannels,proto3" json:"num_pending_channels,omitempty"` + // Number of active channels + NumActiveChannels uint32 `protobuf:"varint,4,opt,name=num_active_channels,json=numActiveChannels,proto3" json:"num_active_channels,omitempty"` + // Number of inactive channels + NumInactiveChannels uint32 `protobuf:"varint,15,opt,name=num_inactive_channels,json=numInactiveChannels,proto3" json:"num_inactive_channels,omitempty"` + // Number of peers + NumPeers uint32 `protobuf:"varint,5,opt,name=num_peers,json=numPeers,proto3" json:"num_peers,omitempty"` + // The node's current view of the height of the best block + BlockHeight uint32 `protobuf:"varint,6,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + // The node's current view of the hash of the best block + BlockHash string `protobuf:"bytes,8,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` + // Timestamp of the block best known to the wallet + BestHeaderTimestamp int64 `protobuf:"varint,13,opt,name=best_header_timestamp,json=bestHeaderTimestamp,proto3" json:"best_header_timestamp,omitempty"` + // Whether the wallet's view is synced to the main chain + SyncedToChain bool `protobuf:"varint,9,opt,name=synced_to_chain,json=syncedToChain,proto3" json:"synced_to_chain,omitempty"` + // Whether we consider ourselves synced with the public channel graph. + SyncedToGraph bool `protobuf:"varint,18,opt,name=synced_to_graph,json=syncedToGraph,proto3" json:"synced_to_graph,omitempty"` + // + //Whether the current node is connected to testnet. This field is + //deprecated and the network field should be used instead + Testnet bool `protobuf:"varint,10,opt,name=testnet,proto3" json:"testnet,omitempty"` // Deprecated: Do not use. + // A list of active chains the node is connected to + Chains []*Chain `protobuf:"bytes,16,rep,name=chains,proto3" json:"chains,omitempty"` + // The URIs of the current node. + Uris []string `protobuf:"bytes,12,rep,name=uris,proto3" json:"uris,omitempty"` + // + //Features that our node has advertised in our init message, node + //announcements and invoices. + Features map[uint32]*Feature `protobuf:"bytes,19,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } +func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } +func (*GetInfoResponse) ProtoMessage() {} +func (*GetInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{47} +} + +func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetInfoResponse.Unmarshal(m, b) +} +func (m *GetInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetInfoResponse.Marshal(b, m, deterministic) +} +func (m *GetInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetInfoResponse.Merge(m, src) +} +func (m *GetInfoResponse) XXX_Size() int { + return xxx_messageInfo_GetInfoResponse.Size(m) +} +func (m *GetInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetInfoResponse proto.InternalMessageInfo + +func (m *GetInfoResponse) GetVersion() string { + if m != nil { + return m.Version + } + return "" +} + +func (m *GetInfoResponse) GetCommitHash() string { + if m != nil { + return m.CommitHash + } + return "" +} + +func (m *GetInfoResponse) GetIdentityPubkey() string { + if m != nil { + return m.IdentityPubkey + } + return "" +} + +func (m *GetInfoResponse) GetAlias() string { + if m != nil { + return m.Alias + } + return "" +} + +func (m *GetInfoResponse) GetColor() string { + if m != nil { + return m.Color + } + return "" +} + +func (m *GetInfoResponse) GetNumPendingChannels() uint32 { + if m != nil { + return m.NumPendingChannels + } + return 0 +} + +func (m *GetInfoResponse) GetNumActiveChannels() uint32 { + if m != nil { + return m.NumActiveChannels + } + return 0 +} + +func (m *GetInfoResponse) GetNumInactiveChannels() uint32 { + if m != nil { + return m.NumInactiveChannels + } + return 0 +} + +func (m *GetInfoResponse) GetNumPeers() uint32 { + if m != nil { + return m.NumPeers + } + return 0 +} + +func (m *GetInfoResponse) GetBlockHeight() uint32 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +func (m *GetInfoResponse) GetBlockHash() string { + if m != nil { + return m.BlockHash + } + return "" +} + +func (m *GetInfoResponse) GetBestHeaderTimestamp() int64 { + if m != nil { + return m.BestHeaderTimestamp + } + return 0 +} + +func (m *GetInfoResponse) GetSyncedToChain() bool { + if m != nil { + return m.SyncedToChain + } + return false +} + +func (m *GetInfoResponse) GetSyncedToGraph() bool { + if m != nil { + return m.SyncedToGraph + } + return false +} + +// Deprecated: Do not use. +func (m *GetInfoResponse) GetTestnet() bool { + if m != nil { + return m.Testnet + } + return false +} + +func (m *GetInfoResponse) GetChains() []*Chain { + if m != nil { + return m.Chains + } + return nil +} + +func (m *GetInfoResponse) GetUris() []string { + if m != nil { + return m.Uris + } + return nil +} + +func (m *GetInfoResponse) GetFeatures() map[uint32]*Feature { + if m != nil { + return m.Features + } + return nil +} + +type GetRecoveryInfoRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetRecoveryInfoRequest) Reset() { *m = GetRecoveryInfoRequest{} } +func (m *GetRecoveryInfoRequest) String() string { return proto.CompactTextString(m) } +func (*GetRecoveryInfoRequest) ProtoMessage() {} +func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{48} +} + +func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetRecoveryInfoRequest.Unmarshal(m, b) +} +func (m *GetRecoveryInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetRecoveryInfoRequest.Marshal(b, m, deterministic) +} +func (m *GetRecoveryInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRecoveryInfoRequest.Merge(m, src) +} +func (m *GetRecoveryInfoRequest) XXX_Size() int { + return xxx_messageInfo_GetRecoveryInfoRequest.Size(m) +} +func (m *GetRecoveryInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetRecoveryInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetRecoveryInfoRequest proto.InternalMessageInfo + +type GetRecoveryInfoResponse struct { + // Whether the wallet is in recovery mode + RecoveryMode bool `protobuf:"varint,1,opt,name=recovery_mode,json=recoveryMode,proto3" json:"recovery_mode,omitempty"` + // Whether the wallet recovery progress is finished + RecoveryFinished bool `protobuf:"varint,2,opt,name=recovery_finished,json=recoveryFinished,proto3" json:"recovery_finished,omitempty"` + // The recovery progress, ranging from 0 to 1. + Progress float64 `protobuf:"fixed64,3,opt,name=progress,proto3" json:"progress,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetRecoveryInfoResponse) Reset() { *m = GetRecoveryInfoResponse{} } +func (m *GetRecoveryInfoResponse) String() string { return proto.CompactTextString(m) } +func (*GetRecoveryInfoResponse) ProtoMessage() {} +func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{49} +} + +func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GetRecoveryInfoResponse.Unmarshal(m, b) +} +func (m *GetRecoveryInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GetRecoveryInfoResponse.Marshal(b, m, deterministic) +} +func (m *GetRecoveryInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRecoveryInfoResponse.Merge(m, src) +} +func (m *GetRecoveryInfoResponse) XXX_Size() int { + return xxx_messageInfo_GetRecoveryInfoResponse.Size(m) +} +func (m *GetRecoveryInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetRecoveryInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetRecoveryInfoResponse proto.InternalMessageInfo + +func (m *GetRecoveryInfoResponse) GetRecoveryMode() bool { + if m != nil { + return m.RecoveryMode + } + return false +} + +func (m *GetRecoveryInfoResponse) GetRecoveryFinished() bool { + if m != nil { + return m.RecoveryFinished + } + return false +} + +func (m *GetRecoveryInfoResponse) GetProgress() float64 { + if m != nil { + return m.Progress + } + return 0 +} + +type Chain struct { + // The blockchain the node is on (eg bitcoin, litecoin) + Chain string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"` + // The network the node is on (eg regtest, testnet, mainnet) + Network string `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Chain) Reset() { *m = Chain{} } +func (m *Chain) String() string { return proto.CompactTextString(m) } +func (*Chain) ProtoMessage() {} +func (*Chain) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{50} +} + +func (m *Chain) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Chain.Unmarshal(m, b) +} +func (m *Chain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Chain.Marshal(b, m, deterministic) +} +func (m *Chain) XXX_Merge(src proto.Message) { + xxx_messageInfo_Chain.Merge(m, src) +} +func (m *Chain) XXX_Size() int { + return xxx_messageInfo_Chain.Size(m) +} +func (m *Chain) XXX_DiscardUnknown() { + xxx_messageInfo_Chain.DiscardUnknown(m) +} + +var xxx_messageInfo_Chain proto.InternalMessageInfo + +func (m *Chain) GetChain() string { + if m != nil { + return m.Chain + } + return "" +} + +func (m *Chain) GetNetwork() string { + if m != nil { + return m.Network + } + return "" +} + +type ConfirmationUpdate struct { + BlockSha []byte `protobuf:"bytes,1,opt,name=block_sha,json=blockSha,proto3" json:"block_sha,omitempty"` + BlockHeight int32 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + NumConfsLeft uint32 `protobuf:"varint,3,opt,name=num_confs_left,json=numConfsLeft,proto3" json:"num_confs_left,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfirmationUpdate) Reset() { *m = ConfirmationUpdate{} } +func (m *ConfirmationUpdate) String() string { return proto.CompactTextString(m) } +func (*ConfirmationUpdate) ProtoMessage() {} +func (*ConfirmationUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{51} +} + +func (m *ConfirmationUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ConfirmationUpdate.Unmarshal(m, b) +} +func (m *ConfirmationUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ConfirmationUpdate.Marshal(b, m, deterministic) +} +func (m *ConfirmationUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfirmationUpdate.Merge(m, src) +} +func (m *ConfirmationUpdate) XXX_Size() int { + return xxx_messageInfo_ConfirmationUpdate.Size(m) +} +func (m *ConfirmationUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ConfirmationUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ConfirmationUpdate proto.InternalMessageInfo + +func (m *ConfirmationUpdate) GetBlockSha() []byte { + if m != nil { + return m.BlockSha + } + return nil +} + +func (m *ConfirmationUpdate) GetBlockHeight() int32 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +func (m *ConfirmationUpdate) GetNumConfsLeft() uint32 { + if m != nil { + return m.NumConfsLeft + } + return 0 +} + +type ChannelOpenUpdate struct { + ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelOpenUpdate) Reset() { *m = ChannelOpenUpdate{} } +func (m *ChannelOpenUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelOpenUpdate) ProtoMessage() {} +func (*ChannelOpenUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{52} +} + +func (m *ChannelOpenUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelOpenUpdate.Unmarshal(m, b) +} +func (m *ChannelOpenUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelOpenUpdate.Marshal(b, m, deterministic) +} +func (m *ChannelOpenUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelOpenUpdate.Merge(m, src) +} +func (m *ChannelOpenUpdate) XXX_Size() int { + return xxx_messageInfo_ChannelOpenUpdate.Size(m) +} +func (m *ChannelOpenUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelOpenUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelOpenUpdate proto.InternalMessageInfo + +func (m *ChannelOpenUpdate) GetChannelPoint() *ChannelPoint { + if m != nil { + return m.ChannelPoint + } + return nil +} + +type ChannelCloseUpdate struct { + ClosingTxid []byte `protobuf:"bytes,1,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` + Success bool `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelCloseUpdate) Reset() { *m = ChannelCloseUpdate{} } +func (m *ChannelCloseUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelCloseUpdate) ProtoMessage() {} +func (*ChannelCloseUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{53} +} + +func (m *ChannelCloseUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelCloseUpdate.Unmarshal(m, b) +} +func (m *ChannelCloseUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelCloseUpdate.Marshal(b, m, deterministic) +} +func (m *ChannelCloseUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelCloseUpdate.Merge(m, src) +} +func (m *ChannelCloseUpdate) XXX_Size() int { + return xxx_messageInfo_ChannelCloseUpdate.Size(m) +} +func (m *ChannelCloseUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelCloseUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelCloseUpdate proto.InternalMessageInfo + +func (m *ChannelCloseUpdate) GetClosingTxid() []byte { + if m != nil { + return m.ClosingTxid + } + return nil +} + +func (m *ChannelCloseUpdate) GetSuccess() bool { + if m != nil { + return m.Success + } + return false +} + +type CloseChannelRequest struct { + // + //The outpoint (txid:index) of the funding transaction. With this value, Bob + //will be able to generate a signature for Alice's version of the commitment + //transaction. + ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + // If true, then the channel will be closed forcibly. This means the + // current commitment transaction will be signed and broadcast. + Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"` + // The target number of blocks that the closure transaction should be + // confirmed by. + TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` + // A manual fee rate set in sat/byte that should be used when crafting the + // closure transaction. + SatPerByte int64 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` + // + //An optional address to send funds to in the case of a cooperative close. + //If the channel was opened with an upfront shutdown script and this field + //is set, the request to close will fail because the channel must pay out + //to the upfront shutdown addresss. + DeliveryAddress string `protobuf:"bytes,5,opt,name=delivery_address,json=deliveryAddress,proto3" json:"delivery_address,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } +func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } +func (*CloseChannelRequest) ProtoMessage() {} +func (*CloseChannelRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{54} +} + +func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CloseChannelRequest.Unmarshal(m, b) +} +func (m *CloseChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CloseChannelRequest.Marshal(b, m, deterministic) +} +func (m *CloseChannelRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloseChannelRequest.Merge(m, src) +} +func (m *CloseChannelRequest) XXX_Size() int { + return xxx_messageInfo_CloseChannelRequest.Size(m) +} +func (m *CloseChannelRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CloseChannelRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_CloseChannelRequest proto.InternalMessageInfo + +func (m *CloseChannelRequest) GetChannelPoint() *ChannelPoint { + if m != nil { + return m.ChannelPoint + } + return nil +} + +func (m *CloseChannelRequest) GetForce() bool { + if m != nil { + return m.Force + } + return false +} + +func (m *CloseChannelRequest) GetTargetConf() int32 { + if m != nil { + return m.TargetConf + } + return 0 +} + +func (m *CloseChannelRequest) GetSatPerByte() int64 { + if m != nil { + return m.SatPerByte + } + return 0 +} + +func (m *CloseChannelRequest) GetDeliveryAddress() string { + if m != nil { + return m.DeliveryAddress + } + return "" +} + +type CloseStatusUpdate struct { + // Types that are valid to be assigned to Update: + // *CloseStatusUpdate_ClosePending + // *CloseStatusUpdate_ChanClose + Update isCloseStatusUpdate_Update `protobuf_oneof:"update"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CloseStatusUpdate) Reset() { *m = CloseStatusUpdate{} } +func (m *CloseStatusUpdate) String() string { return proto.CompactTextString(m) } +func (*CloseStatusUpdate) ProtoMessage() {} +func (*CloseStatusUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{55} +} + +func (m *CloseStatusUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CloseStatusUpdate.Unmarshal(m, b) +} +func (m *CloseStatusUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CloseStatusUpdate.Marshal(b, m, deterministic) +} +func (m *CloseStatusUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_CloseStatusUpdate.Merge(m, src) +} +func (m *CloseStatusUpdate) XXX_Size() int { + return xxx_messageInfo_CloseStatusUpdate.Size(m) +} +func (m *CloseStatusUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_CloseStatusUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_CloseStatusUpdate proto.InternalMessageInfo + +type isCloseStatusUpdate_Update interface { + isCloseStatusUpdate_Update() +} + +type CloseStatusUpdate_ClosePending struct { + ClosePending *PendingUpdate `protobuf:"bytes,1,opt,name=close_pending,json=closePending,proto3,oneof"` +} + +type CloseStatusUpdate_ChanClose struct { + ChanClose *ChannelCloseUpdate `protobuf:"bytes,3,opt,name=chan_close,json=chanClose,proto3,oneof"` +} + +func (*CloseStatusUpdate_ClosePending) isCloseStatusUpdate_Update() {} + +func (*CloseStatusUpdate_ChanClose) isCloseStatusUpdate_Update() {} + +func (m *CloseStatusUpdate) GetUpdate() isCloseStatusUpdate_Update { + if m != nil { + return m.Update + } + return nil +} + +func (m *CloseStatusUpdate) GetClosePending() *PendingUpdate { + if x, ok := m.GetUpdate().(*CloseStatusUpdate_ClosePending); ok { + return x.ClosePending + } + return nil +} + +func (m *CloseStatusUpdate) GetChanClose() *ChannelCloseUpdate { + if x, ok := m.GetUpdate().(*CloseStatusUpdate_ChanClose); ok { + return x.ChanClose + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*CloseStatusUpdate) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*CloseStatusUpdate_ClosePending)(nil), + (*CloseStatusUpdate_ChanClose)(nil), + } +} + +type PendingUpdate struct { + Txid []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` + OutputIndex uint32 `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingUpdate) Reset() { *m = PendingUpdate{} } +func (m *PendingUpdate) String() string { return proto.CompactTextString(m) } +func (*PendingUpdate) ProtoMessage() {} +func (*PendingUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{56} +} + +func (m *PendingUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingUpdate.Unmarshal(m, b) +} +func (m *PendingUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingUpdate.Marshal(b, m, deterministic) +} +func (m *PendingUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingUpdate.Merge(m, src) +} +func (m *PendingUpdate) XXX_Size() int { + return xxx_messageInfo_PendingUpdate.Size(m) +} +func (m *PendingUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_PendingUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingUpdate proto.InternalMessageInfo + +func (m *PendingUpdate) GetTxid() []byte { + if m != nil { + return m.Txid + } + return nil +} + +func (m *PendingUpdate) GetOutputIndex() uint32 { + if m != nil { + return m.OutputIndex + } + return 0 +} + +type ReadyForPsbtFunding struct { + // + //The P2WSH address of the channel funding multisig address that the below + //specified amount in satoshis needs to be sent to. + FundingAddress string `protobuf:"bytes,1,opt,name=funding_address,json=fundingAddress,proto3" json:"funding_address,omitempty"` + // + //The exact amount in satoshis that needs to be sent to the above address to + //fund the pending channel. + FundingAmount int64 `protobuf:"varint,2,opt,name=funding_amount,json=fundingAmount,proto3" json:"funding_amount,omitempty"` + // + //A raw PSBT that contains the pending channel output. If a base PSBT was + //provided in the PsbtShim, this is the base PSBT with one additional output. + //If no base PSBT was specified, this is an otherwise empty PSBT with exactly + //one output. + Psbt []byte `protobuf:"bytes,3,opt,name=psbt,proto3" json:"psbt,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReadyForPsbtFunding) Reset() { *m = ReadyForPsbtFunding{} } +func (m *ReadyForPsbtFunding) String() string { return proto.CompactTextString(m) } +func (*ReadyForPsbtFunding) ProtoMessage() {} +func (*ReadyForPsbtFunding) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{57} +} + +func (m *ReadyForPsbtFunding) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ReadyForPsbtFunding.Unmarshal(m, b) +} +func (m *ReadyForPsbtFunding) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ReadyForPsbtFunding.Marshal(b, m, deterministic) +} +func (m *ReadyForPsbtFunding) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReadyForPsbtFunding.Merge(m, src) +} +func (m *ReadyForPsbtFunding) XXX_Size() int { + return xxx_messageInfo_ReadyForPsbtFunding.Size(m) +} +func (m *ReadyForPsbtFunding) XXX_DiscardUnknown() { + xxx_messageInfo_ReadyForPsbtFunding.DiscardUnknown(m) +} + +var xxx_messageInfo_ReadyForPsbtFunding proto.InternalMessageInfo + +func (m *ReadyForPsbtFunding) GetFundingAddress() string { + if m != nil { + return m.FundingAddress + } + return "" +} + +func (m *ReadyForPsbtFunding) GetFundingAmount() int64 { + if m != nil { + return m.FundingAmount + } + return 0 +} + +func (m *ReadyForPsbtFunding) GetPsbt() []byte { + if m != nil { + return m.Psbt + } + return nil +} + +type OpenChannelRequest struct { + // + //The pubkey of the node to open a channel with. When using REST, this field + //must be encoded as base64. + NodePubkey []byte `protobuf:"bytes,2,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"` + // + //The hex encoded pubkey of the node to open a channel with. Deprecated now + //that the REST gateway supports base64 encoding of bytes fields. + NodePubkeyString string `protobuf:"bytes,3,opt,name=node_pubkey_string,json=nodePubkeyString,proto3" json:"node_pubkey_string,omitempty"` // Deprecated: Do not use. + // The number of satoshis the wallet should commit to the channel + LocalFundingAmount int64 `protobuf:"varint,4,opt,name=local_funding_amount,json=localFundingAmount,proto3" json:"local_funding_amount,omitempty"` + // The number of satoshis to push to the remote side as part of the initial + // commitment state + PushSat int64 `protobuf:"varint,5,opt,name=push_sat,json=pushSat,proto3" json:"push_sat,omitempty"` + // The target number of blocks that the funding transaction should be + // confirmed by. + TargetConf int32 `protobuf:"varint,6,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` + // A manual fee rate set in sat/byte that should be used when crafting the + // funding transaction. + SatPerByte int64 `protobuf:"varint,7,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` + // Whether this channel should be private, not announced to the greater + // network. + Private bool `protobuf:"varint,8,opt,name=private,proto3" json:"private,omitempty"` + // The minimum value in millisatoshi we will require for incoming HTLCs on + // the channel. + MinHtlcMsat int64 `protobuf:"varint,9,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` + // The delay we require on the remote's commitment transaction. If this is + // not set, it will be scaled automatically with the channel size. + RemoteCsvDelay uint32 `protobuf:"varint,10,opt,name=remote_csv_delay,json=remoteCsvDelay,proto3" json:"remote_csv_delay,omitempty"` + // The minimum number of confirmations each one of your outputs used for + // the funding transaction must satisfy. + MinConfs int32 `protobuf:"varint,11,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` + // Whether unconfirmed outputs should be used as inputs for the funding + // transaction. + SpendUnconfirmed bool `protobuf:"varint,12,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` + // + //Close address is an optional address which specifies the address to which + //funds should be paid out to upon cooperative close. This field may only be + //set if the peer supports the option upfront feature bit (call listpeers + //to check). The remote peer will only accept cooperative closes to this + //address if it is set. + // + //Note: If this value is set on channel creation, you will *not* be able to + //cooperatively close out to a different address. + CloseAddress string `protobuf:"bytes,13,opt,name=close_address,json=closeAddress,proto3" json:"close_address,omitempty"` + // + //Funding shims are an optional argument that allow the caller to intercept + //certain funding functionality. For example, a shim can be provided to use a + //particular key for the commitment key (ideally cold) rather than use one + //that is generated by the wallet as normal, or signal that signing will be + //carried out in an interactive manner (PSBT based). + FundingShim *FundingShim `protobuf:"bytes,14,opt,name=funding_shim,json=fundingShim,proto3" json:"funding_shim,omitempty"` + // + //The maximum amount of coins in millisatoshi that can be pending within + //the channel. It only applies to the remote party. + RemoteMaxValueInFlightMsat uint64 `protobuf:"varint,15,opt,name=remote_max_value_in_flight_msat,json=remoteMaxValueInFlightMsat,proto3" json:"remote_max_value_in_flight_msat,omitempty"` + // + //The maximum number of concurrent HTLCs we will allow the remote party to add + //to the commitment transaction. + RemoteMaxHtlcs uint32 `protobuf:"varint,16,opt,name=remote_max_htlcs,json=remoteMaxHtlcs,proto3" json:"remote_max_htlcs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } +func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } +func (*OpenChannelRequest) ProtoMessage() {} +func (*OpenChannelRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{58} +} + +func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_OpenChannelRequest.Unmarshal(m, b) +} +func (m *OpenChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_OpenChannelRequest.Marshal(b, m, deterministic) +} +func (m *OpenChannelRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_OpenChannelRequest.Merge(m, src) +} +func (m *OpenChannelRequest) XXX_Size() int { + return xxx_messageInfo_OpenChannelRequest.Size(m) +} +func (m *OpenChannelRequest) XXX_DiscardUnknown() { + xxx_messageInfo_OpenChannelRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_OpenChannelRequest proto.InternalMessageInfo + +func (m *OpenChannelRequest) GetNodePubkey() []byte { + if m != nil { + return m.NodePubkey + } + return nil +} + +// Deprecated: Do not use. +func (m *OpenChannelRequest) GetNodePubkeyString() string { + if m != nil { + return m.NodePubkeyString + } + return "" +} + +func (m *OpenChannelRequest) GetLocalFundingAmount() int64 { + if m != nil { + return m.LocalFundingAmount + } + return 0 +} + +func (m *OpenChannelRequest) GetPushSat() int64 { + if m != nil { + return m.PushSat + } + return 0 +} + +func (m *OpenChannelRequest) GetTargetConf() int32 { + if m != nil { + return m.TargetConf + } + return 0 +} + +func (m *OpenChannelRequest) GetSatPerByte() int64 { + if m != nil { + return m.SatPerByte + } + return 0 +} + +func (m *OpenChannelRequest) GetPrivate() bool { + if m != nil { + return m.Private + } + return false +} + +func (m *OpenChannelRequest) GetMinHtlcMsat() int64 { + if m != nil { + return m.MinHtlcMsat + } + return 0 +} + +func (m *OpenChannelRequest) GetRemoteCsvDelay() uint32 { + if m != nil { + return m.RemoteCsvDelay + } + return 0 +} + +func (m *OpenChannelRequest) GetMinConfs() int32 { + if m != nil { + return m.MinConfs + } + return 0 +} + +func (m *OpenChannelRequest) GetSpendUnconfirmed() bool { + if m != nil { + return m.SpendUnconfirmed + } + return false +} + +func (m *OpenChannelRequest) GetCloseAddress() string { + if m != nil { + return m.CloseAddress + } + return "" +} + +func (m *OpenChannelRequest) GetFundingShim() *FundingShim { + if m != nil { + return m.FundingShim + } + return nil +} + +func (m *OpenChannelRequest) GetRemoteMaxValueInFlightMsat() uint64 { + if m != nil { + return m.RemoteMaxValueInFlightMsat + } + return 0 +} + +func (m *OpenChannelRequest) GetRemoteMaxHtlcs() uint32 { + if m != nil { + return m.RemoteMaxHtlcs + } + return 0 +} + +type OpenStatusUpdate struct { + // Types that are valid to be assigned to Update: + // *OpenStatusUpdate_ChanPending + // *OpenStatusUpdate_ChanOpen + // *OpenStatusUpdate_PsbtFund + Update isOpenStatusUpdate_Update `protobuf_oneof:"update"` + // + //The pending channel ID of the created channel. This value may be used to + //further the funding flow manually via the FundingStateStep method. + PendingChanId []byte `protobuf:"bytes,4,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *OpenStatusUpdate) Reset() { *m = OpenStatusUpdate{} } +func (m *OpenStatusUpdate) String() string { return proto.CompactTextString(m) } +func (*OpenStatusUpdate) ProtoMessage() {} +func (*OpenStatusUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{59} +} + +func (m *OpenStatusUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_OpenStatusUpdate.Unmarshal(m, b) +} +func (m *OpenStatusUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_OpenStatusUpdate.Marshal(b, m, deterministic) +} +func (m *OpenStatusUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_OpenStatusUpdate.Merge(m, src) +} +func (m *OpenStatusUpdate) XXX_Size() int { + return xxx_messageInfo_OpenStatusUpdate.Size(m) +} +func (m *OpenStatusUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_OpenStatusUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_OpenStatusUpdate proto.InternalMessageInfo + +type isOpenStatusUpdate_Update interface { + isOpenStatusUpdate_Update() +} + +type OpenStatusUpdate_ChanPending struct { + ChanPending *PendingUpdate `protobuf:"bytes,1,opt,name=chan_pending,json=chanPending,proto3,oneof"` +} + +type OpenStatusUpdate_ChanOpen struct { + ChanOpen *ChannelOpenUpdate `protobuf:"bytes,3,opt,name=chan_open,json=chanOpen,proto3,oneof"` +} + +type OpenStatusUpdate_PsbtFund struct { + PsbtFund *ReadyForPsbtFunding `protobuf:"bytes,5,opt,name=psbt_fund,json=psbtFund,proto3,oneof"` +} + +func (*OpenStatusUpdate_ChanPending) isOpenStatusUpdate_Update() {} + +func (*OpenStatusUpdate_ChanOpen) isOpenStatusUpdate_Update() {} + +func (*OpenStatusUpdate_PsbtFund) isOpenStatusUpdate_Update() {} + +func (m *OpenStatusUpdate) GetUpdate() isOpenStatusUpdate_Update { + if m != nil { + return m.Update + } + return nil +} + +func (m *OpenStatusUpdate) GetChanPending() *PendingUpdate { + if x, ok := m.GetUpdate().(*OpenStatusUpdate_ChanPending); ok { + return x.ChanPending + } + return nil +} + +func (m *OpenStatusUpdate) GetChanOpen() *ChannelOpenUpdate { + if x, ok := m.GetUpdate().(*OpenStatusUpdate_ChanOpen); ok { + return x.ChanOpen + } + return nil +} + +func (m *OpenStatusUpdate) GetPsbtFund() *ReadyForPsbtFunding { + if x, ok := m.GetUpdate().(*OpenStatusUpdate_PsbtFund); ok { + return x.PsbtFund + } + return nil +} + +func (m *OpenStatusUpdate) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*OpenStatusUpdate) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*OpenStatusUpdate_ChanPending)(nil), + (*OpenStatusUpdate_ChanOpen)(nil), + (*OpenStatusUpdate_PsbtFund)(nil), + } +} + +type KeyLocator struct { + // The family of key being identified. + KeyFamily int32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` + // The precise index of the key being identified. + KeyIndex int32 `protobuf:"varint,2,opt,name=key_index,json=keyIndex,proto3" json:"key_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyLocator) Reset() { *m = KeyLocator{} } +func (m *KeyLocator) String() string { return proto.CompactTextString(m) } +func (*KeyLocator) ProtoMessage() {} +func (*KeyLocator) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{60} +} + +func (m *KeyLocator) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_KeyLocator.Unmarshal(m, b) +} +func (m *KeyLocator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_KeyLocator.Marshal(b, m, deterministic) +} +func (m *KeyLocator) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyLocator.Merge(m, src) +} +func (m *KeyLocator) XXX_Size() int { + return xxx_messageInfo_KeyLocator.Size(m) +} +func (m *KeyLocator) XXX_DiscardUnknown() { + xxx_messageInfo_KeyLocator.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyLocator proto.InternalMessageInfo + +func (m *KeyLocator) GetKeyFamily() int32 { + if m != nil { + return m.KeyFamily + } + return 0 +} + +func (m *KeyLocator) GetKeyIndex() int32 { + if m != nil { + return m.KeyIndex + } + return 0 +} + +type KeyDescriptor struct { + // + //The raw bytes of the key being identified. + RawKeyBytes []byte `protobuf:"bytes,1,opt,name=raw_key_bytes,json=rawKeyBytes,proto3" json:"raw_key_bytes,omitempty"` + // + //The key locator that identifies which key to use for signing. + KeyLoc *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyDescriptor) Reset() { *m = KeyDescriptor{} } +func (m *KeyDescriptor) String() string { return proto.CompactTextString(m) } +func (*KeyDescriptor) ProtoMessage() {} +func (*KeyDescriptor) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{61} +} + +func (m *KeyDescriptor) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_KeyDescriptor.Unmarshal(m, b) +} +func (m *KeyDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_KeyDescriptor.Marshal(b, m, deterministic) +} +func (m *KeyDescriptor) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyDescriptor.Merge(m, src) +} +func (m *KeyDescriptor) XXX_Size() int { + return xxx_messageInfo_KeyDescriptor.Size(m) +} +func (m *KeyDescriptor) XXX_DiscardUnknown() { + xxx_messageInfo_KeyDescriptor.DiscardUnknown(m) +} + +var xxx_messageInfo_KeyDescriptor proto.InternalMessageInfo + +func (m *KeyDescriptor) GetRawKeyBytes() []byte { + if m != nil { + return m.RawKeyBytes + } + return nil +} + +func (m *KeyDescriptor) GetKeyLoc() *KeyLocator { + if m != nil { + return m.KeyLoc + } + return nil +} + +type ChanPointShim struct { + // + //The size of the pre-crafted output to be used as the channel point for this + //channel funding. + Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"` + // The target channel point to refrence in created commitment transactions. + ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + // Our local key to use when creating the multi-sig output. + LocalKey *KeyDescriptor `protobuf:"bytes,3,opt,name=local_key,json=localKey,proto3" json:"local_key,omitempty"` + // The key of the remote party to use when creating the multi-sig output. + RemoteKey []byte `protobuf:"bytes,4,opt,name=remote_key,json=remoteKey,proto3" json:"remote_key,omitempty"` + // + //If non-zero, then this will be used as the pending channel ID on the wire + //protocol to initate the funding request. This is an optional field, and + //should only be set if the responder is already expecting a specific pending + //channel ID. + PendingChanId []byte `protobuf:"bytes,5,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + // + //This uint32 indicates if this channel is to be considered 'frozen'. A frozen + //channel does not allow a cooperative channel close by the initiator. The + //thaw_height is the height that this restriction stops applying to the + //channel. The height can be interpreted in two ways: as a relative height if + //the value is less than 500,000, or as an absolute height otherwise. + ThawHeight uint32 `protobuf:"varint,6,opt,name=thaw_height,json=thawHeight,proto3" json:"thaw_height,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChanPointShim) Reset() { *m = ChanPointShim{} } +func (m *ChanPointShim) String() string { return proto.CompactTextString(m) } +func (*ChanPointShim) ProtoMessage() {} +func (*ChanPointShim) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{62} +} + +func (m *ChanPointShim) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChanPointShim.Unmarshal(m, b) +} +func (m *ChanPointShim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChanPointShim.Marshal(b, m, deterministic) +} +func (m *ChanPointShim) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChanPointShim.Merge(m, src) +} +func (m *ChanPointShim) XXX_Size() int { + return xxx_messageInfo_ChanPointShim.Size(m) +} +func (m *ChanPointShim) XXX_DiscardUnknown() { + xxx_messageInfo_ChanPointShim.DiscardUnknown(m) +} + +var xxx_messageInfo_ChanPointShim proto.InternalMessageInfo + +func (m *ChanPointShim) GetAmt() int64 { + if m != nil { + return m.Amt + } + return 0 +} + +func (m *ChanPointShim) GetChanPoint() *ChannelPoint { + if m != nil { + return m.ChanPoint + } + return nil +} + +func (m *ChanPointShim) GetLocalKey() *KeyDescriptor { + if m != nil { + return m.LocalKey + } + return nil +} + +func (m *ChanPointShim) GetRemoteKey() []byte { + if m != nil { + return m.RemoteKey + } + return nil +} + +func (m *ChanPointShim) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +func (m *ChanPointShim) GetThawHeight() uint32 { + if m != nil { + return m.ThawHeight + } + return 0 +} + +type PsbtShim struct { + // + //A unique identifier of 32 random bytes that will be used as the pending + //channel ID to identify the PSBT state machine when interacting with it and + //on the wire protocol to initiate the funding request. + PendingChanId []byte `protobuf:"bytes,1,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + // + //An optional base PSBT the new channel output will be added to. If this is + //non-empty, it must be a binary serialized PSBT. + BasePsbt []byte `protobuf:"bytes,2,opt,name=base_psbt,json=basePsbt,proto3" json:"base_psbt,omitempty"` + // + //If a channel should be part of a batch (multiple channel openings in one + //transaction), it can be dangerous if the whole batch transaction is + //published too early before all channel opening negotiations are completed. + //This flag prevents this particular channel from broadcasting the transaction + //after the negotiation with the remote peer. In a batch of channel openings + //this flag should be set to true for every channel but the very last. + NoPublish bool `protobuf:"varint,3,opt,name=no_publish,json=noPublish,proto3" json:"no_publish,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PsbtShim) Reset() { *m = PsbtShim{} } +func (m *PsbtShim) String() string { return proto.CompactTextString(m) } +func (*PsbtShim) ProtoMessage() {} +func (*PsbtShim) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{63} +} + +func (m *PsbtShim) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PsbtShim.Unmarshal(m, b) +} +func (m *PsbtShim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PsbtShim.Marshal(b, m, deterministic) +} +func (m *PsbtShim) XXX_Merge(src proto.Message) { + xxx_messageInfo_PsbtShim.Merge(m, src) +} +func (m *PsbtShim) XXX_Size() int { + return xxx_messageInfo_PsbtShim.Size(m) +} +func (m *PsbtShim) XXX_DiscardUnknown() { + xxx_messageInfo_PsbtShim.DiscardUnknown(m) +} + +var xxx_messageInfo_PsbtShim proto.InternalMessageInfo + +func (m *PsbtShim) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +func (m *PsbtShim) GetBasePsbt() []byte { + if m != nil { + return m.BasePsbt + } + return nil +} + +func (m *PsbtShim) GetNoPublish() bool { + if m != nil { + return m.NoPublish + } + return false +} + +type FundingShim struct { + // Types that are valid to be assigned to Shim: + // *FundingShim_ChanPointShim + // *FundingShim_PsbtShim + Shim isFundingShim_Shim `protobuf_oneof:"shim"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingShim) Reset() { *m = FundingShim{} } +func (m *FundingShim) String() string { return proto.CompactTextString(m) } +func (*FundingShim) ProtoMessage() {} +func (*FundingShim) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{64} +} + +func (m *FundingShim) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingShim.Unmarshal(m, b) +} +func (m *FundingShim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingShim.Marshal(b, m, deterministic) +} +func (m *FundingShim) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingShim.Merge(m, src) +} +func (m *FundingShim) XXX_Size() int { + return xxx_messageInfo_FundingShim.Size(m) +} +func (m *FundingShim) XXX_DiscardUnknown() { + xxx_messageInfo_FundingShim.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingShim proto.InternalMessageInfo + +type isFundingShim_Shim interface { + isFundingShim_Shim() +} + +type FundingShim_ChanPointShim struct { + ChanPointShim *ChanPointShim `protobuf:"bytes,1,opt,name=chan_point_shim,json=chanPointShim,proto3,oneof"` +} + +type FundingShim_PsbtShim struct { + PsbtShim *PsbtShim `protobuf:"bytes,2,opt,name=psbt_shim,json=psbtShim,proto3,oneof"` +} + +func (*FundingShim_ChanPointShim) isFundingShim_Shim() {} + +func (*FundingShim_PsbtShim) isFundingShim_Shim() {} + +func (m *FundingShim) GetShim() isFundingShim_Shim { + if m != nil { + return m.Shim + } + return nil +} + +func (m *FundingShim) GetChanPointShim() *ChanPointShim { + if x, ok := m.GetShim().(*FundingShim_ChanPointShim); ok { + return x.ChanPointShim + } + return nil +} + +func (m *FundingShim) GetPsbtShim() *PsbtShim { + if x, ok := m.GetShim().(*FundingShim_PsbtShim); ok { + return x.PsbtShim + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*FundingShim) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*FundingShim_ChanPointShim)(nil), + (*FundingShim_PsbtShim)(nil), + } +} + +type FundingShimCancel struct { + // The pending channel ID of the channel to cancel the funding shim for. + PendingChanId []byte `protobuf:"bytes,1,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingShimCancel) Reset() { *m = FundingShimCancel{} } +func (m *FundingShimCancel) String() string { return proto.CompactTextString(m) } +func (*FundingShimCancel) ProtoMessage() {} +func (*FundingShimCancel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{65} +} + +func (m *FundingShimCancel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingShimCancel.Unmarshal(m, b) +} +func (m *FundingShimCancel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingShimCancel.Marshal(b, m, deterministic) +} +func (m *FundingShimCancel) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingShimCancel.Merge(m, src) +} +func (m *FundingShimCancel) XXX_Size() int { + return xxx_messageInfo_FundingShimCancel.Size(m) +} +func (m *FundingShimCancel) XXX_DiscardUnknown() { + xxx_messageInfo_FundingShimCancel.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingShimCancel proto.InternalMessageInfo + +func (m *FundingShimCancel) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +type FundingPsbtVerify struct { + // + //The funded but not yet signed PSBT that sends the exact channel capacity + //amount to the PK script returned in the open channel message in a previous + //step. + FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"` + // The pending channel ID of the channel to get the PSBT for. + PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingPsbtVerify) Reset() { *m = FundingPsbtVerify{} } +func (m *FundingPsbtVerify) String() string { return proto.CompactTextString(m) } +func (*FundingPsbtVerify) ProtoMessage() {} +func (*FundingPsbtVerify) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{66} +} + +func (m *FundingPsbtVerify) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingPsbtVerify.Unmarshal(m, b) +} +func (m *FundingPsbtVerify) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingPsbtVerify.Marshal(b, m, deterministic) +} +func (m *FundingPsbtVerify) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingPsbtVerify.Merge(m, src) +} +func (m *FundingPsbtVerify) XXX_Size() int { + return xxx_messageInfo_FundingPsbtVerify.Size(m) +} +func (m *FundingPsbtVerify) XXX_DiscardUnknown() { + xxx_messageInfo_FundingPsbtVerify.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingPsbtVerify proto.InternalMessageInfo + +func (m *FundingPsbtVerify) GetFundedPsbt() []byte { + if m != nil { + return m.FundedPsbt + } + return nil +} + +func (m *FundingPsbtVerify) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +type FundingPsbtFinalize struct { + // + //The funded PSBT that contains all witness data to send the exact channel + //capacity amount to the PK script returned in the open channel message in a + //previous step. Cannot be set at the same time as final_raw_tx. + SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"` + // The pending channel ID of the channel to get the PSBT for. + PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + // + //As an alternative to the signed PSBT with all witness data, the final raw + //wire format transaction can also be specified directly. Cannot be set at the + //same time as signed_psbt. + FinalRawTx []byte `protobuf:"bytes,3,opt,name=final_raw_tx,json=finalRawTx,proto3" json:"final_raw_tx,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingPsbtFinalize) Reset() { *m = FundingPsbtFinalize{} } +func (m *FundingPsbtFinalize) String() string { return proto.CompactTextString(m) } +func (*FundingPsbtFinalize) ProtoMessage() {} +func (*FundingPsbtFinalize) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{67} +} + +func (m *FundingPsbtFinalize) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingPsbtFinalize.Unmarshal(m, b) +} +func (m *FundingPsbtFinalize) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingPsbtFinalize.Marshal(b, m, deterministic) +} +func (m *FundingPsbtFinalize) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingPsbtFinalize.Merge(m, src) +} +func (m *FundingPsbtFinalize) XXX_Size() int { + return xxx_messageInfo_FundingPsbtFinalize.Size(m) +} +func (m *FundingPsbtFinalize) XXX_DiscardUnknown() { + xxx_messageInfo_FundingPsbtFinalize.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingPsbtFinalize proto.InternalMessageInfo + +func (m *FundingPsbtFinalize) GetSignedPsbt() []byte { + if m != nil { + return m.SignedPsbt + } + return nil +} + +func (m *FundingPsbtFinalize) GetPendingChanId() []byte { + if m != nil { + return m.PendingChanId + } + return nil +} + +func (m *FundingPsbtFinalize) GetFinalRawTx() []byte { + if m != nil { + return m.FinalRawTx + } + return nil +} + +type FundingTransitionMsg struct { + // Types that are valid to be assigned to Trigger: + // *FundingTransitionMsg_ShimRegister + // *FundingTransitionMsg_ShimCancel + // *FundingTransitionMsg_PsbtVerify + // *FundingTransitionMsg_PsbtFinalize + Trigger isFundingTransitionMsg_Trigger `protobuf_oneof:"trigger"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingTransitionMsg) Reset() { *m = FundingTransitionMsg{} } +func (m *FundingTransitionMsg) String() string { return proto.CompactTextString(m) } +func (*FundingTransitionMsg) ProtoMessage() {} +func (*FundingTransitionMsg) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{68} +} + +func (m *FundingTransitionMsg) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingTransitionMsg.Unmarshal(m, b) +} +func (m *FundingTransitionMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingTransitionMsg.Marshal(b, m, deterministic) +} +func (m *FundingTransitionMsg) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingTransitionMsg.Merge(m, src) +} +func (m *FundingTransitionMsg) XXX_Size() int { + return xxx_messageInfo_FundingTransitionMsg.Size(m) +} +func (m *FundingTransitionMsg) XXX_DiscardUnknown() { + xxx_messageInfo_FundingTransitionMsg.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingTransitionMsg proto.InternalMessageInfo + +type isFundingTransitionMsg_Trigger interface { + isFundingTransitionMsg_Trigger() +} + +type FundingTransitionMsg_ShimRegister struct { + ShimRegister *FundingShim `protobuf:"bytes,1,opt,name=shim_register,json=shimRegister,proto3,oneof"` +} + +type FundingTransitionMsg_ShimCancel struct { + ShimCancel *FundingShimCancel `protobuf:"bytes,2,opt,name=shim_cancel,json=shimCancel,proto3,oneof"` +} + +type FundingTransitionMsg_PsbtVerify struct { + PsbtVerify *FundingPsbtVerify `protobuf:"bytes,3,opt,name=psbt_verify,json=psbtVerify,proto3,oneof"` +} + +type FundingTransitionMsg_PsbtFinalize struct { + PsbtFinalize *FundingPsbtFinalize `protobuf:"bytes,4,opt,name=psbt_finalize,json=psbtFinalize,proto3,oneof"` +} + +func (*FundingTransitionMsg_ShimRegister) isFundingTransitionMsg_Trigger() {} + +func (*FundingTransitionMsg_ShimCancel) isFundingTransitionMsg_Trigger() {} + +func (*FundingTransitionMsg_PsbtVerify) isFundingTransitionMsg_Trigger() {} + +func (*FundingTransitionMsg_PsbtFinalize) isFundingTransitionMsg_Trigger() {} + +func (m *FundingTransitionMsg) GetTrigger() isFundingTransitionMsg_Trigger { + if m != nil { + return m.Trigger + } + return nil +} + +func (m *FundingTransitionMsg) GetShimRegister() *FundingShim { + if x, ok := m.GetTrigger().(*FundingTransitionMsg_ShimRegister); ok { + return x.ShimRegister + } + return nil +} + +func (m *FundingTransitionMsg) GetShimCancel() *FundingShimCancel { + if x, ok := m.GetTrigger().(*FundingTransitionMsg_ShimCancel); ok { + return x.ShimCancel + } + return nil +} + +func (m *FundingTransitionMsg) GetPsbtVerify() *FundingPsbtVerify { + if x, ok := m.GetTrigger().(*FundingTransitionMsg_PsbtVerify); ok { + return x.PsbtVerify + } + return nil +} + +func (m *FundingTransitionMsg) GetPsbtFinalize() *FundingPsbtFinalize { + if x, ok := m.GetTrigger().(*FundingTransitionMsg_PsbtFinalize); ok { + return x.PsbtFinalize + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*FundingTransitionMsg) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*FundingTransitionMsg_ShimRegister)(nil), + (*FundingTransitionMsg_ShimCancel)(nil), + (*FundingTransitionMsg_PsbtVerify)(nil), + (*FundingTransitionMsg_PsbtFinalize)(nil), + } +} + +type FundingStateStepResp struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FundingStateStepResp) Reset() { *m = FundingStateStepResp{} } +func (m *FundingStateStepResp) String() string { return proto.CompactTextString(m) } +func (*FundingStateStepResp) ProtoMessage() {} +func (*FundingStateStepResp) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{69} +} + +func (m *FundingStateStepResp) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FundingStateStepResp.Unmarshal(m, b) +} +func (m *FundingStateStepResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FundingStateStepResp.Marshal(b, m, deterministic) +} +func (m *FundingStateStepResp) XXX_Merge(src proto.Message) { + xxx_messageInfo_FundingStateStepResp.Merge(m, src) +} +func (m *FundingStateStepResp) XXX_Size() int { + return xxx_messageInfo_FundingStateStepResp.Size(m) +} +func (m *FundingStateStepResp) XXX_DiscardUnknown() { + xxx_messageInfo_FundingStateStepResp.DiscardUnknown(m) +} + +var xxx_messageInfo_FundingStateStepResp proto.InternalMessageInfo + +type PendingHTLC struct { + // The direction within the channel that the htlc was sent + Incoming bool `protobuf:"varint,1,opt,name=incoming,proto3" json:"incoming,omitempty"` + // The total value of the htlc + Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` + // The final output to be swept back to the user's wallet + Outpoint string `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + // The next block height at which we can spend the current stage + MaturityHeight uint32 `protobuf:"varint,4,opt,name=maturity_height,json=maturityHeight,proto3" json:"maturity_height,omitempty"` + // + //The number of blocks remaining until the current stage can be swept. + //Negative values indicate how many blocks have passed since becoming + //mature. + BlocksTilMaturity int32 `protobuf:"varint,5,opt,name=blocks_til_maturity,json=blocksTilMaturity,proto3" json:"blocks_til_maturity,omitempty"` + // Indicates whether the htlc is in its first or second stage of recovery + Stage uint32 `protobuf:"varint,6,opt,name=stage,proto3" json:"stage,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingHTLC) Reset() { *m = PendingHTLC{} } +func (m *PendingHTLC) String() string { return proto.CompactTextString(m) } +func (*PendingHTLC) ProtoMessage() {} +func (*PendingHTLC) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{70} +} + +func (m *PendingHTLC) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingHTLC.Unmarshal(m, b) +} +func (m *PendingHTLC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingHTLC.Marshal(b, m, deterministic) +} +func (m *PendingHTLC) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingHTLC.Merge(m, src) +} +func (m *PendingHTLC) XXX_Size() int { + return xxx_messageInfo_PendingHTLC.Size(m) +} +func (m *PendingHTLC) XXX_DiscardUnknown() { + xxx_messageInfo_PendingHTLC.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingHTLC proto.InternalMessageInfo + +func (m *PendingHTLC) GetIncoming() bool { + if m != nil { + return m.Incoming + } + return false +} + +func (m *PendingHTLC) GetAmount() int64 { + if m != nil { + return m.Amount + } + return 0 +} + +func (m *PendingHTLC) GetOutpoint() string { + if m != nil { + return m.Outpoint + } + return "" +} + +func (m *PendingHTLC) GetMaturityHeight() uint32 { + if m != nil { + return m.MaturityHeight + } + return 0 +} + +func (m *PendingHTLC) GetBlocksTilMaturity() int32 { + if m != nil { + return m.BlocksTilMaturity + } + return 0 +} + +func (m *PendingHTLC) GetStage() uint32 { + if m != nil { + return m.Stage + } + return 0 +} + +type PendingChannelsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsRequest) Reset() { *m = PendingChannelsRequest{} } +func (m *PendingChannelsRequest) String() string { return proto.CompactTextString(m) } +func (*PendingChannelsRequest) ProtoMessage() {} +func (*PendingChannelsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{71} +} + +func (m *PendingChannelsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsRequest.Unmarshal(m, b) +} +func (m *PendingChannelsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsRequest.Marshal(b, m, deterministic) +} +func (m *PendingChannelsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsRequest.Merge(m, src) +} +func (m *PendingChannelsRequest) XXX_Size() int { + return xxx_messageInfo_PendingChannelsRequest.Size(m) +} +func (m *PendingChannelsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsRequest proto.InternalMessageInfo + +type PendingChannelsResponse struct { + // The balance in satoshis encumbered in pending channels + TotalLimboBalance int64 `protobuf:"varint,1,opt,name=total_limbo_balance,json=totalLimboBalance,proto3" json:"total_limbo_balance,omitempty"` + // Channels pending opening + PendingOpenChannels []*PendingChannelsResponse_PendingOpenChannel `protobuf:"bytes,2,rep,name=pending_open_channels,json=pendingOpenChannels,proto3" json:"pending_open_channels,omitempty"` + // + //Deprecated: Channels pending closing previously contained cooperatively + //closed channels with a single confirmation. These channels are now + //considered closed from the time we see them on chain. + PendingClosingChannels []*PendingChannelsResponse_ClosedChannel `protobuf:"bytes,3,rep,name=pending_closing_channels,json=pendingClosingChannels,proto3" json:"pending_closing_channels,omitempty"` // Deprecated: Do not use. + // Channels pending force closing + PendingForceClosingChannels []*PendingChannelsResponse_ForceClosedChannel `protobuf:"bytes,4,rep,name=pending_force_closing_channels,json=pendingForceClosingChannels,proto3" json:"pending_force_closing_channels,omitempty"` + // Channels waiting for closing tx to confirm + WaitingCloseChannels []*PendingChannelsResponse_WaitingCloseChannel `protobuf:"bytes,5,rep,name=waiting_close_channels,json=waitingCloseChannels,proto3" json:"waiting_close_channels,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse) Reset() { *m = PendingChannelsResponse{} } +func (m *PendingChannelsResponse) String() string { return proto.CompactTextString(m) } +func (*PendingChannelsResponse) ProtoMessage() {} +func (*PendingChannelsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72} +} + +func (m *PendingChannelsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse.Unmarshal(m, b) +} +func (m *PendingChannelsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse.Merge(m, src) +} +func (m *PendingChannelsResponse) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse.Size(m) +} +func (m *PendingChannelsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse proto.InternalMessageInfo + +func (m *PendingChannelsResponse) GetTotalLimboBalance() int64 { + if m != nil { + return m.TotalLimboBalance + } + return 0 +} + +func (m *PendingChannelsResponse) GetPendingOpenChannels() []*PendingChannelsResponse_PendingOpenChannel { + if m != nil { + return m.PendingOpenChannels + } + return nil +} + +// Deprecated: Do not use. +func (m *PendingChannelsResponse) GetPendingClosingChannels() []*PendingChannelsResponse_ClosedChannel { + if m != nil { + return m.PendingClosingChannels + } + return nil +} + +func (m *PendingChannelsResponse) GetPendingForceClosingChannels() []*PendingChannelsResponse_ForceClosedChannel { + if m != nil { + return m.PendingForceClosingChannels + } + return nil +} + +func (m *PendingChannelsResponse) GetWaitingCloseChannels() []*PendingChannelsResponse_WaitingCloseChannel { + if m != nil { + return m.WaitingCloseChannels + } + return nil +} + +type PendingChannelsResponse_PendingChannel struct { + RemoteNodePub string `protobuf:"bytes,1,opt,name=remote_node_pub,json=remoteNodePub,proto3" json:"remote_node_pub,omitempty"` + ChannelPoint string `protobuf:"bytes,2,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + Capacity int64 `protobuf:"varint,3,opt,name=capacity,proto3" json:"capacity,omitempty"` + LocalBalance int64 `protobuf:"varint,4,opt,name=local_balance,json=localBalance,proto3" json:"local_balance,omitempty"` + RemoteBalance int64 `protobuf:"varint,5,opt,name=remote_balance,json=remoteBalance,proto3" json:"remote_balance,omitempty"` + // The minimum satoshis this node is required to reserve in its + // balance. + LocalChanReserveSat int64 `protobuf:"varint,6,opt,name=local_chan_reserve_sat,json=localChanReserveSat,proto3" json:"local_chan_reserve_sat,omitempty"` + // + //The minimum satoshis the other node is required to reserve in its + //balance. + RemoteChanReserveSat int64 `protobuf:"varint,7,opt,name=remote_chan_reserve_sat,json=remoteChanReserveSat,proto3" json:"remote_chan_reserve_sat,omitempty"` + // The party that initiated opening the channel. + Initiator Initiator `protobuf:"varint,8,opt,name=initiator,proto3,enum=lnrpc.Initiator" json:"initiator,omitempty"` + // The commitment type used by this channel. + CommitmentType CommitmentType `protobuf:"varint,9,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_PendingChannel) Reset() { + *m = PendingChannelsResponse_PendingChannel{} +} +func (m *PendingChannelsResponse_PendingChannel) String() string { return proto.CompactTextString(m) } +func (*PendingChannelsResponse_PendingChannel) ProtoMessage() {} +func (*PendingChannelsResponse_PendingChannel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 0} +} + +func (m *PendingChannelsResponse_PendingChannel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_PendingChannel.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_PendingChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_PendingChannel.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_PendingChannel) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_PendingChannel.Merge(m, src) +} +func (m *PendingChannelsResponse_PendingChannel) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_PendingChannel.Size(m) +} +func (m *PendingChannelsResponse_PendingChannel) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_PendingChannel.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_PendingChannel proto.InternalMessageInfo + +func (m *PendingChannelsResponse_PendingChannel) GetRemoteNodePub() string { + if m != nil { + return m.RemoteNodePub + } + return "" +} + +func (m *PendingChannelsResponse_PendingChannel) GetChannelPoint() string { + if m != nil { + return m.ChannelPoint + } + return "" +} + +func (m *PendingChannelsResponse_PendingChannel) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *PendingChannelsResponse_PendingChannel) GetLocalBalance() int64 { + if m != nil { + return m.LocalBalance + } + return 0 +} + +func (m *PendingChannelsResponse_PendingChannel) GetRemoteBalance() int64 { + if m != nil { + return m.RemoteBalance + } + return 0 +} + +func (m *PendingChannelsResponse_PendingChannel) GetLocalChanReserveSat() int64 { + if m != nil { + return m.LocalChanReserveSat + } + return 0 +} + +func (m *PendingChannelsResponse_PendingChannel) GetRemoteChanReserveSat() int64 { + if m != nil { + return m.RemoteChanReserveSat + } + return 0 +} + +func (m *PendingChannelsResponse_PendingChannel) GetInitiator() Initiator { + if m != nil { + return m.Initiator + } + return Initiator_INITIATOR_UNKNOWN +} + +func (m *PendingChannelsResponse_PendingChannel) GetCommitmentType() CommitmentType { + if m != nil { + return m.CommitmentType + } + return CommitmentType_LEGACY +} + +type PendingChannelsResponse_PendingOpenChannel struct { + // The pending channel + Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` + // The height at which this channel will be confirmed + ConfirmationHeight uint32 `protobuf:"varint,2,opt,name=confirmation_height,json=confirmationHeight,proto3" json:"confirmation_height,omitempty"` + // + //The amount calculated to be paid in fees for the current set of + //commitment transactions. The fee amount is persisted with the channel + //in order to allow the fee amount to be removed and recalculated with + //each channel state update, including updates that happen after a system + //restart. + CommitFee int64 `protobuf:"varint,4,opt,name=commit_fee,json=commitFee,proto3" json:"commit_fee,omitempty"` + // The weight of the commitment transaction + CommitWeight int64 `protobuf:"varint,5,opt,name=commit_weight,json=commitWeight,proto3" json:"commit_weight,omitempty"` + // + //The required number of satoshis per kilo-weight that the requester will + //pay at all times, for both the funding transaction and commitment + //transaction. This value can later be updated once the channel is open. + FeePerKw int64 `protobuf:"varint,6,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_PendingOpenChannel) Reset() { + *m = PendingChannelsResponse_PendingOpenChannel{} +} +func (m *PendingChannelsResponse_PendingOpenChannel) String() string { + return proto.CompactTextString(m) +} +func (*PendingChannelsResponse_PendingOpenChannel) ProtoMessage() {} +func (*PendingChannelsResponse_PendingOpenChannel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 1} +} + +func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.Merge(m, src) +} +func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.Size(m) +} +func (m *PendingChannelsResponse_PendingOpenChannel) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel proto.InternalMessageInfo + +func (m *PendingChannelsResponse_PendingOpenChannel) GetChannel() *PendingChannelsResponse_PendingChannel { + if m != nil { + return m.Channel + } + return nil +} + +func (m *PendingChannelsResponse_PendingOpenChannel) GetConfirmationHeight() uint32 { + if m != nil { + return m.ConfirmationHeight + } + return 0 +} + +func (m *PendingChannelsResponse_PendingOpenChannel) GetCommitFee() int64 { + if m != nil { + return m.CommitFee + } + return 0 +} + +func (m *PendingChannelsResponse_PendingOpenChannel) GetCommitWeight() int64 { + if m != nil { + return m.CommitWeight + } + return 0 +} + +func (m *PendingChannelsResponse_PendingOpenChannel) GetFeePerKw() int64 { + if m != nil { + return m.FeePerKw + } + return 0 +} + +type PendingChannelsResponse_WaitingCloseChannel struct { + // The pending channel waiting for closing tx to confirm + Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` + // The balance in satoshis encumbered in this channel + LimboBalance int64 `protobuf:"varint,2,opt,name=limbo_balance,json=limboBalance,proto3" json:"limbo_balance,omitempty"` + // + //A list of valid commitment transactions. Any of these can confirm at + //this point. + Commitments *PendingChannelsResponse_Commitments `protobuf:"bytes,3,opt,name=commitments,proto3" json:"commitments,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_WaitingCloseChannel) Reset() { + *m = PendingChannelsResponse_WaitingCloseChannel{} +} +func (m *PendingChannelsResponse_WaitingCloseChannel) String() string { + return proto.CompactTextString(m) +} +func (*PendingChannelsResponse_WaitingCloseChannel) ProtoMessage() {} +func (*PendingChannelsResponse_WaitingCloseChannel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 2} +} + +func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.Merge(m, src) +} +func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.Size(m) +} +func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel proto.InternalMessageInfo + +func (m *PendingChannelsResponse_WaitingCloseChannel) GetChannel() *PendingChannelsResponse_PendingChannel { + if m != nil { + return m.Channel + } + return nil +} + +func (m *PendingChannelsResponse_WaitingCloseChannel) GetLimboBalance() int64 { + if m != nil { + return m.LimboBalance + } + return 0 +} + +func (m *PendingChannelsResponse_WaitingCloseChannel) GetCommitments() *PendingChannelsResponse_Commitments { + if m != nil { + return m.Commitments + } + return nil +} + +type PendingChannelsResponse_Commitments struct { + // Hash of the local version of the commitment tx. + LocalTxid string `protobuf:"bytes,1,opt,name=local_txid,json=localTxid,proto3" json:"local_txid,omitempty"` + // Hash of the remote version of the commitment tx. + RemoteTxid string `protobuf:"bytes,2,opt,name=remote_txid,json=remoteTxid,proto3" json:"remote_txid,omitempty"` + // Hash of the remote pending version of the commitment tx. + RemotePendingTxid string `protobuf:"bytes,3,opt,name=remote_pending_txid,json=remotePendingTxid,proto3" json:"remote_pending_txid,omitempty"` + // + //The amount in satoshis calculated to be paid in fees for the local + //commitment. + LocalCommitFeeSat uint64 `protobuf:"varint,4,opt,name=local_commit_fee_sat,json=localCommitFeeSat,proto3" json:"local_commit_fee_sat,omitempty"` + // + //The amount in satoshis calculated to be paid in fees for the remote + //commitment. + RemoteCommitFeeSat uint64 `protobuf:"varint,5,opt,name=remote_commit_fee_sat,json=remoteCommitFeeSat,proto3" json:"remote_commit_fee_sat,omitempty"` + // + //The amount in satoshis calculated to be paid in fees for the remote + //pending commitment. + RemotePendingCommitFeeSat uint64 `protobuf:"varint,6,opt,name=remote_pending_commit_fee_sat,json=remotePendingCommitFeeSat,proto3" json:"remote_pending_commit_fee_sat,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_Commitments) Reset() { *m = PendingChannelsResponse_Commitments{} } +func (m *PendingChannelsResponse_Commitments) String() string { return proto.CompactTextString(m) } +func (*PendingChannelsResponse_Commitments) ProtoMessage() {} +func (*PendingChannelsResponse_Commitments) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 3} +} + +func (m *PendingChannelsResponse_Commitments) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_Commitments.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_Commitments) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_Commitments.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_Commitments) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_Commitments.Merge(m, src) +} +func (m *PendingChannelsResponse_Commitments) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_Commitments.Size(m) +} +func (m *PendingChannelsResponse_Commitments) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_Commitments.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_Commitments proto.InternalMessageInfo + +func (m *PendingChannelsResponse_Commitments) GetLocalTxid() string { + if m != nil { + return m.LocalTxid + } + return "" +} + +func (m *PendingChannelsResponse_Commitments) GetRemoteTxid() string { + if m != nil { + return m.RemoteTxid + } + return "" +} + +func (m *PendingChannelsResponse_Commitments) GetRemotePendingTxid() string { + if m != nil { + return m.RemotePendingTxid + } + return "" +} + +func (m *PendingChannelsResponse_Commitments) GetLocalCommitFeeSat() uint64 { + if m != nil { + return m.LocalCommitFeeSat + } + return 0 +} + +func (m *PendingChannelsResponse_Commitments) GetRemoteCommitFeeSat() uint64 { + if m != nil { + return m.RemoteCommitFeeSat + } + return 0 +} + +func (m *PendingChannelsResponse_Commitments) GetRemotePendingCommitFeeSat() uint64 { + if m != nil { + return m.RemotePendingCommitFeeSat + } + return 0 +} + +type PendingChannelsResponse_ClosedChannel struct { + // The pending channel to be closed + Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` + // The transaction id of the closing transaction + ClosingTxid string `protobuf:"bytes,2,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_ClosedChannel) Reset() { *m = PendingChannelsResponse_ClosedChannel{} } +func (m *PendingChannelsResponse_ClosedChannel) String() string { return proto.CompactTextString(m) } +func (*PendingChannelsResponse_ClosedChannel) ProtoMessage() {} +func (*PendingChannelsResponse_ClosedChannel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 4} +} + +func (m *PendingChannelsResponse_ClosedChannel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_ClosedChannel.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_ClosedChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_ClosedChannel.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_ClosedChannel) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_ClosedChannel.Merge(m, src) +} +func (m *PendingChannelsResponse_ClosedChannel) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_ClosedChannel.Size(m) +} +func (m *PendingChannelsResponse_ClosedChannel) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_ClosedChannel.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_ClosedChannel proto.InternalMessageInfo + +func (m *PendingChannelsResponse_ClosedChannel) GetChannel() *PendingChannelsResponse_PendingChannel { + if m != nil { + return m.Channel + } + return nil +} + +func (m *PendingChannelsResponse_ClosedChannel) GetClosingTxid() string { + if m != nil { + return m.ClosingTxid + } + return "" +} + +type PendingChannelsResponse_ForceClosedChannel struct { + // The pending channel to be force closed + Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` + // The transaction id of the closing transaction + ClosingTxid string `protobuf:"bytes,2,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` + // The balance in satoshis encumbered in this pending channel + LimboBalance int64 `protobuf:"varint,3,opt,name=limbo_balance,json=limboBalance,proto3" json:"limbo_balance,omitempty"` + // The height at which funds can be swept into the wallet + MaturityHeight uint32 `protobuf:"varint,4,opt,name=maturity_height,json=maturityHeight,proto3" json:"maturity_height,omitempty"` + // + //Remaining # of blocks until the commitment output can be swept. + //Negative values indicate how many blocks have passed since becoming + //mature. + BlocksTilMaturity int32 `protobuf:"varint,5,opt,name=blocks_til_maturity,json=blocksTilMaturity,proto3" json:"blocks_til_maturity,omitempty"` + // The total value of funds successfully recovered from this channel + RecoveredBalance int64 `protobuf:"varint,6,opt,name=recovered_balance,json=recoveredBalance,proto3" json:"recovered_balance,omitempty"` + PendingHtlcs []*PendingHTLC `protobuf:"bytes,8,rep,name=pending_htlcs,json=pendingHtlcs,proto3" json:"pending_htlcs,omitempty"` + Anchor PendingChannelsResponse_ForceClosedChannel_AnchorState `protobuf:"varint,9,opt,name=anchor,proto3,enum=lnrpc.PendingChannelsResponse_ForceClosedChannel_AnchorState" json:"anchor,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PendingChannelsResponse_ForceClosedChannel) Reset() { + *m = PendingChannelsResponse_ForceClosedChannel{} +} +func (m *PendingChannelsResponse_ForceClosedChannel) String() string { + return proto.CompactTextString(m) +} +func (*PendingChannelsResponse_ForceClosedChannel) ProtoMessage() {} +func (*PendingChannelsResponse_ForceClosedChannel) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{72, 5} +} + +func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.Unmarshal(m, b) +} +func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.Marshal(b, m, deterministic) +} +func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.Merge(m, src) +} +func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Size() int { + return xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.Size(m) +} +func (m *PendingChannelsResponse_ForceClosedChannel) XXX_DiscardUnknown() { + xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel proto.InternalMessageInfo + +func (m *PendingChannelsResponse_ForceClosedChannel) GetChannel() *PendingChannelsResponse_PendingChannel { + if m != nil { + return m.Channel + } + return nil +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetClosingTxid() string { + if m != nil { + return m.ClosingTxid + } + return "" +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetLimboBalance() int64 { + if m != nil { + return m.LimboBalance + } + return 0 +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetMaturityHeight() uint32 { + if m != nil { + return m.MaturityHeight + } + return 0 +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetBlocksTilMaturity() int32 { + if m != nil { + return m.BlocksTilMaturity + } + return 0 +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetRecoveredBalance() int64 { + if m != nil { + return m.RecoveredBalance + } + return 0 +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetPendingHtlcs() []*PendingHTLC { + if m != nil { + return m.PendingHtlcs + } + return nil +} + +func (m *PendingChannelsResponse_ForceClosedChannel) GetAnchor() PendingChannelsResponse_ForceClosedChannel_AnchorState { + if m != nil { + return m.Anchor + } + return PendingChannelsResponse_ForceClosedChannel_LIMBO +} + +type ChannelEventSubscription struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelEventSubscription) Reset() { *m = ChannelEventSubscription{} } +func (m *ChannelEventSubscription) String() string { return proto.CompactTextString(m) } +func (*ChannelEventSubscription) ProtoMessage() {} +func (*ChannelEventSubscription) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{73} +} + +func (m *ChannelEventSubscription) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelEventSubscription.Unmarshal(m, b) +} +func (m *ChannelEventSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelEventSubscription.Marshal(b, m, deterministic) +} +func (m *ChannelEventSubscription) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelEventSubscription.Merge(m, src) +} +func (m *ChannelEventSubscription) XXX_Size() int { + return xxx_messageInfo_ChannelEventSubscription.Size(m) +} +func (m *ChannelEventSubscription) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelEventSubscription.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelEventSubscription proto.InternalMessageInfo + +type ChannelEventUpdate struct { + // Types that are valid to be assigned to Channel: + // *ChannelEventUpdate_OpenChannel + // *ChannelEventUpdate_ClosedChannel + // *ChannelEventUpdate_ActiveChannel + // *ChannelEventUpdate_InactiveChannel + // *ChannelEventUpdate_PendingOpenChannel + Channel isChannelEventUpdate_Channel `protobuf_oneof:"channel"` + Type ChannelEventUpdate_UpdateType `protobuf:"varint,5,opt,name=type,proto3,enum=lnrpc.ChannelEventUpdate_UpdateType" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelEventUpdate) Reset() { *m = ChannelEventUpdate{} } +func (m *ChannelEventUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelEventUpdate) ProtoMessage() {} +func (*ChannelEventUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{74} +} + +func (m *ChannelEventUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelEventUpdate.Unmarshal(m, b) +} +func (m *ChannelEventUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelEventUpdate.Marshal(b, m, deterministic) +} +func (m *ChannelEventUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelEventUpdate.Merge(m, src) +} +func (m *ChannelEventUpdate) XXX_Size() int { + return xxx_messageInfo_ChannelEventUpdate.Size(m) +} +func (m *ChannelEventUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelEventUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelEventUpdate proto.InternalMessageInfo + +type isChannelEventUpdate_Channel interface { + isChannelEventUpdate_Channel() +} + +type ChannelEventUpdate_OpenChannel struct { + OpenChannel *Channel `protobuf:"bytes,1,opt,name=open_channel,json=openChannel,proto3,oneof"` +} + +type ChannelEventUpdate_ClosedChannel struct { + ClosedChannel *ChannelCloseSummary `protobuf:"bytes,2,opt,name=closed_channel,json=closedChannel,proto3,oneof"` +} + +type ChannelEventUpdate_ActiveChannel struct { + ActiveChannel *ChannelPoint `protobuf:"bytes,3,opt,name=active_channel,json=activeChannel,proto3,oneof"` +} + +type ChannelEventUpdate_InactiveChannel struct { + InactiveChannel *ChannelPoint `protobuf:"bytes,4,opt,name=inactive_channel,json=inactiveChannel,proto3,oneof"` +} + +type ChannelEventUpdate_PendingOpenChannel struct { + PendingOpenChannel *PendingUpdate `protobuf:"bytes,6,opt,name=pending_open_channel,json=pendingOpenChannel,proto3,oneof"` +} + +func (*ChannelEventUpdate_OpenChannel) isChannelEventUpdate_Channel() {} + +func (*ChannelEventUpdate_ClosedChannel) isChannelEventUpdate_Channel() {} + +func (*ChannelEventUpdate_ActiveChannel) isChannelEventUpdate_Channel() {} + +func (*ChannelEventUpdate_InactiveChannel) isChannelEventUpdate_Channel() {} + +func (*ChannelEventUpdate_PendingOpenChannel) isChannelEventUpdate_Channel() {} + +func (m *ChannelEventUpdate) GetChannel() isChannelEventUpdate_Channel { + if m != nil { + return m.Channel + } + return nil +} + +func (m *ChannelEventUpdate) GetOpenChannel() *Channel { + if x, ok := m.GetChannel().(*ChannelEventUpdate_OpenChannel); ok { + return x.OpenChannel + } + return nil +} + +func (m *ChannelEventUpdate) GetClosedChannel() *ChannelCloseSummary { + if x, ok := m.GetChannel().(*ChannelEventUpdate_ClosedChannel); ok { + return x.ClosedChannel + } + return nil +} + +func (m *ChannelEventUpdate) GetActiveChannel() *ChannelPoint { + if x, ok := m.GetChannel().(*ChannelEventUpdate_ActiveChannel); ok { + return x.ActiveChannel + } + return nil +} + +func (m *ChannelEventUpdate) GetInactiveChannel() *ChannelPoint { + if x, ok := m.GetChannel().(*ChannelEventUpdate_InactiveChannel); ok { + return x.InactiveChannel + } + return nil +} + +func (m *ChannelEventUpdate) GetPendingOpenChannel() *PendingUpdate { + if x, ok := m.GetChannel().(*ChannelEventUpdate_PendingOpenChannel); ok { + return x.PendingOpenChannel + } + return nil +} + +func (m *ChannelEventUpdate) GetType() ChannelEventUpdate_UpdateType { + if m != nil { + return m.Type + } + return ChannelEventUpdate_OPEN_CHANNEL +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*ChannelEventUpdate) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*ChannelEventUpdate_OpenChannel)(nil), + (*ChannelEventUpdate_ClosedChannel)(nil), + (*ChannelEventUpdate_ActiveChannel)(nil), + (*ChannelEventUpdate_InactiveChannel)(nil), + (*ChannelEventUpdate_PendingOpenChannel)(nil), + } +} + +type WalletBalanceRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WalletBalanceRequest) Reset() { *m = WalletBalanceRequest{} } +func (m *WalletBalanceRequest) String() string { return proto.CompactTextString(m) } +func (*WalletBalanceRequest) ProtoMessage() {} +func (*WalletBalanceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{75} +} + +func (m *WalletBalanceRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WalletBalanceRequest.Unmarshal(m, b) +} +func (m *WalletBalanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WalletBalanceRequest.Marshal(b, m, deterministic) +} +func (m *WalletBalanceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_WalletBalanceRequest.Merge(m, src) +} +func (m *WalletBalanceRequest) XXX_Size() int { + return xxx_messageInfo_WalletBalanceRequest.Size(m) +} +func (m *WalletBalanceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_WalletBalanceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_WalletBalanceRequest proto.InternalMessageInfo + +type WalletBalanceResponse struct { + // The balance of the wallet + TotalBalance int64 `protobuf:"varint,1,opt,name=total_balance,json=totalBalance,proto3" json:"total_balance,omitempty"` + // The confirmed balance of a wallet(with >= 1 confirmations) + ConfirmedBalance int64 `protobuf:"varint,2,opt,name=confirmed_balance,json=confirmedBalance,proto3" json:"confirmed_balance,omitempty"` + // The unconfirmed balance of a wallet(with 0 confirmations) + UnconfirmedBalance int64 `protobuf:"varint,3,opt,name=unconfirmed_balance,json=unconfirmedBalance,proto3" json:"unconfirmed_balance,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WalletBalanceResponse) Reset() { *m = WalletBalanceResponse{} } +func (m *WalletBalanceResponse) String() string { return proto.CompactTextString(m) } +func (*WalletBalanceResponse) ProtoMessage() {} +func (*WalletBalanceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{76} +} + +func (m *WalletBalanceResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_WalletBalanceResponse.Unmarshal(m, b) +} +func (m *WalletBalanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_WalletBalanceResponse.Marshal(b, m, deterministic) +} +func (m *WalletBalanceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_WalletBalanceResponse.Merge(m, src) +} +func (m *WalletBalanceResponse) XXX_Size() int { + return xxx_messageInfo_WalletBalanceResponse.Size(m) +} +func (m *WalletBalanceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_WalletBalanceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_WalletBalanceResponse proto.InternalMessageInfo + +func (m *WalletBalanceResponse) GetTotalBalance() int64 { + if m != nil { + return m.TotalBalance + } + return 0 +} + +func (m *WalletBalanceResponse) GetConfirmedBalance() int64 { + if m != nil { + return m.ConfirmedBalance + } + return 0 +} + +func (m *WalletBalanceResponse) GetUnconfirmedBalance() int64 { + if m != nil { + return m.UnconfirmedBalance + } + return 0 +} + +type ChannelBalanceRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBalanceRequest) Reset() { *m = ChannelBalanceRequest{} } +func (m *ChannelBalanceRequest) String() string { return proto.CompactTextString(m) } +func (*ChannelBalanceRequest) ProtoMessage() {} +func (*ChannelBalanceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{77} +} + +func (m *ChannelBalanceRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBalanceRequest.Unmarshal(m, b) +} +func (m *ChannelBalanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBalanceRequest.Marshal(b, m, deterministic) +} +func (m *ChannelBalanceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBalanceRequest.Merge(m, src) +} +func (m *ChannelBalanceRequest) XXX_Size() int { + return xxx_messageInfo_ChannelBalanceRequest.Size(m) +} +func (m *ChannelBalanceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBalanceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBalanceRequest proto.InternalMessageInfo + +type ChannelBalanceResponse struct { + // Sum of channels balances denominated in satoshis + Balance int64 `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty"` + // Sum of channels pending balances denominated in satoshis + PendingOpenBalance int64 `protobuf:"varint,2,opt,name=pending_open_balance,json=pendingOpenBalance,proto3" json:"pending_open_balance,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBalanceResponse) Reset() { *m = ChannelBalanceResponse{} } +func (m *ChannelBalanceResponse) String() string { return proto.CompactTextString(m) } +func (*ChannelBalanceResponse) ProtoMessage() {} +func (*ChannelBalanceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{78} +} + +func (m *ChannelBalanceResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBalanceResponse.Unmarshal(m, b) +} +func (m *ChannelBalanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBalanceResponse.Marshal(b, m, deterministic) +} +func (m *ChannelBalanceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBalanceResponse.Merge(m, src) +} +func (m *ChannelBalanceResponse) XXX_Size() int { + return xxx_messageInfo_ChannelBalanceResponse.Size(m) +} +func (m *ChannelBalanceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBalanceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBalanceResponse proto.InternalMessageInfo + +func (m *ChannelBalanceResponse) GetBalance() int64 { + if m != nil { + return m.Balance + } + return 0 +} + +func (m *ChannelBalanceResponse) GetPendingOpenBalance() int64 { + if m != nil { + return m.PendingOpenBalance + } + return 0 +} + +type QueryRoutesRequest struct { + // The 33-byte hex-encoded public key for the payment destination + PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + // + //The amount to send expressed in satoshis. + // + //The fields amt and amt_msat are mutually exclusive. + Amt int64 `protobuf:"varint,2,opt,name=amt,proto3" json:"amt,omitempty"` + // + //The amount to send expressed in millisatoshis. + // + //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"` + // + //An optional CLTV delta from the current height that should be used for the + //timelock of the final hop. Note that unlike SendPayment, QueryRoutes does + //not add any additional block padding on top of final_ctlv_delta. This + //padding of a few blocks needs to be added manually or otherwise failures may + //happen when a block comes in while the payment is in flight. + FinalCltvDelta int32 `protobuf:"varint,4,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"` + // + //The maximum number of satoshis that will be paid as a fee of the payment. + //This value can be represented either as a percentage of the amount being + //sent, or as a fixed amount of the maximum fee the user is willing the pay to + //send the payment. + FeeLimit *FeeLimit `protobuf:"bytes,5,opt,name=fee_limit,json=feeLimit,proto3" json:"fee_limit,omitempty"` + // + //A list of nodes to ignore during path finding. When using REST, these fields + //must be encoded as base64. + IgnoredNodes [][]byte `protobuf:"bytes,6,rep,name=ignored_nodes,json=ignoredNodes,proto3" json:"ignored_nodes,omitempty"` + // + //Deprecated. A list of edges to ignore during path finding. + IgnoredEdges []*EdgeLocator `protobuf:"bytes,7,rep,name=ignored_edges,json=ignoredEdges,proto3" json:"ignored_edges,omitempty"` // Deprecated: Do not use. + // + //The source node where the request route should originated from. If empty, + //self is assumed. + SourcePubKey string `protobuf:"bytes,8,opt,name=source_pub_key,json=sourcePubKey,proto3" json:"source_pub_key,omitempty"` + // + //If set to true, edge probabilities from mission control will be used to get + //the optimal route. + UseMissionControl bool `protobuf:"varint,9,opt,name=use_mission_control,json=useMissionControl,proto3" json:"use_mission_control,omitempty"` + // + //A list of directed node pairs that will be ignored during path finding. + IgnoredPairs []*NodePair `protobuf:"bytes,10,rep,name=ignored_pairs,json=ignoredPairs,proto3" json:"ignored_pairs,omitempty"` + // + //An optional maximum total time lock for the route. If the source is empty or + //ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If + //zero, then the value of `--max-cltv-expiry` is used as the limit. + CltvLimit uint32 `protobuf:"varint,11,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,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. If the destination + //does not support the specified recrods, and error will be returned. + //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 `protobuf:"bytes,13,rep,name=dest_custom_records,json=destCustomRecords,proto3" json:"dest_custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // + //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,14,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"` + // + //The pubkey of the last hop of the route. If empty, any hop may be used. + LastHopPubkey []byte `protobuf:"bytes,15,opt,name=last_hop_pubkey,json=lastHopPubkey,proto3" json:"last_hop_pubkey,omitempty"` + // + //Optional route hints to reach the destination through private channels. + RouteHints []*RouteHint `protobuf:"bytes,16,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,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 []FeatureBit `protobuf:"varint,17,rep,packed,name=dest_features,json=destFeatures,proto3,enum=lnrpc.FeatureBit" json:"dest_features,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryRoutesRequest) Reset() { *m = QueryRoutesRequest{} } +func (m *QueryRoutesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryRoutesRequest) ProtoMessage() {} +func (*QueryRoutesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{79} +} + +func (m *QueryRoutesRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryRoutesRequest.Unmarshal(m, b) +} +func (m *QueryRoutesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryRoutesRequest.Marshal(b, m, deterministic) +} +func (m *QueryRoutesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRoutesRequest.Merge(m, src) +} +func (m *QueryRoutesRequest) XXX_Size() int { + return xxx_messageInfo_QueryRoutesRequest.Size(m) +} +func (m *QueryRoutesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRoutesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRoutesRequest proto.InternalMessageInfo + +func (m *QueryRoutesRequest) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *QueryRoutesRequest) GetAmt() int64 { + if m != nil { + return m.Amt + } + return 0 +} + +func (m *QueryRoutesRequest) GetAmtMsat() int64 { + if m != nil { + return m.AmtMsat + } + return 0 +} + +func (m *QueryRoutesRequest) GetFinalCltvDelta() int32 { + if m != nil { + return m.FinalCltvDelta + } + return 0 +} + +func (m *QueryRoutesRequest) GetFeeLimit() *FeeLimit { + if m != nil { + return m.FeeLimit + } + return nil +} + +func (m *QueryRoutesRequest) GetIgnoredNodes() [][]byte { + if m != nil { + return m.IgnoredNodes + } + return nil +} + +// Deprecated: Do not use. +func (m *QueryRoutesRequest) GetIgnoredEdges() []*EdgeLocator { + if m != nil { + return m.IgnoredEdges + } + return nil +} + +func (m *QueryRoutesRequest) GetSourcePubKey() string { + if m != nil { + return m.SourcePubKey + } + return "" +} + +func (m *QueryRoutesRequest) GetUseMissionControl() bool { + if m != nil { + return m.UseMissionControl + } + return false +} + +func (m *QueryRoutesRequest) GetIgnoredPairs() []*NodePair { + if m != nil { + return m.IgnoredPairs + } + return nil +} + +func (m *QueryRoutesRequest) GetCltvLimit() uint32 { + if m != nil { + return m.CltvLimit + } + return 0 +} + +func (m *QueryRoutesRequest) GetDestCustomRecords() map[uint64][]byte { + if m != nil { + return m.DestCustomRecords + } + return nil +} + +func (m *QueryRoutesRequest) GetOutgoingChanId() uint64 { + if m != nil { + return m.OutgoingChanId + } + return 0 +} + +func (m *QueryRoutesRequest) GetLastHopPubkey() []byte { + if m != nil { + return m.LastHopPubkey + } + return nil +} + +func (m *QueryRoutesRequest) GetRouteHints() []*RouteHint { + if m != nil { + return m.RouteHints + } + return nil +} + +func (m *QueryRoutesRequest) GetDestFeatures() []FeatureBit { + if m != nil { + return m.DestFeatures + } + return nil +} + +type NodePair struct { + // + //The sending node of the pair. When using REST, this field must be encoded as + //base64. + From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` + // + //The receiving node of the pair. When using REST, this field must be encoded + //as base64. + To []byte `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodePair) Reset() { *m = NodePair{} } +func (m *NodePair) String() string { return proto.CompactTextString(m) } +func (*NodePair) ProtoMessage() {} +func (*NodePair) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{80} +} + +func (m *NodePair) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodePair.Unmarshal(m, b) +} +func (m *NodePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodePair.Marshal(b, m, deterministic) +} +func (m *NodePair) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodePair.Merge(m, src) +} +func (m *NodePair) XXX_Size() int { + return xxx_messageInfo_NodePair.Size(m) +} +func (m *NodePair) XXX_DiscardUnknown() { + xxx_messageInfo_NodePair.DiscardUnknown(m) +} + +var xxx_messageInfo_NodePair proto.InternalMessageInfo + +func (m *NodePair) GetFrom() []byte { + if m != nil { + return m.From + } + return nil +} + +func (m *NodePair) GetTo() []byte { + if m != nil { + return m.To + } + return nil +} + +type EdgeLocator struct { + // The short channel id of this edge. + ChannelId uint64 `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` + // + //The direction of this edge. If direction_reverse is false, the direction + //of this edge is from the channel endpoint with the lexicographically smaller + //pub key to the endpoint with the larger pub key. If direction_reverse is + //is true, the edge goes the other way. + DirectionReverse bool `protobuf:"varint,2,opt,name=direction_reverse,json=directionReverse,proto3" json:"direction_reverse,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EdgeLocator) Reset() { *m = EdgeLocator{} } +func (m *EdgeLocator) String() string { return proto.CompactTextString(m) } +func (*EdgeLocator) ProtoMessage() {} +func (*EdgeLocator) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{81} +} + +func (m *EdgeLocator) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EdgeLocator.Unmarshal(m, b) +} +func (m *EdgeLocator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EdgeLocator.Marshal(b, m, deterministic) +} +func (m *EdgeLocator) XXX_Merge(src proto.Message) { + xxx_messageInfo_EdgeLocator.Merge(m, src) +} +func (m *EdgeLocator) XXX_Size() int { + return xxx_messageInfo_EdgeLocator.Size(m) +} +func (m *EdgeLocator) XXX_DiscardUnknown() { + xxx_messageInfo_EdgeLocator.DiscardUnknown(m) +} + +var xxx_messageInfo_EdgeLocator proto.InternalMessageInfo + +func (m *EdgeLocator) GetChannelId() uint64 { + if m != nil { + return m.ChannelId + } + return 0 +} + +func (m *EdgeLocator) GetDirectionReverse() bool { + if m != nil { + return m.DirectionReverse + } + return false +} + +type QueryRoutesResponse struct { + // + //The route that results from the path finding operation. This is still a + //repeated field to retain backwards compatibility. + Routes []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"` + // + //The success probability of the returned route based on the current mission + //control state. [EXPERIMENTAL] + SuccessProb float64 `protobuf:"fixed64,2,opt,name=success_prob,json=successProb,proto3" json:"success_prob,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryRoutesResponse) Reset() { *m = QueryRoutesResponse{} } +func (m *QueryRoutesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryRoutesResponse) ProtoMessage() {} +func (*QueryRoutesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{82} +} + +func (m *QueryRoutesResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryRoutesResponse.Unmarshal(m, b) +} +func (m *QueryRoutesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryRoutesResponse.Marshal(b, m, deterministic) +} +func (m *QueryRoutesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRoutesResponse.Merge(m, src) +} +func (m *QueryRoutesResponse) XXX_Size() int { + return xxx_messageInfo_QueryRoutesResponse.Size(m) +} +func (m *QueryRoutesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRoutesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRoutesResponse proto.InternalMessageInfo + +func (m *QueryRoutesResponse) GetRoutes() []*Route { + if m != nil { + return m.Routes + } + return nil +} + +func (m *QueryRoutesResponse) GetSuccessProb() float64 { + if m != nil { + return m.SuccessProb + } + return 0 +} + +type Hop struct { + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + ChanCapacity int64 `protobuf:"varint,2,opt,name=chan_capacity,json=chanCapacity,proto3" json:"chan_capacity,omitempty"` + AmtToForward int64 `protobuf:"varint,3,opt,name=amt_to_forward,json=amtToForward,proto3" json:"amt_to_forward,omitempty"` // Deprecated: Do not use. + Fee int64 `protobuf:"varint,4,opt,name=fee,proto3" json:"fee,omitempty"` // Deprecated: Do not use. + Expiry uint32 `protobuf:"varint,5,opt,name=expiry,proto3" json:"expiry,omitempty"` + AmtToForwardMsat int64 `protobuf:"varint,6,opt,name=amt_to_forward_msat,json=amtToForwardMsat,proto3" json:"amt_to_forward_msat,omitempty"` + FeeMsat int64 `protobuf:"varint,7,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` + // + //An optional public key of the hop. If the public key is given, the payment + //can be executed without relying on a copy of the channel graph. + PubKey string `protobuf:"bytes,8,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + // + //If set to true, then this hop will be encoded using the new variable length + //TLV format. Note that if any custom tlv_records below are specified, then + //this field MUST be set to true for them to be encoded properly. + TlvPayload bool `protobuf:"varint,9,opt,name=tlv_payload,json=tlvPayload,proto3" json:"tlv_payload,omitempty"` + // + //An optional TLV record that signals the use of an MPP payment. If present, + //the receiver will enforce that that the same mpp_record is included in the + //final hop payload of all non-zero payments in the HTLC set. If empty, a + //regular single-shot payment is or was attempted. + MppRecord *MPPRecord `protobuf:"bytes,10,opt,name=mpp_record,json=mppRecord,proto3" json:"mpp_record,omitempty"` + // + //An optional set of key-value TLV records. This is useful within the context + //of the SendToRoute call as it allows callers to specify arbitrary K-V pairs + //to drop off at each hop within the onion. + CustomRecords map[uint64][]byte `protobuf:"bytes,11,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hop) Reset() { *m = Hop{} } +func (m *Hop) String() string { return proto.CompactTextString(m) } +func (*Hop) ProtoMessage() {} +func (*Hop) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{83} +} + +func (m *Hop) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hop.Unmarshal(m, b) +} +func (m *Hop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hop.Marshal(b, m, deterministic) +} +func (m *Hop) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hop.Merge(m, src) +} +func (m *Hop) XXX_Size() int { + return xxx_messageInfo_Hop.Size(m) +} +func (m *Hop) XXX_DiscardUnknown() { + xxx_messageInfo_Hop.DiscardUnknown(m) +} + +var xxx_messageInfo_Hop proto.InternalMessageInfo + +func (m *Hop) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *Hop) GetChanCapacity() int64 { + if m != nil { + return m.ChanCapacity + } + return 0 +} + +// Deprecated: Do not use. +func (m *Hop) GetAmtToForward() int64 { + if m != nil { + return m.AmtToForward + } + return 0 +} + +// Deprecated: Do not use. +func (m *Hop) GetFee() int64 { + if m != nil { + return m.Fee + } + return 0 +} + +func (m *Hop) GetExpiry() uint32 { + if m != nil { + return m.Expiry + } + return 0 +} + +func (m *Hop) GetAmtToForwardMsat() int64 { + if m != nil { + return m.AmtToForwardMsat + } + return 0 +} + +func (m *Hop) GetFeeMsat() int64 { + if m != nil { + return m.FeeMsat + } + return 0 +} + +func (m *Hop) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *Hop) GetTlvPayload() bool { + if m != nil { + return m.TlvPayload + } + return false +} + +func (m *Hop) GetMppRecord() *MPPRecord { + if m != nil { + return m.MppRecord + } + return nil +} + +func (m *Hop) GetCustomRecords() map[uint64][]byte { + if m != nil { + return m.CustomRecords + } + return nil +} + +type MPPRecord struct { + // + //A unique, random identifier used to authenticate the sender as the intended + //payer of a multi-path payment. The payment_addr must be the same for all + //subpayments, and match the payment_addr provided in the receiver's invoice. + //The same payment_addr must be used on all subpayments. + PaymentAddr []byte `protobuf:"bytes,11,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` + // + //The total amount in milli-satoshis being sent as part of a larger multi-path + //payment. The caller is responsible for ensuring subpayments to the same node + //and payment_hash sum exactly to total_amt_msat. The same + //total_amt_msat must be used on all subpayments. + TotalAmtMsat int64 `protobuf:"varint,10,opt,name=total_amt_msat,json=totalAmtMsat,proto3" json:"total_amt_msat,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MPPRecord) Reset() { *m = MPPRecord{} } +func (m *MPPRecord) String() string { return proto.CompactTextString(m) } +func (*MPPRecord) ProtoMessage() {} +func (*MPPRecord) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{84} +} + +func (m *MPPRecord) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MPPRecord.Unmarshal(m, b) +} +func (m *MPPRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MPPRecord.Marshal(b, m, deterministic) +} +func (m *MPPRecord) XXX_Merge(src proto.Message) { + xxx_messageInfo_MPPRecord.Merge(m, src) +} +func (m *MPPRecord) XXX_Size() int { + return xxx_messageInfo_MPPRecord.Size(m) +} +func (m *MPPRecord) XXX_DiscardUnknown() { + xxx_messageInfo_MPPRecord.DiscardUnknown(m) +} + +var xxx_messageInfo_MPPRecord proto.InternalMessageInfo + +func (m *MPPRecord) GetPaymentAddr() []byte { + if m != nil { + return m.PaymentAddr + } + return nil +} + +func (m *MPPRecord) GetTotalAmtMsat() int64 { + if m != nil { + return m.TotalAmtMsat + } + return 0 +} + +// +//A path through the channel graph which runs over one or more channels in +//succession. This struct carries all the information required to craft the +//Sphinx onion packet, and send the payment along the first hop in the path. A +//route is only selected as valid if all the channels have sufficient capacity to +//carry the initial payment amount after fees are accounted for. +type Route struct { + // + //The cumulative (final) time lock across the entire route. This is the CLTV + //value that should be extended to the first hop in the route. All other hops + //will decrement the time-lock as advertised, leaving enough time for all + //hops to wait for or present the payment preimage to complete the payment. + TotalTimeLock uint32 `protobuf:"varint,1,opt,name=total_time_lock,json=totalTimeLock,proto3" json:"total_time_lock,omitempty"` + // + //The sum of the fees paid at each hop within the final route. In the case + //of a one-hop payment, this value will be zero as we don't need to pay a fee + //to ourselves. + TotalFees int64 `protobuf:"varint,2,opt,name=total_fees,json=totalFees,proto3" json:"total_fees,omitempty"` // Deprecated: Do not use. + // + //The total amount of funds required to complete a payment over this route. + //This value includes the cumulative fees at each hop. As a result, the HTLC + //extended to the first-hop in the route will need to have at least this many + //satoshis, otherwise the route will fail at an intermediate node due to an + //insufficient amount of fees. + TotalAmt int64 `protobuf:"varint,3,opt,name=total_amt,json=totalAmt,proto3" json:"total_amt,omitempty"` // Deprecated: Do not use. + // + //Contains details concerning the specific forwarding details at each hop. + Hops []*Hop `protobuf:"bytes,4,rep,name=hops,proto3" json:"hops,omitempty"` + // + //The total fees in millisatoshis. + TotalFeesMsat int64 `protobuf:"varint,5,opt,name=total_fees_msat,json=totalFeesMsat,proto3" json:"total_fees_msat,omitempty"` + // + //The total amount in millisatoshis. + TotalAmtMsat int64 `protobuf:"varint,6,opt,name=total_amt_msat,json=totalAmtMsat,proto3" json:"total_amt_msat,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Route) Reset() { *m = Route{} } +func (m *Route) String() string { return proto.CompactTextString(m) } +func (*Route) ProtoMessage() {} +func (*Route) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{85} +} + +func (m *Route) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Route.Unmarshal(m, b) +} +func (m *Route) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Route.Marshal(b, m, deterministic) +} +func (m *Route) XXX_Merge(src proto.Message) { + xxx_messageInfo_Route.Merge(m, src) +} +func (m *Route) XXX_Size() int { + return xxx_messageInfo_Route.Size(m) +} +func (m *Route) XXX_DiscardUnknown() { + xxx_messageInfo_Route.DiscardUnknown(m) +} + +var xxx_messageInfo_Route proto.InternalMessageInfo + +func (m *Route) GetTotalTimeLock() uint32 { + if m != nil { + return m.TotalTimeLock + } + return 0 +} + +// Deprecated: Do not use. +func (m *Route) GetTotalFees() int64 { + if m != nil { + return m.TotalFees + } + return 0 +} + +// Deprecated: Do not use. +func (m *Route) GetTotalAmt() int64 { + if m != nil { + return m.TotalAmt + } + return 0 +} + +func (m *Route) GetHops() []*Hop { + if m != nil { + return m.Hops + } + return nil +} + +func (m *Route) GetTotalFeesMsat() int64 { + if m != nil { + return m.TotalFeesMsat + } + return 0 +} + +func (m *Route) GetTotalAmtMsat() int64 { + if m != nil { + return m.TotalAmtMsat + } + return 0 +} + +type NodeInfoRequest struct { + // The 33-byte hex-encoded compressed public of the target node + PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + // If true, will include all known channels associated with the node. + IncludeChannels bool `protobuf:"varint,2,opt,name=include_channels,json=includeChannels,proto3" json:"include_channels,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeInfoRequest) Reset() { *m = NodeInfoRequest{} } +func (m *NodeInfoRequest) String() string { return proto.CompactTextString(m) } +func (*NodeInfoRequest) ProtoMessage() {} +func (*NodeInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{86} +} + +func (m *NodeInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeInfoRequest.Unmarshal(m, b) +} +func (m *NodeInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeInfoRequest.Marshal(b, m, deterministic) +} +func (m *NodeInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeInfoRequest.Merge(m, src) +} +func (m *NodeInfoRequest) XXX_Size() int { + return xxx_messageInfo_NodeInfoRequest.Size(m) +} +func (m *NodeInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NodeInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeInfoRequest proto.InternalMessageInfo + +func (m *NodeInfoRequest) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *NodeInfoRequest) GetIncludeChannels() bool { + if m != nil { + return m.IncludeChannels + } + return false +} + +type NodeInfo struct { + // + //An individual vertex/node within the channel graph. A node is + //connected to other nodes by one or more channel edges emanating from it. As + //the graph is directed, a node will also have an incoming edge attached to + //it for each outgoing edge. + Node *LightningNode `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"` + // The total number of channels for the node. + NumChannels uint32 `protobuf:"varint,2,opt,name=num_channels,json=numChannels,proto3" json:"num_channels,omitempty"` + // The sum of all channels capacity for the node, denominated in satoshis. + TotalCapacity int64 `protobuf:"varint,3,opt,name=total_capacity,json=totalCapacity,proto3" json:"total_capacity,omitempty"` + // A list of all public channels for the node. + Channels []*ChannelEdge `protobuf:"bytes,4,rep,name=channels,proto3" json:"channels,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeInfo) Reset() { *m = NodeInfo{} } +func (m *NodeInfo) String() string { return proto.CompactTextString(m) } +func (*NodeInfo) ProtoMessage() {} +func (*NodeInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{87} +} + +func (m *NodeInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeInfo.Unmarshal(m, b) +} +func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeInfo.Marshal(b, m, deterministic) +} +func (m *NodeInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeInfo.Merge(m, src) +} +func (m *NodeInfo) XXX_Size() int { + return xxx_messageInfo_NodeInfo.Size(m) +} +func (m *NodeInfo) XXX_DiscardUnknown() { + xxx_messageInfo_NodeInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeInfo proto.InternalMessageInfo + +func (m *NodeInfo) GetNode() *LightningNode { + if m != nil { + return m.Node + } + return nil +} + +func (m *NodeInfo) GetNumChannels() uint32 { + if m != nil { + return m.NumChannels + } + return 0 +} + +func (m *NodeInfo) GetTotalCapacity() int64 { + if m != nil { + return m.TotalCapacity + } + return 0 +} + +func (m *NodeInfo) GetChannels() []*ChannelEdge { + if m != nil { + return m.Channels + } + return nil +} + +// +//An individual vertex/node within the channel graph. A node is +//connected to other nodes by one or more channel edges emanating from it. As the +//graph is directed, a node will also have an incoming edge attached to it for +//each outgoing edge. +type LightningNode struct { + LastUpdate uint32 `protobuf:"varint,1,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` + PubKey string `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` + Alias string `protobuf:"bytes,3,opt,name=alias,proto3" json:"alias,omitempty"` + Addresses []*NodeAddress `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"` + Color string `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"` + Features map[uint32]*Feature `protobuf:"bytes,6,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LightningNode) Reset() { *m = LightningNode{} } +func (m *LightningNode) String() string { return proto.CompactTextString(m) } +func (*LightningNode) ProtoMessage() {} +func (*LightningNode) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{88} +} + +func (m *LightningNode) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LightningNode.Unmarshal(m, b) +} +func (m *LightningNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LightningNode.Marshal(b, m, deterministic) +} +func (m *LightningNode) XXX_Merge(src proto.Message) { + xxx_messageInfo_LightningNode.Merge(m, src) +} +func (m *LightningNode) XXX_Size() int { + return xxx_messageInfo_LightningNode.Size(m) +} +func (m *LightningNode) XXX_DiscardUnknown() { + xxx_messageInfo_LightningNode.DiscardUnknown(m) +} + +var xxx_messageInfo_LightningNode proto.InternalMessageInfo + +func (m *LightningNode) GetLastUpdate() uint32 { + if m != nil { + return m.LastUpdate + } + return 0 +} + +func (m *LightningNode) GetPubKey() string { + if m != nil { + return m.PubKey + } + return "" +} + +func (m *LightningNode) GetAlias() string { + if m != nil { + return m.Alias + } + return "" +} + +func (m *LightningNode) GetAddresses() []*NodeAddress { + if m != nil { + return m.Addresses + } + return nil +} + +func (m *LightningNode) GetColor() string { + if m != nil { + return m.Color + } + return "" +} + +func (m *LightningNode) GetFeatures() map[uint32]*Feature { + if m != nil { + return m.Features + } + return nil +} + +type NodeAddress struct { + Network string `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"` + Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeAddress) Reset() { *m = NodeAddress{} } +func (m *NodeAddress) String() string { return proto.CompactTextString(m) } +func (*NodeAddress) ProtoMessage() {} +func (*NodeAddress) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{89} +} + +func (m *NodeAddress) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeAddress.Unmarshal(m, b) +} +func (m *NodeAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeAddress.Marshal(b, m, deterministic) +} +func (m *NodeAddress) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeAddress.Merge(m, src) +} +func (m *NodeAddress) XXX_Size() int { + return xxx_messageInfo_NodeAddress.Size(m) +} +func (m *NodeAddress) XXX_DiscardUnknown() { + xxx_messageInfo_NodeAddress.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeAddress proto.InternalMessageInfo + +func (m *NodeAddress) GetNetwork() string { + if m != nil { + return m.Network + } + return "" +} + +func (m *NodeAddress) GetAddr() string { + if m != nil { + return m.Addr + } + return "" +} + +type RoutingPolicy struct { + TimeLockDelta uint32 `protobuf:"varint,1,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` + MinHtlc int64 `protobuf:"varint,2,opt,name=min_htlc,json=minHtlc,proto3" json:"min_htlc,omitempty"` + FeeBaseMsat int64 `protobuf:"varint,3,opt,name=fee_base_msat,json=feeBaseMsat,proto3" json:"fee_base_msat,omitempty"` + FeeRateMilliMsat int64 `protobuf:"varint,4,opt,name=fee_rate_milli_msat,json=feeRateMilliMsat,proto3" json:"fee_rate_milli_msat,omitempty"` + Disabled bool `protobuf:"varint,5,opt,name=disabled,proto3" json:"disabled,omitempty"` + MaxHtlcMsat uint64 `protobuf:"varint,6,opt,name=max_htlc_msat,json=maxHtlcMsat,proto3" json:"max_htlc_msat,omitempty"` + LastUpdate uint32 `protobuf:"varint,7,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RoutingPolicy) Reset() { *m = RoutingPolicy{} } +func (m *RoutingPolicy) String() string { return proto.CompactTextString(m) } +func (*RoutingPolicy) ProtoMessage() {} +func (*RoutingPolicy) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{90} +} + +func (m *RoutingPolicy) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RoutingPolicy.Unmarshal(m, b) +} +func (m *RoutingPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RoutingPolicy.Marshal(b, m, deterministic) +} +func (m *RoutingPolicy) XXX_Merge(src proto.Message) { + xxx_messageInfo_RoutingPolicy.Merge(m, src) +} +func (m *RoutingPolicy) XXX_Size() int { + return xxx_messageInfo_RoutingPolicy.Size(m) +} +func (m *RoutingPolicy) XXX_DiscardUnknown() { + xxx_messageInfo_RoutingPolicy.DiscardUnknown(m) +} + +var xxx_messageInfo_RoutingPolicy proto.InternalMessageInfo + +func (m *RoutingPolicy) GetTimeLockDelta() uint32 { + if m != nil { + return m.TimeLockDelta + } + return 0 +} + +func (m *RoutingPolicy) GetMinHtlc() int64 { + if m != nil { + return m.MinHtlc + } + return 0 +} + +func (m *RoutingPolicy) GetFeeBaseMsat() int64 { + if m != nil { + return m.FeeBaseMsat + } + return 0 +} + +func (m *RoutingPolicy) GetFeeRateMilliMsat() int64 { + if m != nil { + return m.FeeRateMilliMsat + } + return 0 +} + +func (m *RoutingPolicy) GetDisabled() bool { + if m != nil { + return m.Disabled + } + return false +} + +func (m *RoutingPolicy) GetMaxHtlcMsat() uint64 { + if m != nil { + return m.MaxHtlcMsat + } + return 0 +} + +func (m *RoutingPolicy) GetLastUpdate() uint32 { + if m != nil { + return m.LastUpdate + } + return 0 +} + +// +//A fully authenticated channel along with all its unique attributes. +//Once an authenticated channel announcement has been processed on the network, +//then an instance of ChannelEdgeInfo encapsulating the channels attributes is +//stored. The other portions relevant to routing policy of a channel are stored +//within a ChannelEdgePolicy for each direction of the channel. +type ChannelEdge struct { + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChannelId uint64 `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` + ChanPoint string `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + LastUpdate uint32 `protobuf:"varint,3,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` // Deprecated: Do not use. + Node1Pub string `protobuf:"bytes,4,opt,name=node1_pub,json=node1Pub,proto3" json:"node1_pub,omitempty"` + Node2Pub string `protobuf:"bytes,5,opt,name=node2_pub,json=node2Pub,proto3" json:"node2_pub,omitempty"` + Capacity int64 `protobuf:"varint,6,opt,name=capacity,proto3" json:"capacity,omitempty"` + Node1Policy *RoutingPolicy `protobuf:"bytes,7,opt,name=node1_policy,json=node1Policy,proto3" json:"node1_policy,omitempty"` + Node2Policy *RoutingPolicy `protobuf:"bytes,8,opt,name=node2_policy,json=node2Policy,proto3" json:"node2_policy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelEdge) Reset() { *m = ChannelEdge{} } +func (m *ChannelEdge) String() string { return proto.CompactTextString(m) } +func (*ChannelEdge) ProtoMessage() {} +func (*ChannelEdge) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{91} +} + +func (m *ChannelEdge) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelEdge.Unmarshal(m, b) +} +func (m *ChannelEdge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelEdge.Marshal(b, m, deterministic) +} +func (m *ChannelEdge) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelEdge.Merge(m, src) +} +func (m *ChannelEdge) XXX_Size() int { + return xxx_messageInfo_ChannelEdge.Size(m) +} +func (m *ChannelEdge) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelEdge.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelEdge proto.InternalMessageInfo + +func (m *ChannelEdge) GetChannelId() uint64 { + if m != nil { + return m.ChannelId + } + return 0 +} + +func (m *ChannelEdge) GetChanPoint() string { + if m != nil { + return m.ChanPoint + } + return "" +} + +// Deprecated: Do not use. +func (m *ChannelEdge) GetLastUpdate() uint32 { + if m != nil { + return m.LastUpdate + } + return 0 +} + +func (m *ChannelEdge) GetNode1Pub() string { + if m != nil { + return m.Node1Pub + } + return "" +} + +func (m *ChannelEdge) GetNode2Pub() string { + if m != nil { + return m.Node2Pub + } + return "" +} + +func (m *ChannelEdge) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *ChannelEdge) GetNode1Policy() *RoutingPolicy { + if m != nil { + return m.Node1Policy + } + return nil +} + +func (m *ChannelEdge) GetNode2Policy() *RoutingPolicy { + if m != nil { + return m.Node2Policy + } + return nil +} + +type ChannelGraphRequest struct { + // + //Whether unannounced channels are included in the response or not. If set, + //unannounced channels are included. Unannounced channels are both private + //channels, and public channels that are not yet announced to the network. + IncludeUnannounced bool `protobuf:"varint,1,opt,name=include_unannounced,json=includeUnannounced,proto3" json:"include_unannounced,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelGraphRequest) Reset() { *m = ChannelGraphRequest{} } +func (m *ChannelGraphRequest) String() string { return proto.CompactTextString(m) } +func (*ChannelGraphRequest) ProtoMessage() {} +func (*ChannelGraphRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{92} +} + +func (m *ChannelGraphRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelGraphRequest.Unmarshal(m, b) +} +func (m *ChannelGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelGraphRequest.Marshal(b, m, deterministic) +} +func (m *ChannelGraphRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelGraphRequest.Merge(m, src) +} +func (m *ChannelGraphRequest) XXX_Size() int { + return xxx_messageInfo_ChannelGraphRequest.Size(m) +} +func (m *ChannelGraphRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelGraphRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelGraphRequest proto.InternalMessageInfo + +func (m *ChannelGraphRequest) GetIncludeUnannounced() bool { + if m != nil { + return m.IncludeUnannounced + } + return false +} + +// Returns a new instance of the directed channel graph. +type ChannelGraph struct { + // The list of `LightningNode`s in this channel graph + Nodes []*LightningNode `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"` + // The list of `ChannelEdge`s in this channel graph + Edges []*ChannelEdge `protobuf:"bytes,2,rep,name=edges,proto3" json:"edges,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelGraph) Reset() { *m = ChannelGraph{} } +func (m *ChannelGraph) String() string { return proto.CompactTextString(m) } +func (*ChannelGraph) ProtoMessage() {} +func (*ChannelGraph) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{93} +} + +func (m *ChannelGraph) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelGraph.Unmarshal(m, b) +} +func (m *ChannelGraph) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelGraph.Marshal(b, m, deterministic) +} +func (m *ChannelGraph) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelGraph.Merge(m, src) +} +func (m *ChannelGraph) XXX_Size() int { + return xxx_messageInfo_ChannelGraph.Size(m) +} +func (m *ChannelGraph) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelGraph.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelGraph proto.InternalMessageInfo + +func (m *ChannelGraph) GetNodes() []*LightningNode { + if m != nil { + return m.Nodes + } + return nil +} + +func (m *ChannelGraph) GetEdges() []*ChannelEdge { + if m != nil { + return m.Edges + } + return nil +} + +type NodeMetricsRequest struct { + // The requested node metrics. + Types []NodeMetricType `protobuf:"varint,1,rep,packed,name=types,proto3,enum=lnrpc.NodeMetricType" json:"types,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeMetricsRequest) Reset() { *m = NodeMetricsRequest{} } +func (m *NodeMetricsRequest) String() string { return proto.CompactTextString(m) } +func (*NodeMetricsRequest) ProtoMessage() {} +func (*NodeMetricsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{94} +} + +func (m *NodeMetricsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeMetricsRequest.Unmarshal(m, b) +} +func (m *NodeMetricsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeMetricsRequest.Marshal(b, m, deterministic) +} +func (m *NodeMetricsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeMetricsRequest.Merge(m, src) +} +func (m *NodeMetricsRequest) XXX_Size() int { + return xxx_messageInfo_NodeMetricsRequest.Size(m) +} +func (m *NodeMetricsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NodeMetricsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeMetricsRequest proto.InternalMessageInfo + +func (m *NodeMetricsRequest) GetTypes() []NodeMetricType { + if m != nil { + return m.Types + } + return nil +} + +type NodeMetricsResponse struct { + // + //Betweenness centrality is the sum of the ratio of shortest paths that pass + //through the node for each pair of nodes in the graph (not counting paths + //starting or ending at this node). + //Map of node pubkey to betweenness centrality of the node. Normalized + //values are in the [0,1] closed interval. + BetweennessCentrality map[string]*FloatMetric `protobuf:"bytes,1,rep,name=betweenness_centrality,json=betweennessCentrality,proto3" json:"betweenness_centrality,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeMetricsResponse) Reset() { *m = NodeMetricsResponse{} } +func (m *NodeMetricsResponse) String() string { return proto.CompactTextString(m) } +func (*NodeMetricsResponse) ProtoMessage() {} +func (*NodeMetricsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{95} +} + +func (m *NodeMetricsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeMetricsResponse.Unmarshal(m, b) +} +func (m *NodeMetricsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeMetricsResponse.Marshal(b, m, deterministic) +} +func (m *NodeMetricsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeMetricsResponse.Merge(m, src) +} +func (m *NodeMetricsResponse) XXX_Size() int { + return xxx_messageInfo_NodeMetricsResponse.Size(m) +} +func (m *NodeMetricsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_NodeMetricsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeMetricsResponse proto.InternalMessageInfo + +func (m *NodeMetricsResponse) GetBetweennessCentrality() map[string]*FloatMetric { + if m != nil { + return m.BetweennessCentrality + } + return nil +} + +type FloatMetric struct { + // Arbitrary float value. + Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"` + // The value normalized to [0,1] or [-1,1]. + NormalizedValue float64 `protobuf:"fixed64,2,opt,name=normalized_value,json=normalizedValue,proto3" json:"normalized_value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FloatMetric) Reset() { *m = FloatMetric{} } +func (m *FloatMetric) String() string { return proto.CompactTextString(m) } +func (*FloatMetric) ProtoMessage() {} +func (*FloatMetric) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{96} +} + +func (m *FloatMetric) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FloatMetric.Unmarshal(m, b) +} +func (m *FloatMetric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FloatMetric.Marshal(b, m, deterministic) +} +func (m *FloatMetric) XXX_Merge(src proto.Message) { + xxx_messageInfo_FloatMetric.Merge(m, src) +} +func (m *FloatMetric) XXX_Size() int { + return xxx_messageInfo_FloatMetric.Size(m) +} +func (m *FloatMetric) XXX_DiscardUnknown() { + xxx_messageInfo_FloatMetric.DiscardUnknown(m) +} + +var xxx_messageInfo_FloatMetric proto.InternalMessageInfo + +func (m *FloatMetric) GetValue() float64 { + if m != nil { + return m.Value + } + return 0 +} + +func (m *FloatMetric) GetNormalizedValue() float64 { + if m != nil { + return m.NormalizedValue + } + return 0 +} + +type ChanInfoRequest struct { + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChanInfoRequest) Reset() { *m = ChanInfoRequest{} } +func (m *ChanInfoRequest) String() string { return proto.CompactTextString(m) } +func (*ChanInfoRequest) ProtoMessage() {} +func (*ChanInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{97} +} + +func (m *ChanInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChanInfoRequest.Unmarshal(m, b) +} +func (m *ChanInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChanInfoRequest.Marshal(b, m, deterministic) +} +func (m *ChanInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChanInfoRequest.Merge(m, src) +} +func (m *ChanInfoRequest) XXX_Size() int { + return xxx_messageInfo_ChanInfoRequest.Size(m) +} +func (m *ChanInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ChanInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ChanInfoRequest proto.InternalMessageInfo + +func (m *ChanInfoRequest) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +type NetworkInfoRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NetworkInfoRequest) Reset() { *m = NetworkInfoRequest{} } +func (m *NetworkInfoRequest) String() string { return proto.CompactTextString(m) } +func (*NetworkInfoRequest) ProtoMessage() {} +func (*NetworkInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{98} +} + +func (m *NetworkInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NetworkInfoRequest.Unmarshal(m, b) +} +func (m *NetworkInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NetworkInfoRequest.Marshal(b, m, deterministic) +} +func (m *NetworkInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_NetworkInfoRequest.Merge(m, src) +} +func (m *NetworkInfoRequest) XXX_Size() int { + return xxx_messageInfo_NetworkInfoRequest.Size(m) +} +func (m *NetworkInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_NetworkInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_NetworkInfoRequest proto.InternalMessageInfo + +type NetworkInfo struct { + GraphDiameter uint32 `protobuf:"varint,1,opt,name=graph_diameter,json=graphDiameter,proto3" json:"graph_diameter,omitempty"` + AvgOutDegree float64 `protobuf:"fixed64,2,opt,name=avg_out_degree,json=avgOutDegree,proto3" json:"avg_out_degree,omitempty"` + MaxOutDegree uint32 `protobuf:"varint,3,opt,name=max_out_degree,json=maxOutDegree,proto3" json:"max_out_degree,omitempty"` + NumNodes uint32 `protobuf:"varint,4,opt,name=num_nodes,json=numNodes,proto3" json:"num_nodes,omitempty"` + NumChannels uint32 `protobuf:"varint,5,opt,name=num_channels,json=numChannels,proto3" json:"num_channels,omitempty"` + TotalNetworkCapacity int64 `protobuf:"varint,6,opt,name=total_network_capacity,json=totalNetworkCapacity,proto3" json:"total_network_capacity,omitempty"` + AvgChannelSize float64 `protobuf:"fixed64,7,opt,name=avg_channel_size,json=avgChannelSize,proto3" json:"avg_channel_size,omitempty"` + MinChannelSize int64 `protobuf:"varint,8,opt,name=min_channel_size,json=minChannelSize,proto3" json:"min_channel_size,omitempty"` + MaxChannelSize int64 `protobuf:"varint,9,opt,name=max_channel_size,json=maxChannelSize,proto3" json:"max_channel_size,omitempty"` + MedianChannelSizeSat int64 `protobuf:"varint,10,opt,name=median_channel_size_sat,json=medianChannelSizeSat,proto3" json:"median_channel_size_sat,omitempty"` + // The number of edges marked as zombies. + NumZombieChans uint64 `protobuf:"varint,11,opt,name=num_zombie_chans,json=numZombieChans,proto3" json:"num_zombie_chans,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NetworkInfo) Reset() { *m = NetworkInfo{} } +func (m *NetworkInfo) String() string { return proto.CompactTextString(m) } +func (*NetworkInfo) ProtoMessage() {} +func (*NetworkInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{99} +} + +func (m *NetworkInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NetworkInfo.Unmarshal(m, b) +} +func (m *NetworkInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NetworkInfo.Marshal(b, m, deterministic) +} +func (m *NetworkInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_NetworkInfo.Merge(m, src) +} +func (m *NetworkInfo) XXX_Size() int { + return xxx_messageInfo_NetworkInfo.Size(m) +} +func (m *NetworkInfo) XXX_DiscardUnknown() { + xxx_messageInfo_NetworkInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_NetworkInfo proto.InternalMessageInfo + +func (m *NetworkInfo) GetGraphDiameter() uint32 { + if m != nil { + return m.GraphDiameter + } + return 0 +} + +func (m *NetworkInfo) GetAvgOutDegree() float64 { + if m != nil { + return m.AvgOutDegree + } + return 0 +} + +func (m *NetworkInfo) GetMaxOutDegree() uint32 { + if m != nil { + return m.MaxOutDegree + } + return 0 +} + +func (m *NetworkInfo) GetNumNodes() uint32 { + if m != nil { + return m.NumNodes + } + return 0 +} + +func (m *NetworkInfo) GetNumChannels() uint32 { + if m != nil { + return m.NumChannels + } + return 0 +} + +func (m *NetworkInfo) GetTotalNetworkCapacity() int64 { + if m != nil { + return m.TotalNetworkCapacity + } + return 0 +} + +func (m *NetworkInfo) GetAvgChannelSize() float64 { + if m != nil { + return m.AvgChannelSize + } + return 0 +} + +func (m *NetworkInfo) GetMinChannelSize() int64 { + if m != nil { + return m.MinChannelSize + } + return 0 +} + +func (m *NetworkInfo) GetMaxChannelSize() int64 { + if m != nil { + return m.MaxChannelSize + } + return 0 +} + +func (m *NetworkInfo) GetMedianChannelSizeSat() int64 { + if m != nil { + return m.MedianChannelSizeSat + } + return 0 +} + +func (m *NetworkInfo) GetNumZombieChans() uint64 { + if m != nil { + return m.NumZombieChans + } + return 0 +} + +type StopRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StopRequest) Reset() { *m = StopRequest{} } +func (m *StopRequest) String() string { return proto.CompactTextString(m) } +func (*StopRequest) ProtoMessage() {} +func (*StopRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{100} +} + +func (m *StopRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StopRequest.Unmarshal(m, b) +} +func (m *StopRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StopRequest.Marshal(b, m, deterministic) +} +func (m *StopRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StopRequest.Merge(m, src) +} +func (m *StopRequest) XXX_Size() int { + return xxx_messageInfo_StopRequest.Size(m) +} +func (m *StopRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StopRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StopRequest proto.InternalMessageInfo + +type StopResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StopResponse) Reset() { *m = StopResponse{} } +func (m *StopResponse) String() string { return proto.CompactTextString(m) } +func (*StopResponse) ProtoMessage() {} +func (*StopResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{101} +} + +func (m *StopResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_StopResponse.Unmarshal(m, b) +} +func (m *StopResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_StopResponse.Marshal(b, m, deterministic) +} +func (m *StopResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StopResponse.Merge(m, src) +} +func (m *StopResponse) XXX_Size() int { + return xxx_messageInfo_StopResponse.Size(m) +} +func (m *StopResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StopResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StopResponse proto.InternalMessageInfo + +type GraphTopologySubscription struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GraphTopologySubscription) Reset() { *m = GraphTopologySubscription{} } +func (m *GraphTopologySubscription) String() string { return proto.CompactTextString(m) } +func (*GraphTopologySubscription) ProtoMessage() {} +func (*GraphTopologySubscription) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{102} +} + +func (m *GraphTopologySubscription) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GraphTopologySubscription.Unmarshal(m, b) +} +func (m *GraphTopologySubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GraphTopologySubscription.Marshal(b, m, deterministic) +} +func (m *GraphTopologySubscription) XXX_Merge(src proto.Message) { + xxx_messageInfo_GraphTopologySubscription.Merge(m, src) +} +func (m *GraphTopologySubscription) XXX_Size() int { + return xxx_messageInfo_GraphTopologySubscription.Size(m) +} +func (m *GraphTopologySubscription) XXX_DiscardUnknown() { + xxx_messageInfo_GraphTopologySubscription.DiscardUnknown(m) +} + +var xxx_messageInfo_GraphTopologySubscription proto.InternalMessageInfo + +type GraphTopologyUpdate struct { + NodeUpdates []*NodeUpdate `protobuf:"bytes,1,rep,name=node_updates,json=nodeUpdates,proto3" json:"node_updates,omitempty"` + ChannelUpdates []*ChannelEdgeUpdate `protobuf:"bytes,2,rep,name=channel_updates,json=channelUpdates,proto3" json:"channel_updates,omitempty"` + ClosedChans []*ClosedChannelUpdate `protobuf:"bytes,3,rep,name=closed_chans,json=closedChans,proto3" json:"closed_chans,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GraphTopologyUpdate) Reset() { *m = GraphTopologyUpdate{} } +func (m *GraphTopologyUpdate) String() string { return proto.CompactTextString(m) } +func (*GraphTopologyUpdate) ProtoMessage() {} +func (*GraphTopologyUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{103} +} + +func (m *GraphTopologyUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GraphTopologyUpdate.Unmarshal(m, b) +} +func (m *GraphTopologyUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GraphTopologyUpdate.Marshal(b, m, deterministic) +} +func (m *GraphTopologyUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_GraphTopologyUpdate.Merge(m, src) +} +func (m *GraphTopologyUpdate) XXX_Size() int { + return xxx_messageInfo_GraphTopologyUpdate.Size(m) +} +func (m *GraphTopologyUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_GraphTopologyUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_GraphTopologyUpdate proto.InternalMessageInfo + +func (m *GraphTopologyUpdate) GetNodeUpdates() []*NodeUpdate { + if m != nil { + return m.NodeUpdates + } + return nil +} + +func (m *GraphTopologyUpdate) GetChannelUpdates() []*ChannelEdgeUpdate { + if m != nil { + return m.ChannelUpdates + } + return nil +} + +func (m *GraphTopologyUpdate) GetClosedChans() []*ClosedChannelUpdate { + if m != nil { + return m.ClosedChans + } + return nil +} + +type NodeUpdate struct { + Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` + IdentityKey string `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` + GlobalFeatures []byte `protobuf:"bytes,3,opt,name=global_features,json=globalFeatures,proto3" json:"global_features,omitempty"` + Alias string `protobuf:"bytes,4,opt,name=alias,proto3" json:"alias,omitempty"` + Color string `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeUpdate) Reset() { *m = NodeUpdate{} } +func (m *NodeUpdate) String() string { return proto.CompactTextString(m) } +func (*NodeUpdate) ProtoMessage() {} +func (*NodeUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{104} +} + +func (m *NodeUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeUpdate.Unmarshal(m, b) +} +func (m *NodeUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeUpdate.Marshal(b, m, deterministic) +} +func (m *NodeUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeUpdate.Merge(m, src) +} +func (m *NodeUpdate) XXX_Size() int { + return xxx_messageInfo_NodeUpdate.Size(m) +} +func (m *NodeUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_NodeUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeUpdate proto.InternalMessageInfo + +func (m *NodeUpdate) GetAddresses() []string { + if m != nil { + return m.Addresses + } + return nil +} + +func (m *NodeUpdate) GetIdentityKey() string { + if m != nil { + return m.IdentityKey + } + return "" +} + +func (m *NodeUpdate) GetGlobalFeatures() []byte { + if m != nil { + return m.GlobalFeatures + } + return nil +} + +func (m *NodeUpdate) GetAlias() string { + if m != nil { + return m.Alias + } + return "" +} + +func (m *NodeUpdate) GetColor() string { + if m != nil { + return m.Color + } + return "" +} + +type ChannelEdgeUpdate struct { + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + Capacity int64 `protobuf:"varint,3,opt,name=capacity,proto3" json:"capacity,omitempty"` + RoutingPolicy *RoutingPolicy `protobuf:"bytes,4,opt,name=routing_policy,json=routingPolicy,proto3" json:"routing_policy,omitempty"` + AdvertisingNode string `protobuf:"bytes,5,opt,name=advertising_node,json=advertisingNode,proto3" json:"advertising_node,omitempty"` + ConnectingNode string `protobuf:"bytes,6,opt,name=connecting_node,json=connectingNode,proto3" json:"connecting_node,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelEdgeUpdate) Reset() { *m = ChannelEdgeUpdate{} } +func (m *ChannelEdgeUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelEdgeUpdate) ProtoMessage() {} +func (*ChannelEdgeUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{105} +} + +func (m *ChannelEdgeUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelEdgeUpdate.Unmarshal(m, b) +} +func (m *ChannelEdgeUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelEdgeUpdate.Marshal(b, m, deterministic) +} +func (m *ChannelEdgeUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelEdgeUpdate.Merge(m, src) +} +func (m *ChannelEdgeUpdate) XXX_Size() int { + return xxx_messageInfo_ChannelEdgeUpdate.Size(m) +} +func (m *ChannelEdgeUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelEdgeUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelEdgeUpdate proto.InternalMessageInfo + +func (m *ChannelEdgeUpdate) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *ChannelEdgeUpdate) GetChanPoint() *ChannelPoint { + if m != nil { + return m.ChanPoint + } + return nil +} + +func (m *ChannelEdgeUpdate) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *ChannelEdgeUpdate) GetRoutingPolicy() *RoutingPolicy { + if m != nil { + return m.RoutingPolicy + } + return nil +} + +func (m *ChannelEdgeUpdate) GetAdvertisingNode() string { + if m != nil { + return m.AdvertisingNode + } + return "" +} + +func (m *ChannelEdgeUpdate) GetConnectingNode() string { + if m != nil { + return m.ConnectingNode + } + return "" +} + +type ClosedChannelUpdate struct { + // + //The unique channel ID for the channel. The first 3 bytes are the block + //height, the next 3 the index within the block, and the last 2 bytes are the + //output index for the channel. + ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + Capacity int64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"` + ClosedHeight uint32 `protobuf:"varint,3,opt,name=closed_height,json=closedHeight,proto3" json:"closed_height,omitempty"` + ChanPoint *ChannelPoint `protobuf:"bytes,4,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ClosedChannelUpdate) Reset() { *m = ClosedChannelUpdate{} } +func (m *ClosedChannelUpdate) String() string { return proto.CompactTextString(m) } +func (*ClosedChannelUpdate) ProtoMessage() {} +func (*ClosedChannelUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{106} +} + +func (m *ClosedChannelUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ClosedChannelUpdate.Unmarshal(m, b) +} +func (m *ClosedChannelUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ClosedChannelUpdate.Marshal(b, m, deterministic) +} +func (m *ClosedChannelUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClosedChannelUpdate.Merge(m, src) +} +func (m *ClosedChannelUpdate) XXX_Size() int { + return xxx_messageInfo_ClosedChannelUpdate.Size(m) +} +func (m *ClosedChannelUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ClosedChannelUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ClosedChannelUpdate proto.InternalMessageInfo + +func (m *ClosedChannelUpdate) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *ClosedChannelUpdate) GetCapacity() int64 { + if m != nil { + return m.Capacity + } + return 0 +} + +func (m *ClosedChannelUpdate) GetClosedHeight() uint32 { + if m != nil { + return m.ClosedHeight + } + return 0 +} + +func (m *ClosedChannelUpdate) GetChanPoint() *ChannelPoint { + if m != nil { + return m.ChanPoint + } + return nil +} + +type HopHint struct { + // The public key of the node at the start of the channel. + NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + // The unique identifier of the channel. + ChanId uint64 `protobuf:"varint,2,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // The base fee of the channel denominated in millisatoshis. + FeeBaseMsat uint32 `protobuf:"varint,3,opt,name=fee_base_msat,json=feeBaseMsat,proto3" json:"fee_base_msat,omitempty"` + // + //The fee rate of the channel for sending one satoshi across it denominated in + //millionths of a satoshi. + FeeProportionalMillionths uint32 `protobuf:"varint,4,opt,name=fee_proportional_millionths,json=feeProportionalMillionths,proto3" json:"fee_proportional_millionths,omitempty"` + // The time-lock delta of the channel. + CltvExpiryDelta uint32 `protobuf:"varint,5,opt,name=cltv_expiry_delta,json=cltvExpiryDelta,proto3" json:"cltv_expiry_delta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HopHint) Reset() { *m = HopHint{} } +func (m *HopHint) String() string { return proto.CompactTextString(m) } +func (*HopHint) ProtoMessage() {} +func (*HopHint) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{107} +} + +func (m *HopHint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HopHint.Unmarshal(m, b) +} +func (m *HopHint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HopHint.Marshal(b, m, deterministic) +} +func (m *HopHint) XXX_Merge(src proto.Message) { + xxx_messageInfo_HopHint.Merge(m, src) +} +func (m *HopHint) XXX_Size() int { + return xxx_messageInfo_HopHint.Size(m) +} +func (m *HopHint) XXX_DiscardUnknown() { + xxx_messageInfo_HopHint.DiscardUnknown(m) +} + +var xxx_messageInfo_HopHint proto.InternalMessageInfo + +func (m *HopHint) GetNodeId() string { + if m != nil { + return m.NodeId + } + return "" +} + +func (m *HopHint) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *HopHint) GetFeeBaseMsat() uint32 { + if m != nil { + return m.FeeBaseMsat + } + return 0 +} + +func (m *HopHint) GetFeeProportionalMillionths() uint32 { + if m != nil { + return m.FeeProportionalMillionths + } + return 0 +} + +func (m *HopHint) GetCltvExpiryDelta() uint32 { + if m != nil { + return m.CltvExpiryDelta + } + return 0 +} + +type RouteHint struct { + // + //A list of hop hints that when chained together can assist in reaching a + //specific destination. + HopHints []*HopHint `protobuf:"bytes,1,rep,name=hop_hints,json=hopHints,proto3" json:"hop_hints,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RouteHint) Reset() { *m = RouteHint{} } +func (m *RouteHint) String() string { return proto.CompactTextString(m) } +func (*RouteHint) ProtoMessage() {} +func (*RouteHint) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{108} +} + +func (m *RouteHint) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RouteHint.Unmarshal(m, b) +} +func (m *RouteHint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RouteHint.Marshal(b, m, deterministic) +} +func (m *RouteHint) XXX_Merge(src proto.Message) { + xxx_messageInfo_RouteHint.Merge(m, src) +} +func (m *RouteHint) XXX_Size() int { + return xxx_messageInfo_RouteHint.Size(m) +} +func (m *RouteHint) XXX_DiscardUnknown() { + xxx_messageInfo_RouteHint.DiscardUnknown(m) +} + +var xxx_messageInfo_RouteHint proto.InternalMessageInfo + +func (m *RouteHint) GetHopHints() []*HopHint { + if m != nil { + return m.HopHints + } + return nil +} + +type Invoice struct { + // + //An optional memo to attach along with the invoice. Used for record keeping + //purposes for the invoice's creator, and will also be set in the description + //field of the encoded payment request if the description_hash field is not + //being used. + Memo string `protobuf:"bytes,1,opt,name=memo,proto3" json:"memo,omitempty"` + // + //The hex-encoded preimage (32 byte) which will allow settling an incoming + //HTLC payable to this preimage. When using REST, this field must be encoded + //as base64. + RPreimage []byte `protobuf:"bytes,3,opt,name=r_preimage,json=rPreimage,proto3" json:"r_preimage,omitempty"` + // + //The hash of the preimage. When using REST, this field must be encoded as + //base64. + RHash []byte `protobuf:"bytes,4,opt,name=r_hash,json=rHash,proto3" json:"r_hash,omitempty"` + // + //The value of this invoice in satoshis + // + //The fields value and value_msat are mutually exclusive. + Value int64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"` + // + //The value of this invoice in millisatoshis + // + //The fields value and value_msat are mutually exclusive. + ValueMsat int64 `protobuf:"varint,23,opt,name=value_msat,json=valueMsat,proto3" json:"value_msat,omitempty"` + // Whether this invoice has been fulfilled + Settled bool `protobuf:"varint,6,opt,name=settled,proto3" json:"settled,omitempty"` // Deprecated: Do not use. + // When this invoice was created + CreationDate int64 `protobuf:"varint,7,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"` + // When this invoice was settled + SettleDate int64 `protobuf:"varint,8,opt,name=settle_date,json=settleDate,proto3" json:"settle_date,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. + PaymentRequest string `protobuf:"bytes,9,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` + // + //Hash (SHA-256) of a description of the payment. Used if the description of + //payment (memo) is too long to naturally fit within the description field + //of an encoded payment request. When using REST, this field must be encoded + //as base64. + DescriptionHash []byte `protobuf:"bytes,10,opt,name=description_hash,json=descriptionHash,proto3" json:"description_hash,omitempty"` + // Payment request expiry time in seconds. Default is 3600 (1 hour). + Expiry int64 `protobuf:"varint,11,opt,name=expiry,proto3" json:"expiry,omitempty"` + // Fallback on-chain address. + FallbackAddr string `protobuf:"bytes,12,opt,name=fallback_addr,json=fallbackAddr,proto3" json:"fallback_addr,omitempty"` + // Delta to use for the time-lock of the CLTV extended to the final hop. + CltvExpiry uint64 `protobuf:"varint,13,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` + // + //Route hints that can each be individually used to assist in reaching the + //invoice's destination. + RouteHints []*RouteHint `protobuf:"bytes,14,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"` + // Whether this invoice should include routing hints for private channels. + Private bool `protobuf:"varint,15,opt,name=private,proto3" json:"private,omitempty"` + // + //The "add" index of this invoice. Each newly created invoice will increment + //this index making it monotonically increasing. Callers to the + //SubscribeInvoices call can use this to instantly get notified of all added + //invoices with an add_index greater than this one. + AddIndex uint64 `protobuf:"varint,16,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` + // + //The "settle" index of this invoice. Each newly settled invoice will + //increment this index making it monotonically increasing. Callers to the + //SubscribeInvoices call can use this to instantly get notified of all + //settled invoices with an settle_index greater than this one. + SettleIndex uint64 `protobuf:"varint,17,opt,name=settle_index,json=settleIndex,proto3" json:"settle_index,omitempty"` + // Deprecated, use amt_paid_sat or amt_paid_msat. + AmtPaid int64 `protobuf:"varint,18,opt,name=amt_paid,json=amtPaid,proto3" json:"amt_paid,omitempty"` // Deprecated: Do not use. + // + //The amount that was accepted for this invoice, in satoshis. This will ONLY + //be set if this invoice has been settled. We provide this field as if the + //invoice was created with a zero value, then we need to record what amount + //was ultimately accepted. Additionally, it's possible that the sender paid + //MORE that was specified in the original invoice. So we'll record that here + //as well. + AmtPaidSat int64 `protobuf:"varint,19,opt,name=amt_paid_sat,json=amtPaidSat,proto3" json:"amt_paid_sat,omitempty"` + // + //The amount that was accepted for this invoice, in millisatoshis. This will + //ONLY be set if this invoice has been settled. We provide this field as if + //the invoice was created with a zero value, then we need to record what + //amount was ultimately accepted. Additionally, it's possible that the sender + //paid MORE that was specified in the original invoice. So we'll record that + //here as well. + AmtPaidMsat int64 `protobuf:"varint,20,opt,name=amt_paid_msat,json=amtPaidMsat,proto3" json:"amt_paid_msat,omitempty"` + // + //The state the invoice is in. + State Invoice_InvoiceState `protobuf:"varint,21,opt,name=state,proto3,enum=lnrpc.Invoice_InvoiceState" json:"state,omitempty"` + // List of HTLCs paying to this invoice [EXPERIMENTAL]. + Htlcs []*InvoiceHTLC `protobuf:"bytes,22,rep,name=htlcs,proto3" json:"htlcs,omitempty"` + // List of features advertised on the invoice. + Features map[uint32]*Feature `protobuf:"bytes,24,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // + //Indicates if this invoice was a spontaneous payment that arrived via keysend + //[EXPERIMENTAL]. + IsKeysend bool `protobuf:"varint,25,opt,name=is_keysend,json=isKeysend,proto3" json:"is_keysend,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Invoice) Reset() { *m = Invoice{} } +func (m *Invoice) String() string { return proto.CompactTextString(m) } +func (*Invoice) ProtoMessage() {} +func (*Invoice) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{109} +} + +func (m *Invoice) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Invoice.Unmarshal(m, b) +} +func (m *Invoice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Invoice.Marshal(b, m, deterministic) +} +func (m *Invoice) XXX_Merge(src proto.Message) { + xxx_messageInfo_Invoice.Merge(m, src) +} +func (m *Invoice) XXX_Size() int { + return xxx_messageInfo_Invoice.Size(m) +} +func (m *Invoice) XXX_DiscardUnknown() { + xxx_messageInfo_Invoice.DiscardUnknown(m) +} + +var xxx_messageInfo_Invoice proto.InternalMessageInfo + +func (m *Invoice) GetMemo() string { + if m != nil { + return m.Memo + } + return "" +} + +func (m *Invoice) GetRPreimage() []byte { + if m != nil { + return m.RPreimage + } + return nil +} + +func (m *Invoice) GetRHash() []byte { + if m != nil { + return m.RHash + } + return nil +} + +func (m *Invoice) GetValue() int64 { + if m != nil { + return m.Value + } + return 0 +} + +func (m *Invoice) GetValueMsat() int64 { + if m != nil { + return m.ValueMsat + } + return 0 +} + +// Deprecated: Do not use. +func (m *Invoice) GetSettled() bool { + if m != nil { + return m.Settled + } + return false +} + +func (m *Invoice) GetCreationDate() int64 { + if m != nil { + return m.CreationDate + } + return 0 +} + +func (m *Invoice) GetSettleDate() int64 { + if m != nil { + return m.SettleDate + } + return 0 +} + +func (m *Invoice) GetPaymentRequest() string { + if m != nil { + return m.PaymentRequest + } + return "" +} + +func (m *Invoice) GetDescriptionHash() []byte { + if m != nil { + return m.DescriptionHash + } + return nil +} + +func (m *Invoice) GetExpiry() int64 { + if m != nil { + return m.Expiry + } + return 0 +} + +func (m *Invoice) GetFallbackAddr() string { + if m != nil { + return m.FallbackAddr + } + return "" +} + +func (m *Invoice) GetCltvExpiry() uint64 { + if m != nil { + return m.CltvExpiry + } + return 0 +} + +func (m *Invoice) GetRouteHints() []*RouteHint { + if m != nil { + return m.RouteHints + } + return nil +} + +func (m *Invoice) GetPrivate() bool { + if m != nil { + return m.Private + } + return false +} + +func (m *Invoice) GetAddIndex() uint64 { + if m != nil { + return m.AddIndex + } + return 0 +} + +func (m *Invoice) GetSettleIndex() uint64 { + if m != nil { + return m.SettleIndex + } + return 0 +} + +// Deprecated: Do not use. +func (m *Invoice) GetAmtPaid() int64 { + if m != nil { + return m.AmtPaid + } + return 0 +} + +func (m *Invoice) GetAmtPaidSat() int64 { + if m != nil { + return m.AmtPaidSat + } + return 0 +} + +func (m *Invoice) GetAmtPaidMsat() int64 { + if m != nil { + return m.AmtPaidMsat + } + return 0 +} + +func (m *Invoice) GetState() Invoice_InvoiceState { + if m != nil { + return m.State + } + return Invoice_OPEN +} + +func (m *Invoice) GetHtlcs() []*InvoiceHTLC { + if m != nil { + return m.Htlcs + } + return nil +} + +func (m *Invoice) GetFeatures() map[uint32]*Feature { + if m != nil { + return m.Features + } + return nil +} + +func (m *Invoice) GetIsKeysend() bool { + if m != nil { + return m.IsKeysend + } + return false +} + +// Details of an HTLC that paid to an invoice +type InvoiceHTLC struct { + // Short channel id over which the htlc was received. + ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // Index identifying the htlc on the channel. + HtlcIndex uint64 `protobuf:"varint,2,opt,name=htlc_index,json=htlcIndex,proto3" json:"htlc_index,omitempty"` + // The amount of the htlc in msat. + AmtMsat uint64 `protobuf:"varint,3,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"` + // Block height at which this htlc was accepted. + AcceptHeight int32 `protobuf:"varint,4,opt,name=accept_height,json=acceptHeight,proto3" json:"accept_height,omitempty"` + // Time at which this htlc was accepted. + AcceptTime int64 `protobuf:"varint,5,opt,name=accept_time,json=acceptTime,proto3" json:"accept_time,omitempty"` + // Time at which this htlc was settled or canceled. + ResolveTime int64 `protobuf:"varint,6,opt,name=resolve_time,json=resolveTime,proto3" json:"resolve_time,omitempty"` + // Block height at which this htlc expires. + ExpiryHeight int32 `protobuf:"varint,7,opt,name=expiry_height,json=expiryHeight,proto3" json:"expiry_height,omitempty"` + // Current state the htlc is in. + State InvoiceHTLCState `protobuf:"varint,8,opt,name=state,proto3,enum=lnrpc.InvoiceHTLCState" json:"state,omitempty"` + // Custom tlv records. + CustomRecords map[uint64][]byte `protobuf:"bytes,9,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // The total amount of the mpp payment in msat. + MppTotalAmtMsat uint64 `protobuf:"varint,10,opt,name=mpp_total_amt_msat,json=mppTotalAmtMsat,proto3" json:"mpp_total_amt_msat,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InvoiceHTLC) Reset() { *m = InvoiceHTLC{} } +func (m *InvoiceHTLC) String() string { return proto.CompactTextString(m) } +func (*InvoiceHTLC) ProtoMessage() {} +func (*InvoiceHTLC) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{110} +} + +func (m *InvoiceHTLC) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_InvoiceHTLC.Unmarshal(m, b) +} +func (m *InvoiceHTLC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_InvoiceHTLC.Marshal(b, m, deterministic) +} +func (m *InvoiceHTLC) XXX_Merge(src proto.Message) { + xxx_messageInfo_InvoiceHTLC.Merge(m, src) +} +func (m *InvoiceHTLC) XXX_Size() int { + return xxx_messageInfo_InvoiceHTLC.Size(m) +} +func (m *InvoiceHTLC) XXX_DiscardUnknown() { + xxx_messageInfo_InvoiceHTLC.DiscardUnknown(m) +} + +var xxx_messageInfo_InvoiceHTLC proto.InternalMessageInfo + +func (m *InvoiceHTLC) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *InvoiceHTLC) GetHtlcIndex() uint64 { + if m != nil { + return m.HtlcIndex + } + return 0 +} + +func (m *InvoiceHTLC) GetAmtMsat() uint64 { + if m != nil { + return m.AmtMsat + } + return 0 +} + +func (m *InvoiceHTLC) GetAcceptHeight() int32 { + if m != nil { + return m.AcceptHeight + } + return 0 +} + +func (m *InvoiceHTLC) GetAcceptTime() int64 { + if m != nil { + return m.AcceptTime + } + return 0 +} + +func (m *InvoiceHTLC) GetResolveTime() int64 { + if m != nil { + return m.ResolveTime + } + return 0 +} + +func (m *InvoiceHTLC) GetExpiryHeight() int32 { + if m != nil { + return m.ExpiryHeight + } + return 0 +} + +func (m *InvoiceHTLC) GetState() InvoiceHTLCState { + if m != nil { + return m.State + } + return InvoiceHTLCState_ACCEPTED +} + +func (m *InvoiceHTLC) GetCustomRecords() map[uint64][]byte { + if m != nil { + return m.CustomRecords + } + return nil +} + +func (m *InvoiceHTLC) GetMppTotalAmtMsat() uint64 { + if m != nil { + return m.MppTotalAmtMsat + } + return 0 +} + +type AddInvoiceResponse struct { + RHash []byte `protobuf:"bytes,1,opt,name=r_hash,json=rHash,proto3" json:"r_hash,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. + PaymentRequest string `protobuf:"bytes,2,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` + // + //The "add" index of this invoice. Each newly created invoice will increment + //this index making it monotonically increasing. Callers to the + //SubscribeInvoices call can use this to instantly get notified of all added + //invoices with an add_index greater than this one. + AddIndex uint64 `protobuf:"varint,16,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AddInvoiceResponse) Reset() { *m = AddInvoiceResponse{} } +func (m *AddInvoiceResponse) String() string { return proto.CompactTextString(m) } +func (*AddInvoiceResponse) ProtoMessage() {} +func (*AddInvoiceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{111} +} + +func (m *AddInvoiceResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AddInvoiceResponse.Unmarshal(m, b) +} +func (m *AddInvoiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AddInvoiceResponse.Marshal(b, m, deterministic) +} +func (m *AddInvoiceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AddInvoiceResponse.Merge(m, src) +} +func (m *AddInvoiceResponse) XXX_Size() int { + return xxx_messageInfo_AddInvoiceResponse.Size(m) +} +func (m *AddInvoiceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AddInvoiceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AddInvoiceResponse proto.InternalMessageInfo + +func (m *AddInvoiceResponse) GetRHash() []byte { + if m != nil { + return m.RHash + } + return nil +} + +func (m *AddInvoiceResponse) GetPaymentRequest() string { + if m != nil { + return m.PaymentRequest + } + return "" +} + +func (m *AddInvoiceResponse) GetAddIndex() uint64 { + if m != nil { + return m.AddIndex + } + return 0 +} + +type PaymentHash struct { + // + //The hex-encoded payment hash of the invoice to be looked up. The passed + //payment hash must be exactly 32 bytes, otherwise an error is returned. + //Deprecated now that the REST gateway supports base64 encoding of bytes + //fields. + RHashStr string `protobuf:"bytes,1,opt,name=r_hash_str,json=rHashStr,proto3" json:"r_hash_str,omitempty"` // Deprecated: Do not use. + // + //The payment hash of the invoice to be looked up. When using REST, this field + //must be encoded as base64. + RHash []byte `protobuf:"bytes,2,opt,name=r_hash,json=rHash,proto3" json:"r_hash,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PaymentHash) Reset() { *m = PaymentHash{} } +func (m *PaymentHash) String() string { return proto.CompactTextString(m) } +func (*PaymentHash) ProtoMessage() {} +func (*PaymentHash) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{112} +} + +func (m *PaymentHash) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PaymentHash.Unmarshal(m, b) +} +func (m *PaymentHash) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PaymentHash.Marshal(b, m, deterministic) +} +func (m *PaymentHash) XXX_Merge(src proto.Message) { + xxx_messageInfo_PaymentHash.Merge(m, src) +} +func (m *PaymentHash) XXX_Size() int { + return xxx_messageInfo_PaymentHash.Size(m) +} +func (m *PaymentHash) XXX_DiscardUnknown() { + xxx_messageInfo_PaymentHash.DiscardUnknown(m) +} + +var xxx_messageInfo_PaymentHash proto.InternalMessageInfo + +// Deprecated: Do not use. +func (m *PaymentHash) GetRHashStr() string { + if m != nil { + return m.RHashStr + } + return "" +} + +func (m *PaymentHash) GetRHash() []byte { + if m != nil { + return m.RHash + } + return nil +} + +type ListInvoiceRequest struct { + // + //If set, only invoices that are not settled and not canceled will be returned + //in the response. + PendingOnly bool `protobuf:"varint,1,opt,name=pending_only,json=pendingOnly,proto3" json:"pending_only,omitempty"` + // + //The index of an invoice that will be used as either the start or end of a + //query to determine which invoices should be returned in the response. + IndexOffset uint64 `protobuf:"varint,4,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` + // The max number of invoices to return in the response to this query. + NumMaxInvoices uint64 `protobuf:"varint,5,opt,name=num_max_invoices,json=numMaxInvoices,proto3" json:"num_max_invoices,omitempty"` + // + //If set, the invoices returned will result from seeking backwards from the + //specified index offset. This can be used to paginate backwards. + Reversed bool `protobuf:"varint,6,opt,name=reversed,proto3" json:"reversed,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListInvoiceRequest) Reset() { *m = ListInvoiceRequest{} } +func (m *ListInvoiceRequest) String() string { return proto.CompactTextString(m) } +func (*ListInvoiceRequest) ProtoMessage() {} +func (*ListInvoiceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{113} +} + +func (m *ListInvoiceRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListInvoiceRequest.Unmarshal(m, b) +} +func (m *ListInvoiceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListInvoiceRequest.Marshal(b, m, deterministic) +} +func (m *ListInvoiceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListInvoiceRequest.Merge(m, src) +} +func (m *ListInvoiceRequest) XXX_Size() int { + return xxx_messageInfo_ListInvoiceRequest.Size(m) +} +func (m *ListInvoiceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListInvoiceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListInvoiceRequest proto.InternalMessageInfo + +func (m *ListInvoiceRequest) GetPendingOnly() bool { + if m != nil { + return m.PendingOnly + } + return false +} + +func (m *ListInvoiceRequest) GetIndexOffset() uint64 { + if m != nil { + return m.IndexOffset + } + return 0 +} + +func (m *ListInvoiceRequest) GetNumMaxInvoices() uint64 { + if m != nil { + return m.NumMaxInvoices + } + return 0 +} + +func (m *ListInvoiceRequest) GetReversed() bool { + if m != nil { + return m.Reversed + } + return false +} + +type ListInvoiceResponse struct { + // + //A list of invoices from the time slice of the time series specified in the + //request. + Invoices []*Invoice `protobuf:"bytes,1,rep,name=invoices,proto3" json:"invoices,omitempty"` + // + //The index of the last item in the set of returned invoices. This can be used + //to seek further, pagination style. + LastIndexOffset uint64 `protobuf:"varint,2,opt,name=last_index_offset,json=lastIndexOffset,proto3" json:"last_index_offset,omitempty"` + // + //The index of the last item in the set of returned invoices. This can be used + //to seek backwards, pagination style. + FirstIndexOffset uint64 `protobuf:"varint,3,opt,name=first_index_offset,json=firstIndexOffset,proto3" json:"first_index_offset,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListInvoiceResponse) Reset() { *m = ListInvoiceResponse{} } +func (m *ListInvoiceResponse) String() string { return proto.CompactTextString(m) } +func (*ListInvoiceResponse) ProtoMessage() {} +func (*ListInvoiceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{114} +} + +func (m *ListInvoiceResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListInvoiceResponse.Unmarshal(m, b) +} +func (m *ListInvoiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListInvoiceResponse.Marshal(b, m, deterministic) +} +func (m *ListInvoiceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListInvoiceResponse.Merge(m, src) +} +func (m *ListInvoiceResponse) XXX_Size() int { + return xxx_messageInfo_ListInvoiceResponse.Size(m) +} +func (m *ListInvoiceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListInvoiceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListInvoiceResponse proto.InternalMessageInfo + +func (m *ListInvoiceResponse) GetInvoices() []*Invoice { + if m != nil { + return m.Invoices + } + return nil +} + +func (m *ListInvoiceResponse) GetLastIndexOffset() uint64 { + if m != nil { + return m.LastIndexOffset + } + return 0 +} + +func (m *ListInvoiceResponse) GetFirstIndexOffset() uint64 { + if m != nil { + return m.FirstIndexOffset + } + return 0 +} + +type InvoiceSubscription struct { + // + //If specified (non-zero), then we'll first start by sending out + //notifications for all added indexes with an add_index greater than this + //value. This allows callers to catch up on any events they missed while they + //weren't connected to the streaming RPC. + AddIndex uint64 `protobuf:"varint,1,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` + // + //If specified (non-zero), then we'll first start by sending out + //notifications for all settled indexes with an settle_index greater than + //this value. This allows callers to catch up on any events they missed while + //they weren't connected to the streaming RPC. + SettleIndex uint64 `protobuf:"varint,2,opt,name=settle_index,json=settleIndex,proto3" json:"settle_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *InvoiceSubscription) Reset() { *m = InvoiceSubscription{} } +func (m *InvoiceSubscription) String() string { return proto.CompactTextString(m) } +func (*InvoiceSubscription) ProtoMessage() {} +func (*InvoiceSubscription) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{115} +} + +func (m *InvoiceSubscription) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_InvoiceSubscription.Unmarshal(m, b) +} +func (m *InvoiceSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_InvoiceSubscription.Marshal(b, m, deterministic) +} +func (m *InvoiceSubscription) XXX_Merge(src proto.Message) { + xxx_messageInfo_InvoiceSubscription.Merge(m, src) +} +func (m *InvoiceSubscription) XXX_Size() int { + return xxx_messageInfo_InvoiceSubscription.Size(m) +} +func (m *InvoiceSubscription) XXX_DiscardUnknown() { + xxx_messageInfo_InvoiceSubscription.DiscardUnknown(m) +} + +var xxx_messageInfo_InvoiceSubscription proto.InternalMessageInfo + +func (m *InvoiceSubscription) GetAddIndex() uint64 { + if m != nil { + return m.AddIndex + } + return 0 +} + +func (m *InvoiceSubscription) GetSettleIndex() uint64 { + if m != nil { + return m.SettleIndex + } + return 0 +} + +type Payment struct { + // The payment hash + PaymentHash string `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + // Deprecated, use value_sat or value_msat. + Value int64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` // Deprecated: Do not use. + // Deprecated, use creation_time_ns + CreationDate int64 `protobuf:"varint,3,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"` // Deprecated: Do not use. + // Deprecated, use fee_sat or fee_msat. + Fee int64 `protobuf:"varint,5,opt,name=fee,proto3" json:"fee,omitempty"` // Deprecated: Do not use. + // The payment preimage + PaymentPreimage string `protobuf:"bytes,6,opt,name=payment_preimage,json=paymentPreimage,proto3" json:"payment_preimage,omitempty"` + // The value of the payment in satoshis + ValueSat int64 `protobuf:"varint,7,opt,name=value_sat,json=valueSat,proto3" json:"value_sat,omitempty"` + // The value of the payment in milli-satoshis + ValueMsat int64 `protobuf:"varint,8,opt,name=value_msat,json=valueMsat,proto3" json:"value_msat,omitempty"` + // The optional payment request being fulfilled. + PaymentRequest string `protobuf:"bytes,9,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` + // The status of the payment. + Status Payment_PaymentStatus `protobuf:"varint,10,opt,name=status,proto3,enum=lnrpc.Payment_PaymentStatus" json:"status,omitempty"` + // The fee paid for this payment in satoshis + FeeSat int64 `protobuf:"varint,11,opt,name=fee_sat,json=feeSat,proto3" json:"fee_sat,omitempty"` + // The fee paid for this payment in milli-satoshis + FeeMsat int64 `protobuf:"varint,12,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` + // The time in UNIX nanoseconds at which the payment was created. + CreationTimeNs int64 `protobuf:"varint,13,opt,name=creation_time_ns,json=creationTimeNs,proto3" json:"creation_time_ns,omitempty"` + // The HTLCs made in attempt to settle the payment. + Htlcs []*HTLCAttempt `protobuf:"bytes,14,rep,name=htlcs,proto3" json:"htlcs,omitempty"` + // + //The creation index of this payment. Each payment can be uniquely identified + //by this index, which may not strictly increment by 1 for payments made in + //older versions of lnd. + PaymentIndex uint64 `protobuf:"varint,15,opt,name=payment_index,json=paymentIndex,proto3" json:"payment_index,omitempty"` + FailureReason PaymentFailureReason `protobuf:"varint,16,opt,name=failure_reason,json=failureReason,proto3,enum=lnrpc.PaymentFailureReason" json:"failure_reason,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Payment) Reset() { *m = Payment{} } +func (m *Payment) String() string { return proto.CompactTextString(m) } +func (*Payment) ProtoMessage() {} +func (*Payment) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{116} +} + +func (m *Payment) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Payment.Unmarshal(m, b) +} +func (m *Payment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Payment.Marshal(b, m, deterministic) +} +func (m *Payment) XXX_Merge(src proto.Message) { + xxx_messageInfo_Payment.Merge(m, src) +} +func (m *Payment) XXX_Size() int { + return xxx_messageInfo_Payment.Size(m) +} +func (m *Payment) XXX_DiscardUnknown() { + xxx_messageInfo_Payment.DiscardUnknown(m) +} + +var xxx_messageInfo_Payment proto.InternalMessageInfo + +func (m *Payment) GetPaymentHash() string { + if m != nil { + return m.PaymentHash + } + return "" +} + +// Deprecated: Do not use. +func (m *Payment) GetValue() int64 { + if m != nil { + return m.Value + } + return 0 +} + +// Deprecated: Do not use. +func (m *Payment) GetCreationDate() int64 { + if m != nil { + return m.CreationDate + } + return 0 +} + +// Deprecated: Do not use. +func (m *Payment) GetFee() int64 { + if m != nil { + return m.Fee + } + return 0 +} + +func (m *Payment) GetPaymentPreimage() string { + if m != nil { + return m.PaymentPreimage + } + return "" +} + +func (m *Payment) GetValueSat() int64 { + if m != nil { + return m.ValueSat + } + return 0 +} + +func (m *Payment) GetValueMsat() int64 { + if m != nil { + return m.ValueMsat + } + return 0 +} + +func (m *Payment) GetPaymentRequest() string { + if m != nil { + return m.PaymentRequest + } + return "" +} + +func (m *Payment) GetStatus() Payment_PaymentStatus { + if m != nil { + return m.Status + } + return Payment_UNKNOWN +} + +func (m *Payment) GetFeeSat() int64 { + if m != nil { + return m.FeeSat + } + return 0 +} + +func (m *Payment) GetFeeMsat() int64 { + if m != nil { + return m.FeeMsat + } + return 0 +} + +func (m *Payment) GetCreationTimeNs() int64 { + if m != nil { + return m.CreationTimeNs + } + return 0 +} + +func (m *Payment) GetHtlcs() []*HTLCAttempt { + if m != nil { + return m.Htlcs + } + return nil +} + +func (m *Payment) GetPaymentIndex() uint64 { + if m != nil { + return m.PaymentIndex + } + return 0 +} + +func (m *Payment) GetFailureReason() PaymentFailureReason { + if m != nil { + return m.FailureReason + } + return PaymentFailureReason_FAILURE_REASON_NONE +} + +type HTLCAttempt struct { + // The status of the HTLC. + Status HTLCAttempt_HTLCStatus `protobuf:"varint,1,opt,name=status,proto3,enum=lnrpc.HTLCAttempt_HTLCStatus" json:"status,omitempty"` + // The route taken by this HTLC. + Route *Route `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"` + // The time in UNIX nanoseconds at which this HTLC was sent. + AttemptTimeNs int64 `protobuf:"varint,3,opt,name=attempt_time_ns,json=attemptTimeNs,proto3" json:"attempt_time_ns,omitempty"` + // + //The time in UNIX nanoseconds at which this HTLC was settled or failed. + //This value will not be set if the HTLC is still IN_FLIGHT. + ResolveTimeNs int64 `protobuf:"varint,4,opt,name=resolve_time_ns,json=resolveTimeNs,proto3" json:"resolve_time_ns,omitempty"` + // Detailed htlc failure info. + Failure *Failure `protobuf:"bytes,5,opt,name=failure,proto3" json:"failure,omitempty"` + // The preimage that was used to settle the HTLC. + Preimage []byte `protobuf:"bytes,6,opt,name=preimage,proto3" json:"preimage,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HTLCAttempt) Reset() { *m = HTLCAttempt{} } +func (m *HTLCAttempt) String() string { return proto.CompactTextString(m) } +func (*HTLCAttempt) ProtoMessage() {} +func (*HTLCAttempt) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{117} +} + +func (m *HTLCAttempt) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_HTLCAttempt.Unmarshal(m, b) +} +func (m *HTLCAttempt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_HTLCAttempt.Marshal(b, m, deterministic) +} +func (m *HTLCAttempt) XXX_Merge(src proto.Message) { + xxx_messageInfo_HTLCAttempt.Merge(m, src) +} +func (m *HTLCAttempt) XXX_Size() int { + return xxx_messageInfo_HTLCAttempt.Size(m) +} +func (m *HTLCAttempt) XXX_DiscardUnknown() { + xxx_messageInfo_HTLCAttempt.DiscardUnknown(m) +} + +var xxx_messageInfo_HTLCAttempt proto.InternalMessageInfo + +func (m *HTLCAttempt) GetStatus() HTLCAttempt_HTLCStatus { + if m != nil { + return m.Status + } + return HTLCAttempt_IN_FLIGHT +} + +func (m *HTLCAttempt) GetRoute() *Route { + if m != nil { + return m.Route + } + return nil +} + +func (m *HTLCAttempt) GetAttemptTimeNs() int64 { + if m != nil { + return m.AttemptTimeNs + } + return 0 +} + +func (m *HTLCAttempt) GetResolveTimeNs() int64 { + if m != nil { + return m.ResolveTimeNs + } + return 0 +} + +func (m *HTLCAttempt) GetFailure() *Failure { + if m != nil { + return m.Failure + } + return nil +} + +func (m *HTLCAttempt) GetPreimage() []byte { + if m != nil { + return m.Preimage + } + return nil +} + +type ListPaymentsRequest struct { + // + //If true, then return payments that have not yet fully completed. This means + //that pending payments, as well as failed payments will show up if this + //field is set to true. This flag doesn't change the meaning of the indices, + //which are tied to individual payments. + IncludeIncomplete bool `protobuf:"varint,1,opt,name=include_incomplete,json=includeIncomplete,proto3" json:"include_incomplete,omitempty"` + // + //The index of a payment that will be used as either the start or end of a + //query to determine which payments should be returned in the response. The + //index_offset is exclusive. In the case of a zero index_offset, the query + //will start with the oldest payment when paginating forwards, or will end + //with the most recent payment when paginating backwards. + IndexOffset uint64 `protobuf:"varint,2,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` + // The maximal number of payments returned in the response to this query. + MaxPayments uint64 `protobuf:"varint,3,opt,name=max_payments,json=maxPayments,proto3" json:"max_payments,omitempty"` + // + //If set, the payments returned will result from seeking backwards from the + //specified index offset. This can be used to paginate backwards. The order + //of the returned payments is always oldest first (ascending index order). + Reversed bool `protobuf:"varint,4,opt,name=reversed,proto3" json:"reversed,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPaymentsRequest) Reset() { *m = ListPaymentsRequest{} } +func (m *ListPaymentsRequest) String() string { return proto.CompactTextString(m) } +func (*ListPaymentsRequest) ProtoMessage() {} +func (*ListPaymentsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{118} +} + +func (m *ListPaymentsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPaymentsRequest.Unmarshal(m, b) +} +func (m *ListPaymentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPaymentsRequest.Marshal(b, m, deterministic) +} +func (m *ListPaymentsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPaymentsRequest.Merge(m, src) +} +func (m *ListPaymentsRequest) XXX_Size() int { + return xxx_messageInfo_ListPaymentsRequest.Size(m) +} +func (m *ListPaymentsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListPaymentsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPaymentsRequest proto.InternalMessageInfo + +func (m *ListPaymentsRequest) GetIncludeIncomplete() bool { + if m != nil { + return m.IncludeIncomplete + } + return false +} + +func (m *ListPaymentsRequest) GetIndexOffset() uint64 { + if m != nil { + return m.IndexOffset + } + return 0 +} + +func (m *ListPaymentsRequest) GetMaxPayments() uint64 { + if m != nil { + return m.MaxPayments + } + return 0 +} + +func (m *ListPaymentsRequest) GetReversed() bool { + if m != nil { + return m.Reversed + } + return false +} + +type ListPaymentsResponse struct { + // The list of payments + Payments []*Payment `protobuf:"bytes,1,rep,name=payments,proto3" json:"payments,omitempty"` + // + //The index of the first item in the set of returned payments. This can be + //used as the index_offset to continue seeking backwards in the next request. + FirstIndexOffset uint64 `protobuf:"varint,2,opt,name=first_index_offset,json=firstIndexOffset,proto3" json:"first_index_offset,omitempty"` + // + //The index of the last item in the set of returned payments. This can be used + //as the index_offset to continue seeking forwards in the next request. + LastIndexOffset uint64 `protobuf:"varint,3,opt,name=last_index_offset,json=lastIndexOffset,proto3" json:"last_index_offset,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPaymentsResponse) Reset() { *m = ListPaymentsResponse{} } +func (m *ListPaymentsResponse) String() string { return proto.CompactTextString(m) } +func (*ListPaymentsResponse) ProtoMessage() {} +func (*ListPaymentsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{119} +} + +func (m *ListPaymentsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPaymentsResponse.Unmarshal(m, b) +} +func (m *ListPaymentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPaymentsResponse.Marshal(b, m, deterministic) +} +func (m *ListPaymentsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPaymentsResponse.Merge(m, src) +} +func (m *ListPaymentsResponse) XXX_Size() int { + return xxx_messageInfo_ListPaymentsResponse.Size(m) +} +func (m *ListPaymentsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListPaymentsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPaymentsResponse proto.InternalMessageInfo + +func (m *ListPaymentsResponse) GetPayments() []*Payment { + if m != nil { + return m.Payments + } + return nil +} + +func (m *ListPaymentsResponse) GetFirstIndexOffset() uint64 { + if m != nil { + return m.FirstIndexOffset + } + return 0 +} + +func (m *ListPaymentsResponse) GetLastIndexOffset() uint64 { + if m != nil { + return m.LastIndexOffset + } + return 0 +} + +type DeleteAllPaymentsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteAllPaymentsRequest) Reset() { *m = DeleteAllPaymentsRequest{} } +func (m *DeleteAllPaymentsRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteAllPaymentsRequest) ProtoMessage() {} +func (*DeleteAllPaymentsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{120} +} + +func (m *DeleteAllPaymentsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteAllPaymentsRequest.Unmarshal(m, b) +} +func (m *DeleteAllPaymentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteAllPaymentsRequest.Marshal(b, m, deterministic) +} +func (m *DeleteAllPaymentsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteAllPaymentsRequest.Merge(m, src) +} +func (m *DeleteAllPaymentsRequest) XXX_Size() int { + return xxx_messageInfo_DeleteAllPaymentsRequest.Size(m) +} +func (m *DeleteAllPaymentsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteAllPaymentsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteAllPaymentsRequest proto.InternalMessageInfo + +type DeleteAllPaymentsResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteAllPaymentsResponse) Reset() { *m = DeleteAllPaymentsResponse{} } +func (m *DeleteAllPaymentsResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteAllPaymentsResponse) ProtoMessage() {} +func (*DeleteAllPaymentsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{121} +} + +func (m *DeleteAllPaymentsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteAllPaymentsResponse.Unmarshal(m, b) +} +func (m *DeleteAllPaymentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteAllPaymentsResponse.Marshal(b, m, deterministic) +} +func (m *DeleteAllPaymentsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteAllPaymentsResponse.Merge(m, src) +} +func (m *DeleteAllPaymentsResponse) XXX_Size() int { + return xxx_messageInfo_DeleteAllPaymentsResponse.Size(m) +} +func (m *DeleteAllPaymentsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteAllPaymentsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteAllPaymentsResponse proto.InternalMessageInfo + +type AbandonChannelRequest struct { + ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + PendingFundingShimOnly bool `protobuf:"varint,2,opt,name=pending_funding_shim_only,json=pendingFundingShimOnly,proto3" json:"pending_funding_shim_only,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AbandonChannelRequest) Reset() { *m = AbandonChannelRequest{} } +func (m *AbandonChannelRequest) String() string { return proto.CompactTextString(m) } +func (*AbandonChannelRequest) ProtoMessage() {} +func (*AbandonChannelRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{122} +} + +func (m *AbandonChannelRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AbandonChannelRequest.Unmarshal(m, b) +} +func (m *AbandonChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AbandonChannelRequest.Marshal(b, m, deterministic) +} +func (m *AbandonChannelRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AbandonChannelRequest.Merge(m, src) +} +func (m *AbandonChannelRequest) XXX_Size() int { + return xxx_messageInfo_AbandonChannelRequest.Size(m) +} +func (m *AbandonChannelRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AbandonChannelRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_AbandonChannelRequest proto.InternalMessageInfo + +func (m *AbandonChannelRequest) GetChannelPoint() *ChannelPoint { + if m != nil { + return m.ChannelPoint + } + return nil +} + +func (m *AbandonChannelRequest) GetPendingFundingShimOnly() bool { + if m != nil { + return m.PendingFundingShimOnly + } + return false +} + +type AbandonChannelResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *AbandonChannelResponse) Reset() { *m = AbandonChannelResponse{} } +func (m *AbandonChannelResponse) String() string { return proto.CompactTextString(m) } +func (*AbandonChannelResponse) ProtoMessage() {} +func (*AbandonChannelResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{123} +} + +func (m *AbandonChannelResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_AbandonChannelResponse.Unmarshal(m, b) +} +func (m *AbandonChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_AbandonChannelResponse.Marshal(b, m, deterministic) +} +func (m *AbandonChannelResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AbandonChannelResponse.Merge(m, src) +} +func (m *AbandonChannelResponse) XXX_Size() int { + return xxx_messageInfo_AbandonChannelResponse.Size(m) +} +func (m *AbandonChannelResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AbandonChannelResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_AbandonChannelResponse proto.InternalMessageInfo + +type DebugLevelRequest struct { + Show bool `protobuf:"varint,1,opt,name=show,proto3" json:"show,omitempty"` + LevelSpec string `protobuf:"bytes,2,opt,name=level_spec,json=levelSpec,proto3" json:"level_spec,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DebugLevelRequest) Reset() { *m = DebugLevelRequest{} } +func (m *DebugLevelRequest) String() string { return proto.CompactTextString(m) } +func (*DebugLevelRequest) ProtoMessage() {} +func (*DebugLevelRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{124} +} + +func (m *DebugLevelRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DebugLevelRequest.Unmarshal(m, b) +} +func (m *DebugLevelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DebugLevelRequest.Marshal(b, m, deterministic) +} +func (m *DebugLevelRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DebugLevelRequest.Merge(m, src) +} +func (m *DebugLevelRequest) XXX_Size() int { + return xxx_messageInfo_DebugLevelRequest.Size(m) +} +func (m *DebugLevelRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DebugLevelRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DebugLevelRequest proto.InternalMessageInfo + +func (m *DebugLevelRequest) GetShow() bool { + if m != nil { + return m.Show + } + return false +} + +func (m *DebugLevelRequest) GetLevelSpec() string { + if m != nil { + return m.LevelSpec + } + return "" +} + +type DebugLevelResponse struct { + SubSystems string `protobuf:"bytes,1,opt,name=sub_systems,json=subSystems,proto3" json:"sub_systems,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DebugLevelResponse) Reset() { *m = DebugLevelResponse{} } +func (m *DebugLevelResponse) String() string { return proto.CompactTextString(m) } +func (*DebugLevelResponse) ProtoMessage() {} +func (*DebugLevelResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{125} +} + +func (m *DebugLevelResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DebugLevelResponse.Unmarshal(m, b) +} +func (m *DebugLevelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DebugLevelResponse.Marshal(b, m, deterministic) +} +func (m *DebugLevelResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DebugLevelResponse.Merge(m, src) +} +func (m *DebugLevelResponse) XXX_Size() int { + return xxx_messageInfo_DebugLevelResponse.Size(m) +} +func (m *DebugLevelResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DebugLevelResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DebugLevelResponse proto.InternalMessageInfo + +func (m *DebugLevelResponse) GetSubSystems() string { + if m != nil { + return m.SubSystems + } + return "" +} + +type PayReqString struct { + // The payment request string to be decoded + PayReq string `protobuf:"bytes,1,opt,name=pay_req,json=payReq,proto3" json:"pay_req,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PayReqString) Reset() { *m = PayReqString{} } +func (m *PayReqString) String() string { return proto.CompactTextString(m) } +func (*PayReqString) ProtoMessage() {} +func (*PayReqString) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{126} +} + +func (m *PayReqString) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PayReqString.Unmarshal(m, b) +} +func (m *PayReqString) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PayReqString.Marshal(b, m, deterministic) +} +func (m *PayReqString) XXX_Merge(src proto.Message) { + xxx_messageInfo_PayReqString.Merge(m, src) +} +func (m *PayReqString) XXX_Size() int { + return xxx_messageInfo_PayReqString.Size(m) +} +func (m *PayReqString) XXX_DiscardUnknown() { + xxx_messageInfo_PayReqString.DiscardUnknown(m) +} + +var xxx_messageInfo_PayReqString proto.InternalMessageInfo + +func (m *PayReqString) GetPayReq() string { + if m != nil { + return m.PayReq + } + return "" +} + +type PayReq struct { + Destination string `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"` + PaymentHash string `protobuf:"bytes,2,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + NumSatoshis int64 `protobuf:"varint,3,opt,name=num_satoshis,json=numSatoshis,proto3" json:"num_satoshis,omitempty"` + Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + Expiry int64 `protobuf:"varint,5,opt,name=expiry,proto3" json:"expiry,omitempty"` + Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"` + DescriptionHash string `protobuf:"bytes,7,opt,name=description_hash,json=descriptionHash,proto3" json:"description_hash,omitempty"` + FallbackAddr string `protobuf:"bytes,8,opt,name=fallback_addr,json=fallbackAddr,proto3" json:"fallback_addr,omitempty"` + CltvExpiry int64 `protobuf:"varint,9,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` + RouteHints []*RouteHint `protobuf:"bytes,10,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"` + PaymentAddr []byte `protobuf:"bytes,11,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` + NumMsat int64 `protobuf:"varint,12,opt,name=num_msat,json=numMsat,proto3" json:"num_msat,omitempty"` + Features map[uint32]*Feature `protobuf:"bytes,13,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PayReq) Reset() { *m = PayReq{} } +func (m *PayReq) String() string { return proto.CompactTextString(m) } +func (*PayReq) ProtoMessage() {} +func (*PayReq) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{127} +} + +func (m *PayReq) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PayReq.Unmarshal(m, b) +} +func (m *PayReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PayReq.Marshal(b, m, deterministic) +} +func (m *PayReq) XXX_Merge(src proto.Message) { + xxx_messageInfo_PayReq.Merge(m, src) +} +func (m *PayReq) XXX_Size() int { + return xxx_messageInfo_PayReq.Size(m) +} +func (m *PayReq) XXX_DiscardUnknown() { + xxx_messageInfo_PayReq.DiscardUnknown(m) +} + +var xxx_messageInfo_PayReq proto.InternalMessageInfo + +func (m *PayReq) GetDestination() string { + if m != nil { + return m.Destination + } + return "" +} + +func (m *PayReq) GetPaymentHash() string { + if m != nil { + return m.PaymentHash + } + return "" +} + +func (m *PayReq) GetNumSatoshis() int64 { + if m != nil { + return m.NumSatoshis + } + return 0 +} + +func (m *PayReq) GetTimestamp() int64 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *PayReq) GetExpiry() int64 { + if m != nil { + return m.Expiry + } + return 0 +} + +func (m *PayReq) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *PayReq) GetDescriptionHash() string { + if m != nil { + return m.DescriptionHash + } + return "" +} + +func (m *PayReq) GetFallbackAddr() string { + if m != nil { + return m.FallbackAddr + } + return "" +} + +func (m *PayReq) GetCltvExpiry() int64 { + if m != nil { + return m.CltvExpiry + } + return 0 +} + +func (m *PayReq) GetRouteHints() []*RouteHint { + if m != nil { + return m.RouteHints + } + return nil +} + +func (m *PayReq) GetPaymentAddr() []byte { + if m != nil { + return m.PaymentAddr + } + return nil +} + +func (m *PayReq) GetNumMsat() int64 { + if m != nil { + return m.NumMsat + } + return 0 +} + +func (m *PayReq) GetFeatures() map[uint32]*Feature { + if m != nil { + return m.Features + } + return nil +} + +type Feature struct { + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + IsRequired bool `protobuf:"varint,3,opt,name=is_required,json=isRequired,proto3" json:"is_required,omitempty"` + IsKnown bool `protobuf:"varint,4,opt,name=is_known,json=isKnown,proto3" json:"is_known,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Feature) Reset() { *m = Feature{} } +func (m *Feature) String() string { return proto.CompactTextString(m) } +func (*Feature) ProtoMessage() {} +func (*Feature) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{128} +} + +func (m *Feature) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Feature.Unmarshal(m, b) +} +func (m *Feature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Feature.Marshal(b, m, deterministic) +} +func (m *Feature) XXX_Merge(src proto.Message) { + xxx_messageInfo_Feature.Merge(m, src) +} +func (m *Feature) XXX_Size() int { + return xxx_messageInfo_Feature.Size(m) +} +func (m *Feature) XXX_DiscardUnknown() { + xxx_messageInfo_Feature.DiscardUnknown(m) +} + +var xxx_messageInfo_Feature proto.InternalMessageInfo + +func (m *Feature) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Feature) GetIsRequired() bool { + if m != nil { + return m.IsRequired + } + return false +} + +func (m *Feature) GetIsKnown() bool { + if m != nil { + return m.IsKnown + } + return false +} + +type FeeReportRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FeeReportRequest) Reset() { *m = FeeReportRequest{} } +func (m *FeeReportRequest) String() string { return proto.CompactTextString(m) } +func (*FeeReportRequest) ProtoMessage() {} +func (*FeeReportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{129} +} + +func (m *FeeReportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FeeReportRequest.Unmarshal(m, b) +} +func (m *FeeReportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FeeReportRequest.Marshal(b, m, deterministic) +} +func (m *FeeReportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_FeeReportRequest.Merge(m, src) +} +func (m *FeeReportRequest) XXX_Size() int { + return xxx_messageInfo_FeeReportRequest.Size(m) +} +func (m *FeeReportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_FeeReportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_FeeReportRequest proto.InternalMessageInfo + +type ChannelFeeReport struct { + // The short channel id that this fee report belongs to. + ChanId uint64 `protobuf:"varint,5,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // The channel that this fee report belongs to. + ChannelPoint string `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` + // The base fee charged regardless of the number of milli-satoshis sent. + BaseFeeMsat int64 `protobuf:"varint,2,opt,name=base_fee_msat,json=baseFeeMsat,proto3" json:"base_fee_msat,omitempty"` + // The amount charged per milli-satoshis transferred expressed in + // millionths of a satoshi. + FeePerMil int64 `protobuf:"varint,3,opt,name=fee_per_mil,json=feePerMil,proto3" json:"fee_per_mil,omitempty"` + // The effective fee rate in milli-satoshis. Computed by dividing the + // fee_per_mil value by 1 million. + FeeRate float64 `protobuf:"fixed64,4,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelFeeReport) Reset() { *m = ChannelFeeReport{} } +func (m *ChannelFeeReport) String() string { return proto.CompactTextString(m) } +func (*ChannelFeeReport) ProtoMessage() {} +func (*ChannelFeeReport) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{130} +} + +func (m *ChannelFeeReport) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelFeeReport.Unmarshal(m, b) +} +func (m *ChannelFeeReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelFeeReport.Marshal(b, m, deterministic) +} +func (m *ChannelFeeReport) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelFeeReport.Merge(m, src) +} +func (m *ChannelFeeReport) XXX_Size() int { + return xxx_messageInfo_ChannelFeeReport.Size(m) +} +func (m *ChannelFeeReport) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelFeeReport.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelFeeReport proto.InternalMessageInfo + +func (m *ChannelFeeReport) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *ChannelFeeReport) GetChannelPoint() string { + if m != nil { + return m.ChannelPoint + } + return "" +} + +func (m *ChannelFeeReport) GetBaseFeeMsat() int64 { + if m != nil { + return m.BaseFeeMsat + } + return 0 +} + +func (m *ChannelFeeReport) GetFeePerMil() int64 { + if m != nil { + return m.FeePerMil + } + return 0 +} + +func (m *ChannelFeeReport) GetFeeRate() float64 { + if m != nil { + return m.FeeRate + } + return 0 +} + +type FeeReportResponse struct { + // An array of channel fee reports which describes the current fee schedule + // for each channel. + ChannelFees []*ChannelFeeReport `protobuf:"bytes,1,rep,name=channel_fees,json=channelFees,proto3" json:"channel_fees,omitempty"` + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 24 hrs. + DayFeeSum uint64 `protobuf:"varint,2,opt,name=day_fee_sum,json=dayFeeSum,proto3" json:"day_fee_sum,omitempty"` + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 week. + WeekFeeSum uint64 `protobuf:"varint,3,opt,name=week_fee_sum,json=weekFeeSum,proto3" json:"week_fee_sum,omitempty"` + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 month. + MonthFeeSum uint64 `protobuf:"varint,4,opt,name=month_fee_sum,json=monthFeeSum,proto3" json:"month_fee_sum,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FeeReportResponse) Reset() { *m = FeeReportResponse{} } +func (m *FeeReportResponse) String() string { return proto.CompactTextString(m) } +func (*FeeReportResponse) ProtoMessage() {} +func (*FeeReportResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{131} +} + +func (m *FeeReportResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FeeReportResponse.Unmarshal(m, b) +} +func (m *FeeReportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FeeReportResponse.Marshal(b, m, deterministic) +} +func (m *FeeReportResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_FeeReportResponse.Merge(m, src) +} +func (m *FeeReportResponse) XXX_Size() int { + return xxx_messageInfo_FeeReportResponse.Size(m) +} +func (m *FeeReportResponse) XXX_DiscardUnknown() { + xxx_messageInfo_FeeReportResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_FeeReportResponse proto.InternalMessageInfo + +func (m *FeeReportResponse) GetChannelFees() []*ChannelFeeReport { + if m != nil { + return m.ChannelFees + } + return nil +} + +func (m *FeeReportResponse) GetDayFeeSum() uint64 { + if m != nil { + return m.DayFeeSum + } + return 0 +} + +func (m *FeeReportResponse) GetWeekFeeSum() uint64 { + if m != nil { + return m.WeekFeeSum + } + return 0 +} + +func (m *FeeReportResponse) GetMonthFeeSum() uint64 { + if m != nil { + return m.MonthFeeSum + } + return 0 +} + +type PolicyUpdateRequest struct { + // Types that are valid to be assigned to Scope: + // *PolicyUpdateRequest_Global + // *PolicyUpdateRequest_ChanPoint + Scope isPolicyUpdateRequest_Scope `protobuf_oneof:"scope"` + // The base fee charged regardless of the number of milli-satoshis sent. + BaseFeeMsat int64 `protobuf:"varint,3,opt,name=base_fee_msat,json=baseFeeMsat,proto3" json:"base_fee_msat,omitempty"` + // The effective fee rate in milli-satoshis. The precision of this value + // goes up to 6 decimal places, so 1e-6. + FeeRate float64 `protobuf:"fixed64,4,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` + // The required timelock delta for HTLCs forwarded over the channel. + TimeLockDelta uint32 `protobuf:"varint,5,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` + // If set, the maximum HTLC size in milli-satoshis. If unset, the maximum + // HTLC will be unchanged. + MaxHtlcMsat uint64 `protobuf:"varint,6,opt,name=max_htlc_msat,json=maxHtlcMsat,proto3" json:"max_htlc_msat,omitempty"` + // The minimum HTLC size in milli-satoshis. Only applied if + // min_htlc_msat_specified is true. + MinHtlcMsat uint64 `protobuf:"varint,7,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` + // If true, min_htlc_msat is applied. + MinHtlcMsatSpecified bool `protobuf:"varint,8,opt,name=min_htlc_msat_specified,json=minHtlcMsatSpecified,proto3" json:"min_htlc_msat_specified,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PolicyUpdateRequest) Reset() { *m = PolicyUpdateRequest{} } +func (m *PolicyUpdateRequest) String() string { return proto.CompactTextString(m) } +func (*PolicyUpdateRequest) ProtoMessage() {} +func (*PolicyUpdateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{132} +} + +func (m *PolicyUpdateRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PolicyUpdateRequest.Unmarshal(m, b) +} +func (m *PolicyUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PolicyUpdateRequest.Marshal(b, m, deterministic) +} +func (m *PolicyUpdateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PolicyUpdateRequest.Merge(m, src) +} +func (m *PolicyUpdateRequest) XXX_Size() int { + return xxx_messageInfo_PolicyUpdateRequest.Size(m) +} +func (m *PolicyUpdateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PolicyUpdateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PolicyUpdateRequest proto.InternalMessageInfo + +type isPolicyUpdateRequest_Scope interface { + isPolicyUpdateRequest_Scope() +} + +type PolicyUpdateRequest_Global struct { + Global bool `protobuf:"varint,1,opt,name=global,proto3,oneof"` +} + +type PolicyUpdateRequest_ChanPoint struct { + ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3,oneof"` +} + +func (*PolicyUpdateRequest_Global) isPolicyUpdateRequest_Scope() {} + +func (*PolicyUpdateRequest_ChanPoint) isPolicyUpdateRequest_Scope() {} + +func (m *PolicyUpdateRequest) GetScope() isPolicyUpdateRequest_Scope { + if m != nil { + return m.Scope + } + return nil +} + +func (m *PolicyUpdateRequest) GetGlobal() bool { + if x, ok := m.GetScope().(*PolicyUpdateRequest_Global); ok { + return x.Global + } + return false +} + +func (m *PolicyUpdateRequest) GetChanPoint() *ChannelPoint { + if x, ok := m.GetScope().(*PolicyUpdateRequest_ChanPoint); ok { + return x.ChanPoint + } + return nil +} + +func (m *PolicyUpdateRequest) GetBaseFeeMsat() int64 { + if m != nil { + return m.BaseFeeMsat + } + return 0 +} + +func (m *PolicyUpdateRequest) GetFeeRate() float64 { + if m != nil { + return m.FeeRate + } + return 0 +} + +func (m *PolicyUpdateRequest) GetTimeLockDelta() uint32 { + if m != nil { + return m.TimeLockDelta + } + return 0 +} + +func (m *PolicyUpdateRequest) GetMaxHtlcMsat() uint64 { + if m != nil { + return m.MaxHtlcMsat + } + return 0 +} + +func (m *PolicyUpdateRequest) GetMinHtlcMsat() uint64 { + if m != nil { + return m.MinHtlcMsat + } + return 0 +} + +func (m *PolicyUpdateRequest) GetMinHtlcMsatSpecified() bool { + if m != nil { + return m.MinHtlcMsatSpecified + } + return false +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*PolicyUpdateRequest) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*PolicyUpdateRequest_Global)(nil), + (*PolicyUpdateRequest_ChanPoint)(nil), + } +} + +type PolicyUpdateResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PolicyUpdateResponse) Reset() { *m = PolicyUpdateResponse{} } +func (m *PolicyUpdateResponse) String() string { return proto.CompactTextString(m) } +func (*PolicyUpdateResponse) ProtoMessage() {} +func (*PolicyUpdateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{133} +} + +func (m *PolicyUpdateResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PolicyUpdateResponse.Unmarshal(m, b) +} +func (m *PolicyUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PolicyUpdateResponse.Marshal(b, m, deterministic) +} +func (m *PolicyUpdateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PolicyUpdateResponse.Merge(m, src) +} +func (m *PolicyUpdateResponse) XXX_Size() int { + return xxx_messageInfo_PolicyUpdateResponse.Size(m) +} +func (m *PolicyUpdateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PolicyUpdateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PolicyUpdateResponse proto.InternalMessageInfo + +type ForwardingHistoryRequest struct { + // Start time is the starting point of the forwarding history request. All + // records beyond this point will be included, respecting the end time, and + // the index offset. + StartTime uint64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + // End time is the end point of the forwarding history request. The + // response will carry at most 50k records between the start time and the + // end time. The index offset can be used to implement pagination. + EndTime uint64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + // Index offset is the offset in the time series to start at. As each + // response can only contain 50k records, callers can use this to skip + // around within a packed time series. + IndexOffset uint32 `protobuf:"varint,3,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` + // The max number of events to return in the response to this query. + NumMaxEvents uint32 `protobuf:"varint,4,opt,name=num_max_events,json=numMaxEvents,proto3" json:"num_max_events,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForwardingHistoryRequest) Reset() { *m = ForwardingHistoryRequest{} } +func (m *ForwardingHistoryRequest) String() string { return proto.CompactTextString(m) } +func (*ForwardingHistoryRequest) ProtoMessage() {} +func (*ForwardingHistoryRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{134} +} + +func (m *ForwardingHistoryRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForwardingHistoryRequest.Unmarshal(m, b) +} +func (m *ForwardingHistoryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForwardingHistoryRequest.Marshal(b, m, deterministic) +} +func (m *ForwardingHistoryRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForwardingHistoryRequest.Merge(m, src) +} +func (m *ForwardingHistoryRequest) XXX_Size() int { + return xxx_messageInfo_ForwardingHistoryRequest.Size(m) +} +func (m *ForwardingHistoryRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ForwardingHistoryRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ForwardingHistoryRequest proto.InternalMessageInfo + +func (m *ForwardingHistoryRequest) GetStartTime() uint64 { + if m != nil { + return m.StartTime + } + return 0 +} + +func (m *ForwardingHistoryRequest) GetEndTime() uint64 { + if m != nil { + return m.EndTime + } + return 0 +} + +func (m *ForwardingHistoryRequest) GetIndexOffset() uint32 { + if m != nil { + return m.IndexOffset + } + return 0 +} + +func (m *ForwardingHistoryRequest) GetNumMaxEvents() uint32 { + if m != nil { + return m.NumMaxEvents + } + return 0 +} + +type ForwardingEvent struct { + // Timestamp is the time (unix epoch offset) that this circuit was + // completed. + Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // The incoming channel ID that carried the HTLC that created the circuit. + ChanIdIn uint64 `protobuf:"varint,2,opt,name=chan_id_in,json=chanIdIn,proto3" json:"chan_id_in,omitempty"` + // The outgoing channel ID that carried the preimage that completed the + // circuit. + ChanIdOut uint64 `protobuf:"varint,4,opt,name=chan_id_out,json=chanIdOut,proto3" json:"chan_id_out,omitempty"` + // The total amount (in satoshis) of the incoming HTLC that created half + // the circuit. + AmtIn uint64 `protobuf:"varint,5,opt,name=amt_in,json=amtIn,proto3" json:"amt_in,omitempty"` + // The total amount (in satoshis) of the outgoing HTLC that created the + // second half of the circuit. + AmtOut uint64 `protobuf:"varint,6,opt,name=amt_out,json=amtOut,proto3" json:"amt_out,omitempty"` + // The total fee (in satoshis) that this payment circuit carried. + Fee uint64 `protobuf:"varint,7,opt,name=fee,proto3" json:"fee,omitempty"` + // The total fee (in milli-satoshis) that this payment circuit carried. + FeeMsat uint64 `protobuf:"varint,8,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` + // The total amount (in milli-satoshis) of the incoming HTLC that created + // half the circuit. + AmtInMsat uint64 `protobuf:"varint,9,opt,name=amt_in_msat,json=amtInMsat,proto3" json:"amt_in_msat,omitempty"` + // The total amount (in milli-satoshis) of the outgoing HTLC that created + // the second half of the circuit. + AmtOutMsat uint64 `protobuf:"varint,10,opt,name=amt_out_msat,json=amtOutMsat,proto3" json:"amt_out_msat,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForwardingEvent) Reset() { *m = ForwardingEvent{} } +func (m *ForwardingEvent) String() string { return proto.CompactTextString(m) } +func (*ForwardingEvent) ProtoMessage() {} +func (*ForwardingEvent) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{135} +} + +func (m *ForwardingEvent) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForwardingEvent.Unmarshal(m, b) +} +func (m *ForwardingEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForwardingEvent.Marshal(b, m, deterministic) +} +func (m *ForwardingEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForwardingEvent.Merge(m, src) +} +func (m *ForwardingEvent) XXX_Size() int { + return xxx_messageInfo_ForwardingEvent.Size(m) +} +func (m *ForwardingEvent) XXX_DiscardUnknown() { + xxx_messageInfo_ForwardingEvent.DiscardUnknown(m) +} + +var xxx_messageInfo_ForwardingEvent proto.InternalMessageInfo + +func (m *ForwardingEvent) GetTimestamp() uint64 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *ForwardingEvent) GetChanIdIn() uint64 { + if m != nil { + return m.ChanIdIn + } + return 0 +} + +func (m *ForwardingEvent) GetChanIdOut() uint64 { + if m != nil { + return m.ChanIdOut + } + return 0 +} + +func (m *ForwardingEvent) GetAmtIn() uint64 { + if m != nil { + return m.AmtIn + } + return 0 +} + +func (m *ForwardingEvent) GetAmtOut() uint64 { + if m != nil { + return m.AmtOut + } + return 0 +} + +func (m *ForwardingEvent) GetFee() uint64 { + if m != nil { + return m.Fee + } + return 0 +} + +func (m *ForwardingEvent) GetFeeMsat() uint64 { + if m != nil { + return m.FeeMsat + } + return 0 +} + +func (m *ForwardingEvent) GetAmtInMsat() uint64 { + if m != nil { + return m.AmtInMsat + } + return 0 +} + +func (m *ForwardingEvent) GetAmtOutMsat() uint64 { + if m != nil { + return m.AmtOutMsat + } + return 0 +} + +type ForwardingHistoryResponse struct { + // A list of forwarding events from the time slice of the time series + // specified in the request. + ForwardingEvents []*ForwardingEvent `protobuf:"bytes,1,rep,name=forwarding_events,json=forwardingEvents,proto3" json:"forwarding_events,omitempty"` + // The index of the last time in the set of returned forwarding events. Can + // be used to seek further, pagination style. + LastOffsetIndex uint32 `protobuf:"varint,2,opt,name=last_offset_index,json=lastOffsetIndex,proto3" json:"last_offset_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ForwardingHistoryResponse) Reset() { *m = ForwardingHistoryResponse{} } +func (m *ForwardingHistoryResponse) String() string { return proto.CompactTextString(m) } +func (*ForwardingHistoryResponse) ProtoMessage() {} +func (*ForwardingHistoryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{136} +} + +func (m *ForwardingHistoryResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ForwardingHistoryResponse.Unmarshal(m, b) +} +func (m *ForwardingHistoryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ForwardingHistoryResponse.Marshal(b, m, deterministic) +} +func (m *ForwardingHistoryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ForwardingHistoryResponse.Merge(m, src) +} +func (m *ForwardingHistoryResponse) XXX_Size() int { + return xxx_messageInfo_ForwardingHistoryResponse.Size(m) +} +func (m *ForwardingHistoryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ForwardingHistoryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ForwardingHistoryResponse proto.InternalMessageInfo + +func (m *ForwardingHistoryResponse) GetForwardingEvents() []*ForwardingEvent { + if m != nil { + return m.ForwardingEvents + } + return nil +} + +func (m *ForwardingHistoryResponse) GetLastOffsetIndex() uint32 { + if m != nil { + return m.LastOffsetIndex + } + return 0 +} + +type ExportChannelBackupRequest struct { + // The target channel point to obtain a back up for. + ChanPoint *ChannelPoint `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExportChannelBackupRequest) Reset() { *m = ExportChannelBackupRequest{} } +func (m *ExportChannelBackupRequest) String() string { return proto.CompactTextString(m) } +func (*ExportChannelBackupRequest) ProtoMessage() {} +func (*ExportChannelBackupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{137} +} + +func (m *ExportChannelBackupRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExportChannelBackupRequest.Unmarshal(m, b) +} +func (m *ExportChannelBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExportChannelBackupRequest.Marshal(b, m, deterministic) +} +func (m *ExportChannelBackupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExportChannelBackupRequest.Merge(m, src) +} +func (m *ExportChannelBackupRequest) XXX_Size() int { + return xxx_messageInfo_ExportChannelBackupRequest.Size(m) +} +func (m *ExportChannelBackupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ExportChannelBackupRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ExportChannelBackupRequest proto.InternalMessageInfo + +func (m *ExportChannelBackupRequest) GetChanPoint() *ChannelPoint { + if m != nil { + return m.ChanPoint + } + return nil +} + +type ChannelBackup struct { + // + //Identifies the channel that this backup belongs to. + ChanPoint *ChannelPoint `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` + // + //Is an encrypted single-chan backup. this can be passed to + //RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in + //order to trigger the recovery protocol. When using REST, this field must be + //encoded as base64. + ChanBackup []byte `protobuf:"bytes,2,opt,name=chan_backup,json=chanBackup,proto3" json:"chan_backup,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBackup) Reset() { *m = ChannelBackup{} } +func (m *ChannelBackup) String() string { return proto.CompactTextString(m) } +func (*ChannelBackup) ProtoMessage() {} +func (*ChannelBackup) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{138} +} + +func (m *ChannelBackup) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBackup.Unmarshal(m, b) +} +func (m *ChannelBackup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBackup.Marshal(b, m, deterministic) +} +func (m *ChannelBackup) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBackup.Merge(m, src) +} +func (m *ChannelBackup) XXX_Size() int { + return xxx_messageInfo_ChannelBackup.Size(m) +} +func (m *ChannelBackup) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBackup.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBackup proto.InternalMessageInfo + +func (m *ChannelBackup) GetChanPoint() *ChannelPoint { + if m != nil { + return m.ChanPoint + } + return nil +} + +func (m *ChannelBackup) GetChanBackup() []byte { + if m != nil { + return m.ChanBackup + } + return nil +} + +type MultiChanBackup struct { + // + //Is the set of all channels that are included in this multi-channel backup. + ChanPoints []*ChannelPoint `protobuf:"bytes,1,rep,name=chan_points,json=chanPoints,proto3" json:"chan_points,omitempty"` + // + //A single encrypted blob containing all the static channel backups of the + //channel listed above. This can be stored as a single file or blob, and + //safely be replaced with any prior/future versions. When using REST, this + //field must be encoded as base64. + MultiChanBackup []byte `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3" json:"multi_chan_backup,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MultiChanBackup) Reset() { *m = MultiChanBackup{} } +func (m *MultiChanBackup) String() string { return proto.CompactTextString(m) } +func (*MultiChanBackup) ProtoMessage() {} +func (*MultiChanBackup) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{139} +} + +func (m *MultiChanBackup) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MultiChanBackup.Unmarshal(m, b) +} +func (m *MultiChanBackup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MultiChanBackup.Marshal(b, m, deterministic) +} +func (m *MultiChanBackup) XXX_Merge(src proto.Message) { + xxx_messageInfo_MultiChanBackup.Merge(m, src) +} +func (m *MultiChanBackup) XXX_Size() int { + return xxx_messageInfo_MultiChanBackup.Size(m) +} +func (m *MultiChanBackup) XXX_DiscardUnknown() { + xxx_messageInfo_MultiChanBackup.DiscardUnknown(m) +} + +var xxx_messageInfo_MultiChanBackup proto.InternalMessageInfo + +func (m *MultiChanBackup) GetChanPoints() []*ChannelPoint { + if m != nil { + return m.ChanPoints + } + return nil +} + +func (m *MultiChanBackup) GetMultiChanBackup() []byte { + if m != nil { + return m.MultiChanBackup + } + return nil +} + +type ChanBackupExportRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChanBackupExportRequest) Reset() { *m = ChanBackupExportRequest{} } +func (m *ChanBackupExportRequest) String() string { return proto.CompactTextString(m) } +func (*ChanBackupExportRequest) ProtoMessage() {} +func (*ChanBackupExportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{140} +} + +func (m *ChanBackupExportRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChanBackupExportRequest.Unmarshal(m, b) +} +func (m *ChanBackupExportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChanBackupExportRequest.Marshal(b, m, deterministic) +} +func (m *ChanBackupExportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChanBackupExportRequest.Merge(m, src) +} +func (m *ChanBackupExportRequest) XXX_Size() int { + return xxx_messageInfo_ChanBackupExportRequest.Size(m) +} +func (m *ChanBackupExportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ChanBackupExportRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ChanBackupExportRequest proto.InternalMessageInfo + +type ChanBackupSnapshot struct { + // + //The set of new channels that have been added since the last channel backup + //snapshot was requested. + SingleChanBackups *ChannelBackups `protobuf:"bytes,1,opt,name=single_chan_backups,json=singleChanBackups,proto3" json:"single_chan_backups,omitempty"` + // + //A multi-channel backup that covers all open channels currently known to + //lnd. + MultiChanBackup *MultiChanBackup `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3" json:"multi_chan_backup,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChanBackupSnapshot) Reset() { *m = ChanBackupSnapshot{} } +func (m *ChanBackupSnapshot) String() string { return proto.CompactTextString(m) } +func (*ChanBackupSnapshot) ProtoMessage() {} +func (*ChanBackupSnapshot) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{141} +} + +func (m *ChanBackupSnapshot) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChanBackupSnapshot.Unmarshal(m, b) +} +func (m *ChanBackupSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChanBackupSnapshot.Marshal(b, m, deterministic) +} +func (m *ChanBackupSnapshot) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChanBackupSnapshot.Merge(m, src) +} +func (m *ChanBackupSnapshot) XXX_Size() int { + return xxx_messageInfo_ChanBackupSnapshot.Size(m) +} +func (m *ChanBackupSnapshot) XXX_DiscardUnknown() { + xxx_messageInfo_ChanBackupSnapshot.DiscardUnknown(m) +} + +var xxx_messageInfo_ChanBackupSnapshot proto.InternalMessageInfo + +func (m *ChanBackupSnapshot) GetSingleChanBackups() *ChannelBackups { + if m != nil { + return m.SingleChanBackups + } + return nil +} + +func (m *ChanBackupSnapshot) GetMultiChanBackup() *MultiChanBackup { + if m != nil { + return m.MultiChanBackup + } + return nil +} + +type ChannelBackups struct { + // + //A set of single-chan static channel backups. + ChanBackups []*ChannelBackup `protobuf:"bytes,1,rep,name=chan_backups,json=chanBackups,proto3" json:"chan_backups,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBackups) Reset() { *m = ChannelBackups{} } +func (m *ChannelBackups) String() string { return proto.CompactTextString(m) } +func (*ChannelBackups) ProtoMessage() {} +func (*ChannelBackups) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{142} +} + +func (m *ChannelBackups) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBackups.Unmarshal(m, b) +} +func (m *ChannelBackups) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBackups.Marshal(b, m, deterministic) +} +func (m *ChannelBackups) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBackups.Merge(m, src) +} +func (m *ChannelBackups) XXX_Size() int { + return xxx_messageInfo_ChannelBackups.Size(m) +} +func (m *ChannelBackups) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBackups.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBackups proto.InternalMessageInfo + +func (m *ChannelBackups) GetChanBackups() []*ChannelBackup { + if m != nil { + return m.ChanBackups + } + return nil +} + +type RestoreChanBackupRequest struct { + // Types that are valid to be assigned to Backup: + // *RestoreChanBackupRequest_ChanBackups + // *RestoreChanBackupRequest_MultiChanBackup + Backup isRestoreChanBackupRequest_Backup `protobuf_oneof:"backup"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RestoreChanBackupRequest) Reset() { *m = RestoreChanBackupRequest{} } +func (m *RestoreChanBackupRequest) String() string { return proto.CompactTextString(m) } +func (*RestoreChanBackupRequest) ProtoMessage() {} +func (*RestoreChanBackupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{143} +} + +func (m *RestoreChanBackupRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RestoreChanBackupRequest.Unmarshal(m, b) +} +func (m *RestoreChanBackupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RestoreChanBackupRequest.Marshal(b, m, deterministic) +} +func (m *RestoreChanBackupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RestoreChanBackupRequest.Merge(m, src) +} +func (m *RestoreChanBackupRequest) XXX_Size() int { + return xxx_messageInfo_RestoreChanBackupRequest.Size(m) +} +func (m *RestoreChanBackupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RestoreChanBackupRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RestoreChanBackupRequest proto.InternalMessageInfo + +type isRestoreChanBackupRequest_Backup interface { + isRestoreChanBackupRequest_Backup() +} + +type RestoreChanBackupRequest_ChanBackups struct { + ChanBackups *ChannelBackups `protobuf:"bytes,1,opt,name=chan_backups,json=chanBackups,proto3,oneof"` +} + +type RestoreChanBackupRequest_MultiChanBackup struct { + MultiChanBackup []byte `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3,oneof"` +} + +func (*RestoreChanBackupRequest_ChanBackups) isRestoreChanBackupRequest_Backup() {} + +func (*RestoreChanBackupRequest_MultiChanBackup) isRestoreChanBackupRequest_Backup() {} + +func (m *RestoreChanBackupRequest) GetBackup() isRestoreChanBackupRequest_Backup { + if m != nil { + return m.Backup + } + return nil +} + +func (m *RestoreChanBackupRequest) GetChanBackups() *ChannelBackups { + if x, ok := m.GetBackup().(*RestoreChanBackupRequest_ChanBackups); ok { + return x.ChanBackups + } + return nil +} + +func (m *RestoreChanBackupRequest) GetMultiChanBackup() []byte { + if x, ok := m.GetBackup().(*RestoreChanBackupRequest_MultiChanBackup); ok { + return x.MultiChanBackup + } + return nil +} + +// XXX_OneofWrappers is for the internal use of the proto package. +func (*RestoreChanBackupRequest) XXX_OneofWrappers() []interface{} { + return []interface{}{ + (*RestoreChanBackupRequest_ChanBackups)(nil), + (*RestoreChanBackupRequest_MultiChanBackup)(nil), + } +} + +type RestoreBackupResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RestoreBackupResponse) Reset() { *m = RestoreBackupResponse{} } +func (m *RestoreBackupResponse) String() string { return proto.CompactTextString(m) } +func (*RestoreBackupResponse) ProtoMessage() {} +func (*RestoreBackupResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{144} +} + +func (m *RestoreBackupResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RestoreBackupResponse.Unmarshal(m, b) +} +func (m *RestoreBackupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RestoreBackupResponse.Marshal(b, m, deterministic) +} +func (m *RestoreBackupResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RestoreBackupResponse.Merge(m, src) +} +func (m *RestoreBackupResponse) XXX_Size() int { + return xxx_messageInfo_RestoreBackupResponse.Size(m) +} +func (m *RestoreBackupResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RestoreBackupResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RestoreBackupResponse proto.InternalMessageInfo + +type ChannelBackupSubscription struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelBackupSubscription) Reset() { *m = ChannelBackupSubscription{} } +func (m *ChannelBackupSubscription) String() string { return proto.CompactTextString(m) } +func (*ChannelBackupSubscription) ProtoMessage() {} +func (*ChannelBackupSubscription) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{145} +} + +func (m *ChannelBackupSubscription) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelBackupSubscription.Unmarshal(m, b) +} +func (m *ChannelBackupSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelBackupSubscription.Marshal(b, m, deterministic) +} +func (m *ChannelBackupSubscription) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelBackupSubscription.Merge(m, src) +} +func (m *ChannelBackupSubscription) XXX_Size() int { + return xxx_messageInfo_ChannelBackupSubscription.Size(m) +} +func (m *ChannelBackupSubscription) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelBackupSubscription.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelBackupSubscription proto.InternalMessageInfo + +type VerifyChanBackupResponse struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *VerifyChanBackupResponse) Reset() { *m = VerifyChanBackupResponse{} } +func (m *VerifyChanBackupResponse) String() string { return proto.CompactTextString(m) } +func (*VerifyChanBackupResponse) ProtoMessage() {} +func (*VerifyChanBackupResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{146} +} + +func (m *VerifyChanBackupResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_VerifyChanBackupResponse.Unmarshal(m, b) +} +func (m *VerifyChanBackupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_VerifyChanBackupResponse.Marshal(b, m, deterministic) +} +func (m *VerifyChanBackupResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_VerifyChanBackupResponse.Merge(m, src) +} +func (m *VerifyChanBackupResponse) XXX_Size() int { + return xxx_messageInfo_VerifyChanBackupResponse.Size(m) +} +func (m *VerifyChanBackupResponse) XXX_DiscardUnknown() { + xxx_messageInfo_VerifyChanBackupResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_VerifyChanBackupResponse proto.InternalMessageInfo + +type MacaroonPermission struct { + // The entity a permission grants access to. + Entity string `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + // The action that is granted. + Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MacaroonPermission) Reset() { *m = MacaroonPermission{} } +func (m *MacaroonPermission) String() string { return proto.CompactTextString(m) } +func (*MacaroonPermission) ProtoMessage() {} +func (*MacaroonPermission) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{147} +} + +func (m *MacaroonPermission) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MacaroonPermission.Unmarshal(m, b) +} +func (m *MacaroonPermission) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MacaroonPermission.Marshal(b, m, deterministic) +} +func (m *MacaroonPermission) XXX_Merge(src proto.Message) { + xxx_messageInfo_MacaroonPermission.Merge(m, src) +} +func (m *MacaroonPermission) XXX_Size() int { + return xxx_messageInfo_MacaroonPermission.Size(m) +} +func (m *MacaroonPermission) XXX_DiscardUnknown() { + xxx_messageInfo_MacaroonPermission.DiscardUnknown(m) +} + +var xxx_messageInfo_MacaroonPermission proto.InternalMessageInfo + +func (m *MacaroonPermission) GetEntity() string { + if m != nil { + return m.Entity + } + return "" +} + +func (m *MacaroonPermission) GetAction() string { + if m != nil { + return m.Action + } + return "" +} + +type BakeMacaroonRequest struct { + // The list of permissions the new macaroon should grant. + Permissions []*MacaroonPermission `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"` + // The root key ID used to create the macaroon, must be a positive integer. + RootKeyId uint64 `protobuf:"varint,2,opt,name=root_key_id,json=rootKeyId,proto3" json:"root_key_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BakeMacaroonRequest) Reset() { *m = BakeMacaroonRequest{} } +func (m *BakeMacaroonRequest) String() string { return proto.CompactTextString(m) } +func (*BakeMacaroonRequest) ProtoMessage() {} +func (*BakeMacaroonRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{148} +} + +func (m *BakeMacaroonRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BakeMacaroonRequest.Unmarshal(m, b) +} +func (m *BakeMacaroonRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BakeMacaroonRequest.Marshal(b, m, deterministic) +} +func (m *BakeMacaroonRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BakeMacaroonRequest.Merge(m, src) +} +func (m *BakeMacaroonRequest) XXX_Size() int { + return xxx_messageInfo_BakeMacaroonRequest.Size(m) +} +func (m *BakeMacaroonRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BakeMacaroonRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BakeMacaroonRequest proto.InternalMessageInfo + +func (m *BakeMacaroonRequest) GetPermissions() []*MacaroonPermission { + if m != nil { + return m.Permissions + } + return nil +} + +func (m *BakeMacaroonRequest) GetRootKeyId() uint64 { + if m != nil { + return m.RootKeyId + } + return 0 +} + +type BakeMacaroonResponse struct { + // The hex encoded macaroon, serialized in binary format. + Macaroon string `protobuf:"bytes,1,opt,name=macaroon,proto3" json:"macaroon,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BakeMacaroonResponse) Reset() { *m = BakeMacaroonResponse{} } +func (m *BakeMacaroonResponse) String() string { return proto.CompactTextString(m) } +func (*BakeMacaroonResponse) ProtoMessage() {} +func (*BakeMacaroonResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{149} +} + +func (m *BakeMacaroonResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BakeMacaroonResponse.Unmarshal(m, b) +} +func (m *BakeMacaroonResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BakeMacaroonResponse.Marshal(b, m, deterministic) +} +func (m *BakeMacaroonResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BakeMacaroonResponse.Merge(m, src) +} +func (m *BakeMacaroonResponse) XXX_Size() int { + return xxx_messageInfo_BakeMacaroonResponse.Size(m) +} +func (m *BakeMacaroonResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BakeMacaroonResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BakeMacaroonResponse proto.InternalMessageInfo + +func (m *BakeMacaroonResponse) GetMacaroon() string { + if m != nil { + return m.Macaroon + } + return "" +} + +type ListMacaroonIDsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListMacaroonIDsRequest) Reset() { *m = ListMacaroonIDsRequest{} } +func (m *ListMacaroonIDsRequest) String() string { return proto.CompactTextString(m) } +func (*ListMacaroonIDsRequest) ProtoMessage() {} +func (*ListMacaroonIDsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{150} +} + +func (m *ListMacaroonIDsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListMacaroonIDsRequest.Unmarshal(m, b) +} +func (m *ListMacaroonIDsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListMacaroonIDsRequest.Marshal(b, m, deterministic) +} +func (m *ListMacaroonIDsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListMacaroonIDsRequest.Merge(m, src) +} +func (m *ListMacaroonIDsRequest) XXX_Size() int { + return xxx_messageInfo_ListMacaroonIDsRequest.Size(m) +} +func (m *ListMacaroonIDsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListMacaroonIDsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListMacaroonIDsRequest proto.InternalMessageInfo + +type ListMacaroonIDsResponse struct { + // The list of root key IDs that are in use. + RootKeyIds []uint64 `protobuf:"varint,1,rep,packed,name=root_key_ids,json=rootKeyIds,proto3" json:"root_key_ids,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListMacaroonIDsResponse) Reset() { *m = ListMacaroonIDsResponse{} } +func (m *ListMacaroonIDsResponse) String() string { return proto.CompactTextString(m) } +func (*ListMacaroonIDsResponse) ProtoMessage() {} +func (*ListMacaroonIDsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{151} +} + +func (m *ListMacaroonIDsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListMacaroonIDsResponse.Unmarshal(m, b) +} +func (m *ListMacaroonIDsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListMacaroonIDsResponse.Marshal(b, m, deterministic) +} +func (m *ListMacaroonIDsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListMacaroonIDsResponse.Merge(m, src) +} +func (m *ListMacaroonIDsResponse) XXX_Size() int { + return xxx_messageInfo_ListMacaroonIDsResponse.Size(m) +} +func (m *ListMacaroonIDsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListMacaroonIDsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListMacaroonIDsResponse proto.InternalMessageInfo + +func (m *ListMacaroonIDsResponse) GetRootKeyIds() []uint64 { + if m != nil { + return m.RootKeyIds + } + return nil +} + +type DeleteMacaroonIDRequest struct { + // The root key ID to be removed. + RootKeyId uint64 `protobuf:"varint,1,opt,name=root_key_id,json=rootKeyId,proto3" json:"root_key_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteMacaroonIDRequest) Reset() { *m = DeleteMacaroonIDRequest{} } +func (m *DeleteMacaroonIDRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteMacaroonIDRequest) ProtoMessage() {} +func (*DeleteMacaroonIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{152} +} + +func (m *DeleteMacaroonIDRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteMacaroonIDRequest.Unmarshal(m, b) +} +func (m *DeleteMacaroonIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteMacaroonIDRequest.Marshal(b, m, deterministic) +} +func (m *DeleteMacaroonIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteMacaroonIDRequest.Merge(m, src) +} +func (m *DeleteMacaroonIDRequest) XXX_Size() int { + return xxx_messageInfo_DeleteMacaroonIDRequest.Size(m) +} +func (m *DeleteMacaroonIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteMacaroonIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteMacaroonIDRequest proto.InternalMessageInfo + +func (m *DeleteMacaroonIDRequest) GetRootKeyId() uint64 { + if m != nil { + return m.RootKeyId + } + return 0 +} + +type DeleteMacaroonIDResponse struct { + // A boolean indicates that the deletion is successful. + Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteMacaroonIDResponse) Reset() { *m = DeleteMacaroonIDResponse{} } +func (m *DeleteMacaroonIDResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteMacaroonIDResponse) ProtoMessage() {} +func (*DeleteMacaroonIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{153} +} + +func (m *DeleteMacaroonIDResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteMacaroonIDResponse.Unmarshal(m, b) +} +func (m *DeleteMacaroonIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteMacaroonIDResponse.Marshal(b, m, deterministic) +} +func (m *DeleteMacaroonIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteMacaroonIDResponse.Merge(m, src) +} +func (m *DeleteMacaroonIDResponse) XXX_Size() int { + return xxx_messageInfo_DeleteMacaroonIDResponse.Size(m) +} +func (m *DeleteMacaroonIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteMacaroonIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteMacaroonIDResponse proto.InternalMessageInfo + +func (m *DeleteMacaroonIDResponse) GetDeleted() bool { + if m != nil { + return m.Deleted + } + return false +} + +type MacaroonPermissionList struct { + // A list of macaroon permissions. + Permissions []*MacaroonPermission `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MacaroonPermissionList) Reset() { *m = MacaroonPermissionList{} } +func (m *MacaroonPermissionList) String() string { return proto.CompactTextString(m) } +func (*MacaroonPermissionList) ProtoMessage() {} +func (*MacaroonPermissionList) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{154} +} + +func (m *MacaroonPermissionList) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MacaroonPermissionList.Unmarshal(m, b) +} +func (m *MacaroonPermissionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MacaroonPermissionList.Marshal(b, m, deterministic) +} +func (m *MacaroonPermissionList) XXX_Merge(src proto.Message) { + xxx_messageInfo_MacaroonPermissionList.Merge(m, src) +} +func (m *MacaroonPermissionList) XXX_Size() int { + return xxx_messageInfo_MacaroonPermissionList.Size(m) +} +func (m *MacaroonPermissionList) XXX_DiscardUnknown() { + xxx_messageInfo_MacaroonPermissionList.DiscardUnknown(m) +} + +var xxx_messageInfo_MacaroonPermissionList proto.InternalMessageInfo + +func (m *MacaroonPermissionList) GetPermissions() []*MacaroonPermission { + if m != nil { + return m.Permissions + } + return nil +} + +type ListPermissionsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPermissionsRequest) Reset() { *m = ListPermissionsRequest{} } +func (m *ListPermissionsRequest) String() string { return proto.CompactTextString(m) } +func (*ListPermissionsRequest) ProtoMessage() {} +func (*ListPermissionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{155} +} + +func (m *ListPermissionsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPermissionsRequest.Unmarshal(m, b) +} +func (m *ListPermissionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPermissionsRequest.Marshal(b, m, deterministic) +} +func (m *ListPermissionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPermissionsRequest.Merge(m, src) +} +func (m *ListPermissionsRequest) XXX_Size() int { + return xxx_messageInfo_ListPermissionsRequest.Size(m) +} +func (m *ListPermissionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListPermissionsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPermissionsRequest proto.InternalMessageInfo + +type ListPermissionsResponse struct { + // + //A map between all RPC method URIs and their required macaroon permissions to + //access them. + MethodPermissions map[string]*MacaroonPermissionList `protobuf:"bytes,1,rep,name=method_permissions,json=methodPermissions,proto3" json:"method_permissions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListPermissionsResponse) Reset() { *m = ListPermissionsResponse{} } +func (m *ListPermissionsResponse) String() string { return proto.CompactTextString(m) } +func (*ListPermissionsResponse) ProtoMessage() {} +func (*ListPermissionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{156} +} + +func (m *ListPermissionsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListPermissionsResponse.Unmarshal(m, b) +} +func (m *ListPermissionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListPermissionsResponse.Marshal(b, m, deterministic) +} +func (m *ListPermissionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListPermissionsResponse.Merge(m, src) +} +func (m *ListPermissionsResponse) XXX_Size() int { + return xxx_messageInfo_ListPermissionsResponse.Size(m) +} +func (m *ListPermissionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListPermissionsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListPermissionsResponse proto.InternalMessageInfo + +func (m *ListPermissionsResponse) GetMethodPermissions() map[string]*MacaroonPermissionList { + if m != nil { + return m.MethodPermissions + } + return nil +} + +type Failure struct { + // Failure code as defined in the Lightning spec + Code Failure_FailureCode `protobuf:"varint,1,opt,name=code,proto3,enum=lnrpc.Failure_FailureCode" json:"code,omitempty"` + // An optional channel update message. + ChannelUpdate *ChannelUpdate `protobuf:"bytes,3,opt,name=channel_update,json=channelUpdate,proto3" json:"channel_update,omitempty"` + // A failure type-dependent htlc value. + HtlcMsat uint64 `protobuf:"varint,4,opt,name=htlc_msat,json=htlcMsat,proto3" json:"htlc_msat,omitempty"` + // The sha256 sum of the onion payload. + OnionSha_256 []byte `protobuf:"bytes,5,opt,name=onion_sha_256,json=onionSha256,proto3" json:"onion_sha_256,omitempty"` + // A failure type-dependent cltv expiry value. + CltvExpiry uint32 `protobuf:"varint,6,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` + // A failure type-dependent flags value. + Flags uint32 `protobuf:"varint,7,opt,name=flags,proto3" json:"flags,omitempty"` + // + //The position in the path of the intermediate or final node that generated + //the failure message. Position zero is the sender node. + FailureSourceIndex uint32 `protobuf:"varint,8,opt,name=failure_source_index,json=failureSourceIndex,proto3" json:"failure_source_index,omitempty"` + // A failure type-dependent block height. + Height uint32 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Failure) Reset() { *m = Failure{} } +func (m *Failure) String() string { return proto.CompactTextString(m) } +func (*Failure) ProtoMessage() {} +func (*Failure) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{157} +} + +func (m *Failure) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Failure.Unmarshal(m, b) +} +func (m *Failure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Failure.Marshal(b, m, deterministic) +} +func (m *Failure) XXX_Merge(src proto.Message) { + xxx_messageInfo_Failure.Merge(m, src) +} +func (m *Failure) XXX_Size() int { + return xxx_messageInfo_Failure.Size(m) +} +func (m *Failure) XXX_DiscardUnknown() { + xxx_messageInfo_Failure.DiscardUnknown(m) +} + +var xxx_messageInfo_Failure proto.InternalMessageInfo + +func (m *Failure) GetCode() Failure_FailureCode { + if m != nil { + return m.Code + } + return Failure_RESERVED +} + +func (m *Failure) GetChannelUpdate() *ChannelUpdate { + if m != nil { + return m.ChannelUpdate + } + return nil +} + +func (m *Failure) GetHtlcMsat() uint64 { + if m != nil { + return m.HtlcMsat + } + return 0 +} + +func (m *Failure) GetOnionSha_256() []byte { + if m != nil { + return m.OnionSha_256 + } + return nil +} + +func (m *Failure) GetCltvExpiry() uint32 { + if m != nil { + return m.CltvExpiry + } + return 0 +} + +func (m *Failure) GetFlags() uint32 { + if m != nil { + return m.Flags + } + return 0 +} + +func (m *Failure) GetFailureSourceIndex() uint32 { + if m != nil { + return m.FailureSourceIndex + } + return 0 +} + +func (m *Failure) GetHeight() uint32 { + if m != nil { + return m.Height + } + return 0 +} + +type ChannelUpdate struct { + // + //The signature that validates the announced data and proves the ownership + //of node id. + Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` + // + //The target chain that this channel was opened within. This value + //should be the genesis hash of the target chain. Along with the short + //channel ID, this uniquely identifies the channel globally in a + //blockchain. + ChainHash []byte `protobuf:"bytes,2,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` + // + //The unique description of the funding transaction. + ChanId uint64 `protobuf:"varint,3,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` + // + //A timestamp that allows ordering in the case of multiple announcements. + //We should ignore the message if timestamp is not greater than the + //last-received. + Timestamp uint32 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // + //The bitfield that describes whether optional fields are present in this + //update. Currently, the least-significant bit must be set to 1 if the + //optional field MaxHtlc is present. + MessageFlags uint32 `protobuf:"varint,10,opt,name=message_flags,json=messageFlags,proto3" json:"message_flags,omitempty"` + // + //The bitfield that describes additional meta-data concerning how the + //update is to be interpreted. Currently, the least-significant bit must be + //set to 0 if the creating node corresponds to the first node in the + //previously sent channel announcement and 1 otherwise. If the second bit + //is set, then the channel is set to be disabled. + ChannelFlags uint32 `protobuf:"varint,5,opt,name=channel_flags,json=channelFlags,proto3" json:"channel_flags,omitempty"` + // + //The minimum number of blocks this node requires to be added to the expiry + //of HTLCs. This is a security parameter determined by the node operator. + //This value represents the required gap between the time locks of the + //incoming and outgoing HTLC's set to this node. + TimeLockDelta uint32 `protobuf:"varint,6,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` + // + //The minimum HTLC value which will be accepted. + HtlcMinimumMsat uint64 `protobuf:"varint,7,opt,name=htlc_minimum_msat,json=htlcMinimumMsat,proto3" json:"htlc_minimum_msat,omitempty"` + // + //The base fee that must be used for incoming HTLC's to this particular + //channel. This value will be tacked onto the required for a payment + //independent of the size of the payment. + BaseFee uint32 `protobuf:"varint,8,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"` + // + //The fee rate that will be charged per millionth of a satoshi. + FeeRate uint32 `protobuf:"varint,9,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` + // + //The maximum HTLC value which will be accepted. + HtlcMaximumMsat uint64 `protobuf:"varint,11,opt,name=htlc_maximum_msat,json=htlcMaximumMsat,proto3" json:"htlc_maximum_msat,omitempty"` + // + //The set of data that was appended to this message, some of which we may + //not actually know how to iterate or parse. By holding onto this data, we + //ensure that we're able to properly validate the set of signatures that + //cover these new fields, and ensure we're able to make upgrades to the + //network in a forwards compatible manner. + ExtraOpaqueData []byte `protobuf:"bytes,12,opt,name=extra_opaque_data,json=extraOpaqueData,proto3" json:"extra_opaque_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ChannelUpdate) Reset() { *m = ChannelUpdate{} } +func (m *ChannelUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelUpdate) ProtoMessage() {} +func (*ChannelUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{158} +} + +func (m *ChannelUpdate) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ChannelUpdate.Unmarshal(m, b) +} +func (m *ChannelUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ChannelUpdate.Marshal(b, m, deterministic) +} +func (m *ChannelUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChannelUpdate.Merge(m, src) +} +func (m *ChannelUpdate) XXX_Size() int { + return xxx_messageInfo_ChannelUpdate.Size(m) +} +func (m *ChannelUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_ChannelUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_ChannelUpdate proto.InternalMessageInfo + +func (m *ChannelUpdate) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +func (m *ChannelUpdate) GetChainHash() []byte { + if m != nil { + return m.ChainHash + } + return nil +} + +func (m *ChannelUpdate) GetChanId() uint64 { + if m != nil { + return m.ChanId + } + return 0 +} + +func (m *ChannelUpdate) GetTimestamp() uint32 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *ChannelUpdate) GetMessageFlags() uint32 { + if m != nil { + return m.MessageFlags + } + return 0 +} + +func (m *ChannelUpdate) GetChannelFlags() uint32 { + if m != nil { + return m.ChannelFlags + } + return 0 +} + +func (m *ChannelUpdate) GetTimeLockDelta() uint32 { + if m != nil { + return m.TimeLockDelta + } + return 0 +} + +func (m *ChannelUpdate) GetHtlcMinimumMsat() uint64 { + if m != nil { + return m.HtlcMinimumMsat + } + return 0 +} + +func (m *ChannelUpdate) GetBaseFee() uint32 { + if m != nil { + return m.BaseFee + } + return 0 +} + +func (m *ChannelUpdate) GetFeeRate() uint32 { + if m != nil { + return m.FeeRate + } + return 0 +} + +func (m *ChannelUpdate) GetHtlcMaximumMsat() uint64 { + if m != nil { + return m.HtlcMaximumMsat + } + return 0 +} + +func (m *ChannelUpdate) GetExtraOpaqueData() []byte { + if m != nil { + return m.ExtraOpaqueData + } + return nil +} + +type MacaroonId struct { + Nonce []byte `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"` + StorageId []byte `protobuf:"bytes,2,opt,name=storageId,proto3" json:"storageId,omitempty"` + Ops []*Op `protobuf:"bytes,3,rep,name=ops,proto3" json:"ops,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MacaroonId) Reset() { *m = MacaroonId{} } +func (m *MacaroonId) String() string { return proto.CompactTextString(m) } +func (*MacaroonId) ProtoMessage() {} +func (*MacaroonId) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{159} +} + +func (m *MacaroonId) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MacaroonId.Unmarshal(m, b) +} +func (m *MacaroonId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MacaroonId.Marshal(b, m, deterministic) +} +func (m *MacaroonId) XXX_Merge(src proto.Message) { + xxx_messageInfo_MacaroonId.Merge(m, src) +} +func (m *MacaroonId) XXX_Size() int { + return xxx_messageInfo_MacaroonId.Size(m) +} +func (m *MacaroonId) XXX_DiscardUnknown() { + xxx_messageInfo_MacaroonId.DiscardUnknown(m) +} + +var xxx_messageInfo_MacaroonId proto.InternalMessageInfo + +func (m *MacaroonId) GetNonce() []byte { + if m != nil { + return m.Nonce + } + return nil +} + +func (m *MacaroonId) GetStorageId() []byte { + if m != nil { + return m.StorageId + } + return nil +} + +func (m *MacaroonId) GetOps() []*Op { + if m != nil { + return m.Ops + } + return nil +} + +type Op struct { + Entity string `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` + Actions []string `protobuf:"bytes,2,rep,name=actions,proto3" json:"actions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Op) Reset() { *m = Op{} } +func (m *Op) String() string { return proto.CompactTextString(m) } +func (*Op) ProtoMessage() {} +func (*Op) Descriptor() ([]byte, []int) { + return fileDescriptor_77a6da22d6a3feb1, []int{160} +} + +func (m *Op) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Op.Unmarshal(m, b) +} +func (m *Op) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Op.Marshal(b, m, deterministic) +} +func (m *Op) XXX_Merge(src proto.Message) { + xxx_messageInfo_Op.Merge(m, src) +} +func (m *Op) XXX_Size() int { + return xxx_messageInfo_Op.Size(m) +} +func (m *Op) XXX_DiscardUnknown() { + xxx_messageInfo_Op.DiscardUnknown(m) +} + +var xxx_messageInfo_Op proto.InternalMessageInfo + +func (m *Op) GetEntity() string { + if m != nil { + return m.Entity + } + return "" +} + +func (m *Op) GetActions() []string { + if m != nil { + return m.Actions + } + return nil +} + +func init() { + proto.RegisterEnum("lnrpc.AddressType", AddressType_name, AddressType_value) + proto.RegisterEnum("lnrpc.CommitmentType", CommitmentType_name, CommitmentType_value) + proto.RegisterEnum("lnrpc.Initiator", Initiator_name, Initiator_value) + proto.RegisterEnum("lnrpc.ResolutionType", ResolutionType_name, ResolutionType_value) + proto.RegisterEnum("lnrpc.ResolutionOutcome", ResolutionOutcome_name, ResolutionOutcome_value) + proto.RegisterEnum("lnrpc.NodeMetricType", NodeMetricType_name, NodeMetricType_value) + proto.RegisterEnum("lnrpc.InvoiceHTLCState", InvoiceHTLCState_name, InvoiceHTLCState_value) + proto.RegisterEnum("lnrpc.PaymentFailureReason", PaymentFailureReason_name, PaymentFailureReason_value) + proto.RegisterEnum("lnrpc.FeatureBit", FeatureBit_name, FeatureBit_value) + proto.RegisterEnum("lnrpc.ChannelCloseSummary_ClosureType", ChannelCloseSummary_ClosureType_name, ChannelCloseSummary_ClosureType_value) + proto.RegisterEnum("lnrpc.Peer_SyncType", Peer_SyncType_name, Peer_SyncType_value) + proto.RegisterEnum("lnrpc.PeerEvent_EventType", PeerEvent_EventType_name, PeerEvent_EventType_value) + proto.RegisterEnum("lnrpc.PendingChannelsResponse_ForceClosedChannel_AnchorState", PendingChannelsResponse_ForceClosedChannel_AnchorState_name, PendingChannelsResponse_ForceClosedChannel_AnchorState_value) + proto.RegisterEnum("lnrpc.ChannelEventUpdate_UpdateType", ChannelEventUpdate_UpdateType_name, ChannelEventUpdate_UpdateType_value) + proto.RegisterEnum("lnrpc.Invoice_InvoiceState", Invoice_InvoiceState_name, Invoice_InvoiceState_value) + proto.RegisterEnum("lnrpc.Payment_PaymentStatus", Payment_PaymentStatus_name, Payment_PaymentStatus_value) + proto.RegisterEnum("lnrpc.HTLCAttempt_HTLCStatus", HTLCAttempt_HTLCStatus_name, HTLCAttempt_HTLCStatus_value) + proto.RegisterEnum("lnrpc.Failure_FailureCode", Failure_FailureCode_name, Failure_FailureCode_value) + proto.RegisterType((*Utxo)(nil), "lnrpc.Utxo") + proto.RegisterType((*Transaction)(nil), "lnrpc.Transaction") + proto.RegisterType((*GetTransactionsRequest)(nil), "lnrpc.GetTransactionsRequest") + proto.RegisterType((*TransactionDetails)(nil), "lnrpc.TransactionDetails") + proto.RegisterType((*FeeLimit)(nil), "lnrpc.FeeLimit") + proto.RegisterType((*SendRequest)(nil), "lnrpc.SendRequest") + proto.RegisterMapType((map[uint64][]byte)(nil), "lnrpc.SendRequest.DestCustomRecordsEntry") + proto.RegisterType((*SendResponse)(nil), "lnrpc.SendResponse") + proto.RegisterType((*SendToRouteRequest)(nil), "lnrpc.SendToRouteRequest") + proto.RegisterType((*ChannelAcceptRequest)(nil), "lnrpc.ChannelAcceptRequest") + proto.RegisterType((*ChannelAcceptResponse)(nil), "lnrpc.ChannelAcceptResponse") + proto.RegisterType((*ChannelPoint)(nil), "lnrpc.ChannelPoint") + proto.RegisterType((*OutPoint)(nil), "lnrpc.OutPoint") + proto.RegisterType((*LightningAddress)(nil), "lnrpc.LightningAddress") + proto.RegisterType((*EstimateFeeRequest)(nil), "lnrpc.EstimateFeeRequest") + proto.RegisterMapType((map[string]int64)(nil), "lnrpc.EstimateFeeRequest.AddrToAmountEntry") + proto.RegisterType((*EstimateFeeResponse)(nil), "lnrpc.EstimateFeeResponse") + proto.RegisterType((*SendManyRequest)(nil), "lnrpc.SendManyRequest") + proto.RegisterMapType((map[string]int64)(nil), "lnrpc.SendManyRequest.AddrToAmountEntry") + proto.RegisterType((*SendManyResponse)(nil), "lnrpc.SendManyResponse") + proto.RegisterType((*SendCoinsRequest)(nil), "lnrpc.SendCoinsRequest") + proto.RegisterType((*SendCoinsResponse)(nil), "lnrpc.SendCoinsResponse") + proto.RegisterType((*ListUnspentRequest)(nil), "lnrpc.ListUnspentRequest") + proto.RegisterType((*ListUnspentResponse)(nil), "lnrpc.ListUnspentResponse") + proto.RegisterType((*NewAddressRequest)(nil), "lnrpc.NewAddressRequest") + proto.RegisterType((*NewAddressResponse)(nil), "lnrpc.NewAddressResponse") + proto.RegisterType((*SignMessageRequest)(nil), "lnrpc.SignMessageRequest") + proto.RegisterType((*SignMessageResponse)(nil), "lnrpc.SignMessageResponse") + proto.RegisterType((*VerifyMessageRequest)(nil), "lnrpc.VerifyMessageRequest") + proto.RegisterType((*VerifyMessageResponse)(nil), "lnrpc.VerifyMessageResponse") + proto.RegisterType((*ConnectPeerRequest)(nil), "lnrpc.ConnectPeerRequest") + proto.RegisterType((*ConnectPeerResponse)(nil), "lnrpc.ConnectPeerResponse") + proto.RegisterType((*DisconnectPeerRequest)(nil), "lnrpc.DisconnectPeerRequest") + proto.RegisterType((*DisconnectPeerResponse)(nil), "lnrpc.DisconnectPeerResponse") + proto.RegisterType((*HTLC)(nil), "lnrpc.HTLC") + proto.RegisterType((*ChannelConstraints)(nil), "lnrpc.ChannelConstraints") + proto.RegisterType((*Channel)(nil), "lnrpc.Channel") + proto.RegisterType((*ListChannelsRequest)(nil), "lnrpc.ListChannelsRequest") + proto.RegisterType((*ListChannelsResponse)(nil), "lnrpc.ListChannelsResponse") + proto.RegisterType((*ChannelCloseSummary)(nil), "lnrpc.ChannelCloseSummary") + proto.RegisterType((*Resolution)(nil), "lnrpc.Resolution") + proto.RegisterType((*ClosedChannelsRequest)(nil), "lnrpc.ClosedChannelsRequest") + proto.RegisterType((*ClosedChannelsResponse)(nil), "lnrpc.ClosedChannelsResponse") + proto.RegisterType((*Peer)(nil), "lnrpc.Peer") + proto.RegisterMapType((map[uint32]*Feature)(nil), "lnrpc.Peer.FeaturesEntry") + proto.RegisterType((*TimestampedError)(nil), "lnrpc.TimestampedError") + proto.RegisterType((*ListPeersRequest)(nil), "lnrpc.ListPeersRequest") + proto.RegisterType((*ListPeersResponse)(nil), "lnrpc.ListPeersResponse") + proto.RegisterType((*PeerEventSubscription)(nil), "lnrpc.PeerEventSubscription") + proto.RegisterType((*PeerEvent)(nil), "lnrpc.PeerEvent") + proto.RegisterType((*GetInfoRequest)(nil), "lnrpc.GetInfoRequest") + proto.RegisterType((*GetInfoResponse)(nil), "lnrpc.GetInfoResponse") + proto.RegisterMapType((map[uint32]*Feature)(nil), "lnrpc.GetInfoResponse.FeaturesEntry") + proto.RegisterType((*GetRecoveryInfoRequest)(nil), "lnrpc.GetRecoveryInfoRequest") + proto.RegisterType((*GetRecoveryInfoResponse)(nil), "lnrpc.GetRecoveryInfoResponse") + proto.RegisterType((*Chain)(nil), "lnrpc.Chain") + proto.RegisterType((*ConfirmationUpdate)(nil), "lnrpc.ConfirmationUpdate") + proto.RegisterType((*ChannelOpenUpdate)(nil), "lnrpc.ChannelOpenUpdate") + proto.RegisterType((*ChannelCloseUpdate)(nil), "lnrpc.ChannelCloseUpdate") + proto.RegisterType((*CloseChannelRequest)(nil), "lnrpc.CloseChannelRequest") + proto.RegisterType((*CloseStatusUpdate)(nil), "lnrpc.CloseStatusUpdate") + proto.RegisterType((*PendingUpdate)(nil), "lnrpc.PendingUpdate") + proto.RegisterType((*ReadyForPsbtFunding)(nil), "lnrpc.ReadyForPsbtFunding") + proto.RegisterType((*OpenChannelRequest)(nil), "lnrpc.OpenChannelRequest") + proto.RegisterType((*OpenStatusUpdate)(nil), "lnrpc.OpenStatusUpdate") + proto.RegisterType((*KeyLocator)(nil), "lnrpc.KeyLocator") + proto.RegisterType((*KeyDescriptor)(nil), "lnrpc.KeyDescriptor") + proto.RegisterType((*ChanPointShim)(nil), "lnrpc.ChanPointShim") + proto.RegisterType((*PsbtShim)(nil), "lnrpc.PsbtShim") + proto.RegisterType((*FundingShim)(nil), "lnrpc.FundingShim") + proto.RegisterType((*FundingShimCancel)(nil), "lnrpc.FundingShimCancel") + proto.RegisterType((*FundingPsbtVerify)(nil), "lnrpc.FundingPsbtVerify") + proto.RegisterType((*FundingPsbtFinalize)(nil), "lnrpc.FundingPsbtFinalize") + proto.RegisterType((*FundingTransitionMsg)(nil), "lnrpc.FundingTransitionMsg") + proto.RegisterType((*FundingStateStepResp)(nil), "lnrpc.FundingStateStepResp") + proto.RegisterType((*PendingHTLC)(nil), "lnrpc.PendingHTLC") + proto.RegisterType((*PendingChannelsRequest)(nil), "lnrpc.PendingChannelsRequest") + proto.RegisterType((*PendingChannelsResponse)(nil), "lnrpc.PendingChannelsResponse") + proto.RegisterType((*PendingChannelsResponse_PendingChannel)(nil), "lnrpc.PendingChannelsResponse.PendingChannel") + proto.RegisterType((*PendingChannelsResponse_PendingOpenChannel)(nil), "lnrpc.PendingChannelsResponse.PendingOpenChannel") + proto.RegisterType((*PendingChannelsResponse_WaitingCloseChannel)(nil), "lnrpc.PendingChannelsResponse.WaitingCloseChannel") + proto.RegisterType((*PendingChannelsResponse_Commitments)(nil), "lnrpc.PendingChannelsResponse.Commitments") + proto.RegisterType((*PendingChannelsResponse_ClosedChannel)(nil), "lnrpc.PendingChannelsResponse.ClosedChannel") + proto.RegisterType((*PendingChannelsResponse_ForceClosedChannel)(nil), "lnrpc.PendingChannelsResponse.ForceClosedChannel") + proto.RegisterType((*ChannelEventSubscription)(nil), "lnrpc.ChannelEventSubscription") + proto.RegisterType((*ChannelEventUpdate)(nil), "lnrpc.ChannelEventUpdate") + proto.RegisterType((*WalletBalanceRequest)(nil), "lnrpc.WalletBalanceRequest") + proto.RegisterType((*WalletBalanceResponse)(nil), "lnrpc.WalletBalanceResponse") + proto.RegisterType((*ChannelBalanceRequest)(nil), "lnrpc.ChannelBalanceRequest") + proto.RegisterType((*ChannelBalanceResponse)(nil), "lnrpc.ChannelBalanceResponse") + proto.RegisterType((*QueryRoutesRequest)(nil), "lnrpc.QueryRoutesRequest") + proto.RegisterMapType((map[uint64][]byte)(nil), "lnrpc.QueryRoutesRequest.DestCustomRecordsEntry") + proto.RegisterType((*NodePair)(nil), "lnrpc.NodePair") + proto.RegisterType((*EdgeLocator)(nil), "lnrpc.EdgeLocator") + proto.RegisterType((*QueryRoutesResponse)(nil), "lnrpc.QueryRoutesResponse") + proto.RegisterType((*Hop)(nil), "lnrpc.Hop") + proto.RegisterMapType((map[uint64][]byte)(nil), "lnrpc.Hop.CustomRecordsEntry") + proto.RegisterType((*MPPRecord)(nil), "lnrpc.MPPRecord") + proto.RegisterType((*Route)(nil), "lnrpc.Route") + proto.RegisterType((*NodeInfoRequest)(nil), "lnrpc.NodeInfoRequest") + proto.RegisterType((*NodeInfo)(nil), "lnrpc.NodeInfo") + proto.RegisterType((*LightningNode)(nil), "lnrpc.LightningNode") + proto.RegisterMapType((map[uint32]*Feature)(nil), "lnrpc.LightningNode.FeaturesEntry") + proto.RegisterType((*NodeAddress)(nil), "lnrpc.NodeAddress") + proto.RegisterType((*RoutingPolicy)(nil), "lnrpc.RoutingPolicy") + proto.RegisterType((*ChannelEdge)(nil), "lnrpc.ChannelEdge") + proto.RegisterType((*ChannelGraphRequest)(nil), "lnrpc.ChannelGraphRequest") + proto.RegisterType((*ChannelGraph)(nil), "lnrpc.ChannelGraph") + proto.RegisterType((*NodeMetricsRequest)(nil), "lnrpc.NodeMetricsRequest") + proto.RegisterType((*NodeMetricsResponse)(nil), "lnrpc.NodeMetricsResponse") + proto.RegisterMapType((map[string]*FloatMetric)(nil), "lnrpc.NodeMetricsResponse.BetweennessCentralityEntry") + proto.RegisterType((*FloatMetric)(nil), "lnrpc.FloatMetric") + proto.RegisterType((*ChanInfoRequest)(nil), "lnrpc.ChanInfoRequest") + proto.RegisterType((*NetworkInfoRequest)(nil), "lnrpc.NetworkInfoRequest") + proto.RegisterType((*NetworkInfo)(nil), "lnrpc.NetworkInfo") + proto.RegisterType((*StopRequest)(nil), "lnrpc.StopRequest") + proto.RegisterType((*StopResponse)(nil), "lnrpc.StopResponse") + proto.RegisterType((*GraphTopologySubscription)(nil), "lnrpc.GraphTopologySubscription") + proto.RegisterType((*GraphTopologyUpdate)(nil), "lnrpc.GraphTopologyUpdate") + proto.RegisterType((*NodeUpdate)(nil), "lnrpc.NodeUpdate") + proto.RegisterType((*ChannelEdgeUpdate)(nil), "lnrpc.ChannelEdgeUpdate") + proto.RegisterType((*ClosedChannelUpdate)(nil), "lnrpc.ClosedChannelUpdate") + proto.RegisterType((*HopHint)(nil), "lnrpc.HopHint") + proto.RegisterType((*RouteHint)(nil), "lnrpc.RouteHint") + proto.RegisterType((*Invoice)(nil), "lnrpc.Invoice") + proto.RegisterMapType((map[uint32]*Feature)(nil), "lnrpc.Invoice.FeaturesEntry") + proto.RegisterType((*InvoiceHTLC)(nil), "lnrpc.InvoiceHTLC") + proto.RegisterMapType((map[uint64][]byte)(nil), "lnrpc.InvoiceHTLC.CustomRecordsEntry") + proto.RegisterType((*AddInvoiceResponse)(nil), "lnrpc.AddInvoiceResponse") + proto.RegisterType((*PaymentHash)(nil), "lnrpc.PaymentHash") + proto.RegisterType((*ListInvoiceRequest)(nil), "lnrpc.ListInvoiceRequest") + proto.RegisterType((*ListInvoiceResponse)(nil), "lnrpc.ListInvoiceResponse") + proto.RegisterType((*InvoiceSubscription)(nil), "lnrpc.InvoiceSubscription") + proto.RegisterType((*Payment)(nil), "lnrpc.Payment") + proto.RegisterType((*HTLCAttempt)(nil), "lnrpc.HTLCAttempt") + proto.RegisterType((*ListPaymentsRequest)(nil), "lnrpc.ListPaymentsRequest") + proto.RegisterType((*ListPaymentsResponse)(nil), "lnrpc.ListPaymentsResponse") + proto.RegisterType((*DeleteAllPaymentsRequest)(nil), "lnrpc.DeleteAllPaymentsRequest") + proto.RegisterType((*DeleteAllPaymentsResponse)(nil), "lnrpc.DeleteAllPaymentsResponse") + proto.RegisterType((*AbandonChannelRequest)(nil), "lnrpc.AbandonChannelRequest") + proto.RegisterType((*AbandonChannelResponse)(nil), "lnrpc.AbandonChannelResponse") + proto.RegisterType((*DebugLevelRequest)(nil), "lnrpc.DebugLevelRequest") + proto.RegisterType((*DebugLevelResponse)(nil), "lnrpc.DebugLevelResponse") + proto.RegisterType((*PayReqString)(nil), "lnrpc.PayReqString") + proto.RegisterType((*PayReq)(nil), "lnrpc.PayReq") + proto.RegisterMapType((map[uint32]*Feature)(nil), "lnrpc.PayReq.FeaturesEntry") + proto.RegisterType((*Feature)(nil), "lnrpc.Feature") + proto.RegisterType((*FeeReportRequest)(nil), "lnrpc.FeeReportRequest") + proto.RegisterType((*ChannelFeeReport)(nil), "lnrpc.ChannelFeeReport") + proto.RegisterType((*FeeReportResponse)(nil), "lnrpc.FeeReportResponse") + proto.RegisterType((*PolicyUpdateRequest)(nil), "lnrpc.PolicyUpdateRequest") + proto.RegisterType((*PolicyUpdateResponse)(nil), "lnrpc.PolicyUpdateResponse") + proto.RegisterType((*ForwardingHistoryRequest)(nil), "lnrpc.ForwardingHistoryRequest") + proto.RegisterType((*ForwardingEvent)(nil), "lnrpc.ForwardingEvent") + proto.RegisterType((*ForwardingHistoryResponse)(nil), "lnrpc.ForwardingHistoryResponse") + proto.RegisterType((*ExportChannelBackupRequest)(nil), "lnrpc.ExportChannelBackupRequest") + proto.RegisterType((*ChannelBackup)(nil), "lnrpc.ChannelBackup") + proto.RegisterType((*MultiChanBackup)(nil), "lnrpc.MultiChanBackup") + proto.RegisterType((*ChanBackupExportRequest)(nil), "lnrpc.ChanBackupExportRequest") + proto.RegisterType((*ChanBackupSnapshot)(nil), "lnrpc.ChanBackupSnapshot") + proto.RegisterType((*ChannelBackups)(nil), "lnrpc.ChannelBackups") + proto.RegisterType((*RestoreChanBackupRequest)(nil), "lnrpc.RestoreChanBackupRequest") + proto.RegisterType((*RestoreBackupResponse)(nil), "lnrpc.RestoreBackupResponse") + proto.RegisterType((*ChannelBackupSubscription)(nil), "lnrpc.ChannelBackupSubscription") + proto.RegisterType((*VerifyChanBackupResponse)(nil), "lnrpc.VerifyChanBackupResponse") + proto.RegisterType((*MacaroonPermission)(nil), "lnrpc.MacaroonPermission") + proto.RegisterType((*BakeMacaroonRequest)(nil), "lnrpc.BakeMacaroonRequest") + proto.RegisterType((*BakeMacaroonResponse)(nil), "lnrpc.BakeMacaroonResponse") + proto.RegisterType((*ListMacaroonIDsRequest)(nil), "lnrpc.ListMacaroonIDsRequest") + proto.RegisterType((*ListMacaroonIDsResponse)(nil), "lnrpc.ListMacaroonIDsResponse") + proto.RegisterType((*DeleteMacaroonIDRequest)(nil), "lnrpc.DeleteMacaroonIDRequest") + proto.RegisterType((*DeleteMacaroonIDResponse)(nil), "lnrpc.DeleteMacaroonIDResponse") + proto.RegisterType((*MacaroonPermissionList)(nil), "lnrpc.MacaroonPermissionList") + proto.RegisterType((*ListPermissionsRequest)(nil), "lnrpc.ListPermissionsRequest") + proto.RegisterType((*ListPermissionsResponse)(nil), "lnrpc.ListPermissionsResponse") + proto.RegisterMapType((map[string]*MacaroonPermissionList)(nil), "lnrpc.ListPermissionsResponse.MethodPermissionsEntry") + proto.RegisterType((*Failure)(nil), "lnrpc.Failure") + proto.RegisterType((*ChannelUpdate)(nil), "lnrpc.ChannelUpdate") + proto.RegisterType((*MacaroonId)(nil), "lnrpc.MacaroonId") + proto.RegisterType((*Op)(nil), "lnrpc.Op") +} + +func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) } + +var fileDescriptor_77a6da22d6a3feb1 = []byte{ + // 11995 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x5b, 0x6c, 0x23, 0x49, + 0x96, 0x18, 0x5a, 0x7c, 0x89, 0xe4, 0x21, 0x29, 0x51, 0xa1, 0x17, 0x4b, 0xd5, 0xd5, 0x55, 0x9d, + 0xdd, 0xd3, 0x5d, 0x53, 0xdd, 0x53, 0x5d, 0x5d, 0xdd, 0xd5, 0x8f, 0xe9, 0xbb, 0x33, 0x43, 0x51, + 0x54, 0x89, 0x53, 0x12, 0xa9, 0x49, 0x52, 0xdd, 0xdb, 0x8b, 0xdd, 0xcd, 0x4d, 0x91, 0x21, 0x29, + 0x6f, 0x91, 0x99, 0xec, 0xcc, 0xa4, 0x4a, 0x9a, 0x8b, 0x0b, 0xdc, 0x8f, 0xbd, 0xb6, 0xb1, 0x58, + 0x18, 0x30, 0xe0, 0x35, 0xe0, 0xc7, 0xc2, 0x2f, 0xd8, 0xfe, 0x5b, 0x18, 0xde, 0xb5, 0xbf, 0xfc, + 0xed, 0x85, 0x01, 0x3f, 0x60, 0x78, 0x0d, 0x3f, 0xb0, 0x58, 0xc0, 0x80, 0xbd, 0xfe, 0x30, 0x60, + 0x2c, 0x60, 0xff, 0xf8, 0xc3, 0x80, 0x11, 0x27, 0x1e, 0x19, 0xf9, 0x50, 0x55, 0xf5, 0x6c, 0x7b, + 0x7e, 0x24, 0xc6, 0x39, 0x27, 0xde, 0x11, 0x27, 0xce, 0x2b, 0x22, 0xa1, 0xea, 0xcf, 0xc7, 0x0f, + 0xe6, 0xbe, 0x17, 0x7a, 0xa4, 0x34, 0x75, 0xfd, 0xf9, 0xd8, 0xf8, 0xe3, 0x1c, 0x14, 0x8f, 0xc3, + 0x4b, 0x8f, 0x3c, 0x86, 0xba, 0x3d, 0x99, 0xf8, 0x34, 0x08, 0xac, 0xf0, 0x6a, 0x4e, 0x5b, 0xb9, + 0xbb, 0xb9, 0x7b, 0xcb, 0x8f, 0xc8, 0x03, 0x24, 0x7b, 0xd0, 0xe6, 0xa8, 0xd1, 0xd5, 0x9c, 0x9a, + 0x35, 0x3b, 0x4a, 0x90, 0x16, 0x94, 0x45, 0xb2, 0x95, 0xbf, 0x9b, 0xbb, 0x57, 0x35, 0x65, 0x92, + 0xdc, 0x06, 0xb0, 0x67, 0xde, 0xc2, 0x0d, 0xad, 0xc0, 0x0e, 0x5b, 0x85, 0xbb, 0xb9, 0x7b, 0x05, + 0xb3, 0xca, 0x21, 0x43, 0x3b, 0x24, 0xb7, 0xa0, 0x3a, 0x7f, 0x66, 0x05, 0x63, 0xdf, 0x99, 0x87, + 0xad, 0x22, 0x66, 0xad, 0xcc, 0x9f, 0x0d, 0x31, 0x4d, 0xde, 0x85, 0x8a, 0xb7, 0x08, 0xe7, 0x9e, + 0xe3, 0x86, 0xad, 0xd2, 0xdd, 0xdc, 0xbd, 0xda, 0xa3, 0x15, 0xd1, 0x90, 0xc1, 0x22, 0x3c, 0x62, + 0x60, 0x53, 0x11, 0x90, 0xb7, 0xa0, 0x31, 0xf6, 0xdc, 0x53, 0xc7, 0x9f, 0xd9, 0xa1, 0xe3, 0xb9, + 0x41, 0x6b, 0x09, 0xeb, 0x8a, 0x03, 0x8d, 0x7f, 0x92, 0x87, 0xda, 0xc8, 0xb7, 0xdd, 0xc0, 0x1e, + 0x33, 0x00, 0xd9, 0x82, 0x72, 0x78, 0x69, 0x9d, 0xdb, 0xc1, 0x39, 0x76, 0xb5, 0x6a, 0x2e, 0x85, + 0x97, 0xfb, 0x76, 0x70, 0x4e, 0x36, 0x61, 0x89, 0xb7, 0x12, 0x3b, 0x54, 0x30, 0x45, 0x8a, 0xbc, + 0x0b, 0xab, 0xee, 0x62, 0x66, 0xc5, 0xab, 0x62, 0xdd, 0x2a, 0x99, 0x4d, 0x77, 0x31, 0xeb, 0xe8, + 0x70, 0xd6, 0xf9, 0x93, 0xa9, 0x37, 0x7e, 0xc6, 0x2b, 0xe0, 0xdd, 0xab, 0x22, 0x04, 0xeb, 0x78, + 0x03, 0xea, 0x02, 0x4d, 0x9d, 0xb3, 0x73, 0xde, 0xc7, 0x92, 0x59, 0xe3, 0x04, 0x08, 0x62, 0x25, + 0x84, 0xce, 0x8c, 0x5a, 0x41, 0x68, 0xcf, 0xe6, 0xa2, 0x4b, 0x55, 0x06, 0x19, 0x32, 0x00, 0xa2, + 0xbd, 0xd0, 0x9e, 0x5a, 0xa7, 0x94, 0x06, 0xad, 0xb2, 0x40, 0x33, 0xc8, 0x1e, 0xa5, 0x01, 0xf9, + 0x0e, 0x2c, 0x4f, 0x68, 0x10, 0x5a, 0x62, 0x32, 0x68, 0xd0, 0xaa, 0xdc, 0x2d, 0xdc, 0xab, 0x9a, + 0x0d, 0x06, 0x6d, 0x4b, 0x20, 0x79, 0x0d, 0xc0, 0xb7, 0x9f, 0x5b, 0x6c, 0x20, 0xe8, 0x65, 0xab, + 0xca, 0x67, 0xc1, 0xb7, 0x9f, 0x8f, 0x2e, 0xf7, 0xe9, 0x25, 0x59, 0x87, 0xd2, 0xd4, 0x3e, 0xa1, + 0xd3, 0x16, 0x20, 0x82, 0x27, 0x8c, 0x5f, 0x82, 0xcd, 0x27, 0x34, 0xd4, 0x86, 0x32, 0x30, 0xe9, + 0xd7, 0x0b, 0x1a, 0x84, 0xac, 0x57, 0x41, 0x68, 0xfb, 0xa1, 0xec, 0x55, 0x8e, 0xf7, 0x0a, 0x61, + 0x51, 0xaf, 0xa8, 0x3b, 0x91, 0x04, 0x79, 0x24, 0xa8, 0x52, 0x77, 0xc2, 0xd1, 0xc6, 0x01, 0x10, + 0xad, 0xe0, 0x5d, 0x1a, 0xda, 0xce, 0x34, 0x20, 0x1f, 0x43, 0x3d, 0xd4, 0xaa, 0x6b, 0xe5, 0xee, + 0x16, 0xee, 0xd5, 0xd4, 0xd2, 0xd4, 0x32, 0x98, 0x31, 0x3a, 0xe3, 0x1c, 0x2a, 0x7b, 0x94, 0x1e, + 0x38, 0x33, 0x27, 0x24, 0x9b, 0x50, 0x3a, 0x75, 0x2e, 0xe9, 0x04, 0x1b, 0x55, 0xd8, 0xbf, 0x61, + 0xf2, 0x24, 0xb9, 0x03, 0x80, 0x3f, 0xac, 0x99, 0x5a, 0xa5, 0xfb, 0x37, 0xcc, 0x2a, 0xc2, 0x0e, + 0x03, 0x3b, 0x24, 0xdb, 0x50, 0x9e, 0x53, 0x7f, 0x4c, 0xe5, 0x7a, 0xd8, 0xbf, 0x61, 0x4a, 0xc0, + 0x4e, 0x19, 0x4a, 0x53, 0x56, 0xba, 0xf1, 0xfb, 0x25, 0xa8, 0x0d, 0xa9, 0x3b, 0x91, 0x23, 0x41, + 0xa0, 0xc8, 0x06, 0x1a, 0x2b, 0xab, 0x9b, 0xf8, 0x9b, 0xbc, 0x09, 0x35, 0x9c, 0x92, 0x20, 0xf4, + 0x1d, 0xf7, 0x8c, 0xef, 0x96, 0x9d, 0x7c, 0x2b, 0x67, 0x02, 0x03, 0x0f, 0x11, 0x4a, 0x9a, 0x50, + 0xb0, 0x67, 0x72, 0xb7, 0xb0, 0x9f, 0xe4, 0x26, 0x54, 0xec, 0x59, 0xc8, 0x9b, 0x57, 0x47, 0x70, + 0xd9, 0x9e, 0x85, 0xd8, 0xb4, 0x37, 0xa0, 0x3e, 0xb7, 0xaf, 0x66, 0xd4, 0x0d, 0xa3, 0x65, 0x56, + 0x37, 0x6b, 0x02, 0x86, 0x0b, 0xed, 0x11, 0xac, 0xe9, 0x24, 0xb2, 0xf2, 0x92, 0xaa, 0x7c, 0x55, + 0xa3, 0x16, 0x6d, 0x78, 0x07, 0x56, 0x64, 0x1e, 0x9f, 0xf7, 0x07, 0x97, 0x5f, 0xd5, 0x5c, 0x16, + 0x60, 0xd9, 0xcb, 0x7b, 0xd0, 0x3c, 0x75, 0x5c, 0x7b, 0x6a, 0x8d, 0xa7, 0xe1, 0x85, 0x35, 0xa1, + 0xd3, 0xd0, 0xc6, 0x95, 0x58, 0x32, 0x97, 0x11, 0xde, 0x99, 0x86, 0x17, 0xbb, 0x0c, 0x4a, 0xde, + 0x83, 0xea, 0x29, 0xa5, 0x16, 0x0e, 0x56, 0xab, 0x12, 0xdb, 0xd0, 0x72, 0x86, 0xcc, 0xca, 0xa9, + 0x9c, 0xab, 0xf7, 0xa0, 0xe9, 0x2d, 0xc2, 0x33, 0xcf, 0x71, 0xcf, 0xac, 0xf1, 0xb9, 0xed, 0x5a, + 0xce, 0x04, 0xd7, 0x66, 0x71, 0x27, 0xff, 0x30, 0x67, 0x2e, 0x4b, 0x5c, 0xe7, 0xdc, 0x76, 0x7b, + 0x13, 0xf2, 0x36, 0xac, 0x4c, 0xed, 0x20, 0xb4, 0xce, 0xbd, 0xb9, 0x35, 0x5f, 0x9c, 0x3c, 0xa3, + 0x57, 0xad, 0x06, 0x0e, 0x44, 0x83, 0x81, 0xf7, 0xbd, 0xf9, 0x11, 0x02, 0xd9, 0xd2, 0xc3, 0x76, + 0xf2, 0x46, 0xb0, 0x25, 0xdd, 0x30, 0xab, 0x0c, 0xc2, 0x2b, 0xfd, 0x0a, 0xd6, 0x70, 0x7a, 0xc6, + 0x8b, 0x20, 0xf4, 0x66, 0x96, 0x4f, 0xc7, 0x9e, 0x3f, 0x09, 0x5a, 0x35, 0x5c, 0x6b, 0xdf, 0x15, + 0x8d, 0xd5, 0xe6, 0xf8, 0xc1, 0x2e, 0x0d, 0xc2, 0x0e, 0x12, 0x9b, 0x9c, 0xb6, 0xeb, 0x86, 0xfe, + 0x95, 0xb9, 0x3a, 0x49, 0xc2, 0xc9, 0x7b, 0x40, 0xec, 0xe9, 0xd4, 0x7b, 0x6e, 0x05, 0x74, 0x7a, + 0x6a, 0x89, 0x41, 0x6c, 0x2d, 0xdf, 0xcd, 0xdd, 0xab, 0x98, 0x4d, 0xc4, 0x0c, 0xe9, 0xf4, 0xf4, + 0x88, 0xc3, 0xc9, 0xc7, 0x80, 0x9b, 0xd4, 0x3a, 0xa5, 0x76, 0xb8, 0xf0, 0x69, 0xd0, 0x5a, 0xb9, + 0x5b, 0xb8, 0xb7, 0xfc, 0x68, 0x55, 0x8d, 0x17, 0x82, 0x77, 0x9c, 0xd0, 0xac, 0x33, 0x3a, 0x91, + 0x0e, 0xb6, 0x77, 0x61, 0x33, 0xbb, 0x49, 0x6c, 0x51, 0xb1, 0x51, 0x61, 0x8b, 0xb1, 0x68, 0xb2, + 0x9f, 0x6c, 0x67, 0x5f, 0xd8, 0xd3, 0x05, 0xc5, 0x55, 0x58, 0x37, 0x79, 0xe2, 0xfb, 0xf9, 0x4f, + 0x73, 0xc6, 0xef, 0xe5, 0xa0, 0xce, 0x7b, 0x19, 0xcc, 0x3d, 0x37, 0xa0, 0xe4, 0x4d, 0x68, 0xc8, + 0xd5, 0x40, 0x7d, 0xdf, 0xf3, 0x05, 0xb7, 0x94, 0x2b, 0xaf, 0xcb, 0x60, 0xe4, 0xbb, 0xd0, 0x94, + 0x44, 0x73, 0x9f, 0x3a, 0x33, 0xfb, 0x4c, 0x16, 0x2d, 0x97, 0xd2, 0x91, 0x00, 0x93, 0x0f, 0xa2, + 0xf2, 0x7c, 0x6f, 0x11, 0x52, 0x5c, 0xeb, 0xb5, 0x47, 0x75, 0xd1, 0x3d, 0x93, 0xc1, 0x54, 0xe9, + 0x98, 0x7a, 0x85, 0x75, 0x6e, 0xfc, 0x56, 0x0e, 0x08, 0x6b, 0xf6, 0xc8, 0xe3, 0x05, 0x44, 0x1c, + 0x29, 0x96, 0x33, 0xf7, 0xca, 0x3b, 0x24, 0xff, 0xa2, 0x1d, 0x62, 0x40, 0x89, 0xb7, 0xbd, 0x98, + 0xd1, 0x76, 0x8e, 0xfa, 0x71, 0xb1, 0x52, 0x68, 0x16, 0x8d, 0xff, 0x50, 0x80, 0x75, 0xb6, 0x4e, + 0x5d, 0x3a, 0x6d, 0x8f, 0xc7, 0x74, 0xae, 0xf6, 0xce, 0x1d, 0xa8, 0xb9, 0xde, 0x84, 0xca, 0x15, + 0xcb, 0x1b, 0x06, 0x0c, 0xa4, 0x2d, 0xd7, 0x73, 0xdb, 0x71, 0x79, 0xc3, 0xf9, 0x60, 0x56, 0x11, + 0x82, 0xcd, 0x7e, 0x1b, 0x56, 0xe6, 0xd4, 0x9d, 0xe8, 0x5b, 0xa4, 0xc0, 0x57, 0xbd, 0x00, 0x8b, + 0xdd, 0x71, 0x07, 0x6a, 0xa7, 0x0b, 0x4e, 0xc7, 0x18, 0x4b, 0x11, 0xd7, 0x00, 0x08, 0x50, 0x9b, + 0xf3, 0x97, 0xf9, 0x22, 0x38, 0x47, 0x6c, 0x09, 0xb1, 0x65, 0x96, 0x66, 0xa8, 0xdb, 0x00, 0x93, + 0x45, 0x10, 0x8a, 0x1d, 0xb3, 0x84, 0xc8, 0x2a, 0x83, 0xf0, 0x1d, 0xf3, 0x3d, 0x58, 0x9b, 0xd9, + 0x97, 0x16, 0xae, 0x1d, 0xcb, 0x71, 0xad, 0xd3, 0x29, 0x32, 0xf5, 0x32, 0xd2, 0x35, 0x67, 0xf6, + 0xe5, 0x17, 0x0c, 0xd3, 0x73, 0xf7, 0x10, 0xce, 0xd8, 0xca, 0x98, 0x8f, 0x84, 0xe5, 0xd3, 0x80, + 0xfa, 0x17, 0x14, 0x39, 0x41, 0xd1, 0x5c, 0x16, 0x60, 0x93, 0x43, 0x59, 0x8b, 0x66, 0xac, 0xdf, + 0xe1, 0x74, 0xcc, 0xb7, 0xbd, 0x59, 0x9e, 0x39, 0xee, 0x7e, 0x38, 0x1d, 0xb3, 0xf3, 0x8a, 0xf1, + 0x91, 0x39, 0xf5, 0xad, 0x67, 0xcf, 0x71, 0x0f, 0x17, 0x91, 0x6f, 0x1c, 0x51, 0xff, 0xe9, 0x73, + 0x26, 0x52, 0x8c, 0x03, 0x64, 0x44, 0xf6, 0x55, 0xab, 0x86, 0x1b, 0xbc, 0x32, 0x0e, 0x18, 0x0b, + 0xb2, 0xaf, 0xd8, 0x26, 0x64, 0xad, 0xb5, 0x71, 0x16, 0xe8, 0x04, 0x8b, 0x0f, 0x90, 0xa3, 0x36, + 0xb0, 0xb1, 0x6d, 0x81, 0x60, 0xf5, 0x04, 0x6c, 0xd5, 0xcb, 0xc6, 0x9e, 0x4e, 0xed, 0xb3, 0x00, + 0x59, 0x4a, 0xc3, 0xac, 0x0b, 0xe0, 0x1e, 0x83, 0x19, 0x5f, 0xc2, 0x46, 0x62, 0x6e, 0xc5, 0x9e, + 0x61, 0x22, 0x04, 0x42, 0x70, 0x5e, 0x2b, 0xa6, 0x48, 0x65, 0x4d, 0x5a, 0x3e, 0x63, 0xd2, 0x8c, + 0xdf, 0xce, 0x41, 0x5d, 0x94, 0x8c, 0xc2, 0x0e, 0x79, 0x00, 0x44, 0xce, 0x62, 0x78, 0xe9, 0x4c, + 0xac, 0x93, 0xab, 0x90, 0x06, 0x7c, 0xd1, 0xec, 0xdf, 0x30, 0x9b, 0x02, 0x37, 0xba, 0x74, 0x26, + 0x3b, 0x0c, 0x43, 0xee, 0x43, 0x33, 0x46, 0x1f, 0x84, 0x3e, 0x5f, 0xd1, 0xfb, 0x37, 0xcc, 0x65, + 0x8d, 0x7a, 0x18, 0xfa, 0x6c, 0x8f, 0x30, 0x51, 0x6a, 0x11, 0x5a, 0x8e, 0x3b, 0xa1, 0x97, 0xb8, + 0x8c, 0x1a, 0x66, 0x8d, 0xc3, 0x7a, 0x0c, 0xb4, 0xb3, 0x0c, 0x75, 0xbd, 0x38, 0xe3, 0x0c, 0x2a, + 0x52, 0x0e, 0x43, 0x41, 0x24, 0xd1, 0x24, 0xb3, 0x1a, 0xaa, 0x96, 0xdc, 0x84, 0x4a, 0xbc, 0x05, + 0x66, 0x39, 0x7c, 0xe5, 0x8a, 0x8d, 0x1f, 0x40, 0xf3, 0x80, 0x2d, 0x1e, 0x97, 0x2d, 0x56, 0x21, + 0x57, 0x6e, 0xc2, 0x92, 0xb6, 0x69, 0xaa, 0xa6, 0x48, 0xb1, 0x33, 0xf7, 0xdc, 0x0b, 0x42, 0x51, + 0x0b, 0xfe, 0x36, 0x7e, 0x3f, 0x07, 0xa4, 0x1b, 0x84, 0xce, 0xcc, 0x0e, 0xe9, 0x1e, 0x55, 0x6c, + 0x61, 0x00, 0x75, 0x56, 0xda, 0xc8, 0x6b, 0x73, 0x41, 0x8f, 0x0b, 0x14, 0xef, 0x8a, 0x6d, 0x9c, + 0xce, 0xf0, 0x40, 0xa7, 0xe6, 0x6c, 0x3e, 0x56, 0x00, 0xdb, 0x65, 0xa1, 0xed, 0x9f, 0xd1, 0x10, + 0xc5, 0x43, 0x21, 0xd7, 0x00, 0x07, 0x31, 0xc1, 0x70, 0xfb, 0x87, 0xb0, 0x9a, 0x2a, 0x43, 0xe7, + 0xcb, 0xd5, 0x0c, 0xbe, 0x5c, 0xd0, 0xf9, 0xb2, 0x05, 0x6b, 0xb1, 0x76, 0x89, 0x95, 0xb6, 0x05, + 0x65, 0xb6, 0x21, 0x98, 0x70, 0x90, 0xe3, 0xd2, 0xea, 0x29, 0xa5, 0x4c, 0xbc, 0x7e, 0x1f, 0xd6, + 0x4f, 0x29, 0xf5, 0xed, 0x10, 0x91, 0xb8, 0x63, 0xd8, 0x0c, 0x89, 0x82, 0x57, 0x05, 0x6e, 0x68, + 0x87, 0x47, 0xd4, 0x67, 0x33, 0x65, 0xfc, 0xcf, 0x1c, 0xac, 0x30, 0x0e, 0x7a, 0x68, 0xbb, 0x57, + 0x72, 0x9c, 0x0e, 0x32, 0xc7, 0xe9, 0x9e, 0x76, 0x18, 0x6a, 0xd4, 0xdf, 0x74, 0x90, 0x0a, 0xc9, + 0x41, 0x22, 0x77, 0xa1, 0x1e, 0x6b, 0x6b, 0x09, 0xdb, 0x0a, 0x81, 0x6a, 0x64, 0x24, 0x91, 0x2e, + 0x69, 0x12, 0xe9, 0x9f, 0x7e, 0x70, 0xdf, 0x86, 0x66, 0xd4, 0x19, 0x31, 0xb2, 0x04, 0x8a, 0x6c, + 0xa1, 0x8a, 0x02, 0xf0, 0xb7, 0xf1, 0x0f, 0x72, 0x9c, 0xb0, 0xe3, 0x39, 0x91, 0xd4, 0x4b, 0xa0, + 0xc8, 0xa4, 0x6c, 0x49, 0xc8, 0x7e, 0x5f, 0xab, 0x43, 0x7c, 0x0b, 0x43, 0x70, 0x13, 0x2a, 0x01, + 0x13, 0xa1, 0xed, 0x29, 0x1f, 0x85, 0x8a, 0x59, 0x66, 0xe9, 0xf6, 0x74, 0x1a, 0x8d, 0x4e, 0x59, + 0x97, 0xd7, 0xdf, 0x81, 0x55, 0xad, 0xcd, 0x2f, 0xe8, 0x5d, 0x1f, 0xc8, 0x81, 0x13, 0x84, 0xc7, + 0x6e, 0x30, 0xd7, 0x84, 0xbc, 0x5b, 0x50, 0x65, 0xdc, 0x98, 0xb5, 0x37, 0x10, 0x12, 0x3d, 0x63, + 0xcf, 0xac, 0xb5, 0x01, 0x22, 0xed, 0x4b, 0x81, 0xcc, 0x0b, 0xa4, 0x7d, 0x89, 0x48, 0xe3, 0x53, + 0x58, 0x8b, 0x95, 0x27, 0xaa, 0x7e, 0x03, 0x4a, 0x8b, 0xf0, 0xd2, 0x93, 0x62, 0x7c, 0x4d, 0xac, + 0x26, 0xa6, 0x84, 0x9a, 0x1c, 0x63, 0x7c, 0x0e, 0xab, 0x7d, 0xfa, 0x5c, 0x6c, 0x78, 0xd9, 0x90, + 0xb7, 0xa1, 0xf8, 0x12, 0xc5, 0x14, 0xf1, 0xc6, 0x03, 0x20, 0x7a, 0x66, 0x51, 0xab, 0xa6, 0xa7, + 0xe6, 0x62, 0x7a, 0xaa, 0xf1, 0x36, 0x90, 0xa1, 0x73, 0xe6, 0x1e, 0xd2, 0x20, 0xb0, 0xcf, 0x14, + 0x8b, 0x68, 0x42, 0x61, 0x16, 0x9c, 0x09, 0x7e, 0xc6, 0x7e, 0x1a, 0x1f, 0xc2, 0x5a, 0x8c, 0x4e, + 0x14, 0xfc, 0x1a, 0x54, 0x03, 0xe7, 0xcc, 0x45, 0x21, 0x4c, 0x14, 0x1d, 0x01, 0x8c, 0x3d, 0x58, + 0xff, 0x82, 0xfa, 0xce, 0xe9, 0xd5, 0xcb, 0x8a, 0x8f, 0x97, 0x93, 0x4f, 0x96, 0xd3, 0x85, 0x8d, + 0x44, 0x39, 0xa2, 0x7a, 0xbe, 0xa8, 0xc5, 0x4c, 0x56, 0x4c, 0x9e, 0xd0, 0x78, 0x64, 0x5e, 0xe7, + 0x91, 0x86, 0x07, 0xa4, 0xe3, 0xb9, 0x2e, 0x1d, 0x87, 0x47, 0x94, 0xfa, 0xb2, 0x31, 0xef, 0x6a, + 0x2b, 0xb8, 0xf6, 0x68, 0x4b, 0x8c, 0x6c, 0x92, 0xf1, 0x8a, 0xa5, 0x4d, 0xa0, 0x38, 0xa7, 0xfe, + 0x0c, 0x0b, 0xae, 0x98, 0xf8, 0x9b, 0x0d, 0x2e, 0xd3, 0x4c, 0xbd, 0x05, 0xd7, 0x5c, 0x8a, 0xa6, + 0x4c, 0x1a, 0x1b, 0xb0, 0x16, 0xab, 0x90, 0xb7, 0xda, 0x78, 0x08, 0x1b, 0xbb, 0x4e, 0x30, 0x4e, + 0x37, 0x65, 0x0b, 0xca, 0xf3, 0xc5, 0x89, 0x15, 0xe7, 0xee, 0x4f, 0xe9, 0x95, 0xd1, 0x82, 0xcd, + 0x64, 0x0e, 0x51, 0xd6, 0xaf, 0xe7, 0xa0, 0xb8, 0x3f, 0x3a, 0xe8, 0x90, 0x6d, 0xa8, 0x38, 0xee, + 0xd8, 0x9b, 0x31, 0xf1, 0x8d, 0x8f, 0x86, 0x4a, 0x5f, 0xbb, 0x21, 0x6f, 0x41, 0x15, 0xa5, 0x3e, + 0xa6, 0x78, 0x0b, 0x01, 0xaa, 0xc2, 0x00, 0x07, 0xde, 0xf8, 0x19, 0xd3, 0xf8, 0xe9, 0xe5, 0xdc, + 0xf1, 0x51, 0xa7, 0x97, 0x3a, 0x6b, 0x91, 0x4b, 0x0c, 0x11, 0x42, 0xa8, 0xae, 0xbf, 0x9e, 0x07, + 0x22, 0xce, 0xec, 0x8e, 0xe7, 0x06, 0xa1, 0x6f, 0x3b, 0x6e, 0x18, 0xc4, 0x65, 0x92, 0x5c, 0x42, + 0x26, 0xb9, 0x07, 0x4d, 0x94, 0x03, 0x84, 0x3c, 0x84, 0x6c, 0x3c, 0x1f, 0xc9, 0x44, 0x42, 0x20, + 0x62, 0xec, 0xfc, 0x2d, 0x58, 0x8e, 0x44, 0x31, 0x65, 0x50, 0x29, 0x9a, 0x75, 0x25, 0x8e, 0x09, + 0xa6, 0xcf, 0xb6, 0xa3, 0x94, 0x31, 0x94, 0xde, 0xc8, 0xa5, 0xbe, 0xd5, 0x99, 0x7d, 0x79, 0x44, + 0xa5, 0xe0, 0x87, 0x1a, 0xa4, 0x01, 0x0d, 0x29, 0x6a, 0x71, 0x4a, 0x2e, 0x01, 0xd6, 0x84, 0xbc, + 0x85, 0x34, 0xd9, 0x82, 0xd3, 0x52, 0xb6, 0xe0, 0x64, 0xfc, 0xdb, 0x2a, 0x94, 0xc5, 0x30, 0x70, + 0x31, 0x28, 0x74, 0x2e, 0x68, 0x24, 0x06, 0xb1, 0x14, 0x13, 0xae, 0x7c, 0x3a, 0xf3, 0x42, 0x25, + 0xfd, 0xf2, 0x45, 0x5a, 0xe7, 0x40, 0x21, 0xff, 0x6a, 0x12, 0x18, 0xb7, 0x03, 0x15, 0x38, 0xd1, + 0x58, 0x97, 0x8b, 0x6e, 0x41, 0x59, 0x0a, 0x52, 0x45, 0xa5, 0x20, 0x2e, 0x8d, 0xb9, 0xe8, 0xbb, + 0x0d, 0x95, 0xb1, 0x3d, 0xb7, 0xc7, 0x4e, 0x78, 0x25, 0xf8, 0xa8, 0x4a, 0xb3, 0xd2, 0xa7, 0xde, + 0xd8, 0x9e, 0x5a, 0x27, 0xf6, 0xd4, 0x76, 0xc7, 0x54, 0x18, 0x58, 0xea, 0x08, 0xdc, 0xe1, 0x30, + 0xf2, 0x1d, 0x58, 0x16, 0xed, 0x94, 0x54, 0xdc, 0xce, 0x22, 0x5a, 0x2f, 0xc9, 0x98, 0xa4, 0xee, + 0xcd, 0xd8, 0xbc, 0x9c, 0x52, 0x2e, 0xd3, 0x16, 0xcc, 0x2a, 0x87, 0xec, 0x51, 0xec, 0xad, 0x40, + 0x3f, 0xe7, 0x2b, 0xa8, 0xca, 0xab, 0xe2, 0xc0, 0x2f, 0xb9, 0x5d, 0x24, 0x2d, 0xd8, 0x16, 0x34, + 0xc1, 0xf6, 0x5d, 0x58, 0x5d, 0xb8, 0x01, 0x0d, 0xc3, 0x29, 0x9d, 0xa8, 0xb6, 0xd4, 0x90, 0xa8, + 0xa9, 0x10, 0xb2, 0x39, 0x0f, 0x60, 0x8d, 0x5b, 0x86, 0x02, 0x3b, 0xf4, 0x82, 0x73, 0x27, 0xb0, + 0x02, 0xa6, 0x6e, 0x72, 0xdb, 0xc1, 0x2a, 0xa2, 0x86, 0x02, 0x33, 0xe4, 0xfa, 0xe6, 0x56, 0x82, + 0xde, 0xa7, 0x63, 0xea, 0x5c, 0xd0, 0x09, 0x0a, 0xbd, 0x05, 0x73, 0x23, 0x96, 0xc7, 0x14, 0x48, + 0xd4, 0x60, 0x16, 0x33, 0x6b, 0x31, 0x9f, 0xd8, 0x4c, 0xf2, 0x5b, 0xe6, 0x9a, 0x85, 0xbb, 0x98, + 0x1d, 0x73, 0x08, 0x79, 0x08, 0x52, 0xac, 0x15, 0x6b, 0x66, 0x25, 0xc6, 0xf0, 0xd9, 0x9e, 0x35, + 0xeb, 0x82, 0x82, 0x4b, 0xdd, 0x77, 0xf4, 0xcd, 0xd2, 0x64, 0x2b, 0x0c, 0x35, 0xb0, 0x68, 0xc3, + 0xb4, 0xa0, 0x3c, 0xf7, 0x9d, 0x0b, 0x3b, 0xa4, 0xad, 0x55, 0x7e, 0xf6, 0x89, 0x24, 0x63, 0x9f, + 0x8e, 0xeb, 0x84, 0x8e, 0x1d, 0x7a, 0x7e, 0x8b, 0x20, 0x2e, 0x02, 0x90, 0xfb, 0xb0, 0x8a, 0xeb, + 0x24, 0x08, 0xed, 0x70, 0x11, 0x08, 0x91, 0x7e, 0x0d, 0x17, 0x14, 0x2a, 0x25, 0x43, 0x84, 0xa3, + 0x54, 0x4f, 0x3e, 0x81, 0x4d, 0xbe, 0x34, 0x52, 0x5b, 0x73, 0x9d, 0x0d, 0x07, 0xb6, 0x68, 0x0d, + 0x29, 0x3a, 0xf1, 0x3d, 0xfa, 0x19, 0x6c, 0x89, 0xe5, 0x92, 0xca, 0xb9, 0xa1, 0x72, 0xae, 0x73, + 0x92, 0x44, 0xd6, 0x07, 0xb0, 0xca, 0x9a, 0xe6, 0x8c, 0x2d, 0x51, 0x02, 0xdb, 0x15, 0x9b, 0xac, + 0x17, 0x98, 0x69, 0x85, 0x23, 0x4d, 0xc4, 0x3d, 0xa5, 0x57, 0xe4, 0x07, 0xb0, 0xc2, 0x97, 0x0f, + 0xea, 0xad, 0x78, 0x2c, 0x6e, 0xe3, 0xb1, 0xb8, 0x21, 0x06, 0xb7, 0xa3, 0xb0, 0x78, 0x32, 0x2e, + 0x8f, 0x63, 0x69, 0xb6, 0x35, 0xa6, 0xce, 0x29, 0x65, 0x5c, 0xba, 0xb5, 0xc5, 0x17, 0x9b, 0x4c, + 0xb3, 0x5d, 0xbb, 0x98, 0x23, 0xa6, 0xc5, 0x59, 0x25, 0x4f, 0xe1, 0x3a, 0x9e, 0x7a, 0x01, 0x95, + 0x36, 0xc5, 0xd6, 0x4d, 0xb1, 0x21, 0x19, 0x50, 0x0a, 0xe7, 0x4c, 0xc3, 0xe1, 0xda, 0xa4, 0xb2, + 0xfc, 0xde, 0xc2, 0x85, 0xd1, 0xe0, 0x4a, 0xa5, 0xb4, 0xfe, 0x32, 0x41, 0xe8, 0xdc, 0x7e, 0x2e, + 0x99, 0xea, 0x6b, 0xc8, 0x4d, 0x80, 0x81, 0x84, 0xa1, 0x70, 0x0f, 0x56, 0xc5, 0x2c, 0x44, 0xcc, + 0xb4, 0x75, 0x1b, 0x0f, 0xa8, 0x9b, 0xb2, 0x8f, 0x29, 0x6e, 0x6b, 0x36, 0xf9, 0xbc, 0x68, 0xfc, + 0x77, 0x1f, 0x88, 0x9c, 0x14, 0xad, 0xa0, 0xd7, 0x5f, 0x56, 0xd0, 0xaa, 0x98, 0xa6, 0x08, 0x64, + 0xfc, 0x6e, 0x8e, 0xcb, 0x33, 0x82, 0x3a, 0xd0, 0x34, 0x79, 0xce, 0xd7, 0x2c, 0xcf, 0x9d, 0x5e, + 0x09, 0x56, 0x07, 0x1c, 0x34, 0x70, 0xa7, 0xc8, 0x6b, 0x1c, 0x57, 0x27, 0xe1, 0x47, 0x67, 0x5d, + 0x02, 0x91, 0xe8, 0x0e, 0xd4, 0xe6, 0x8b, 0x93, 0xa9, 0x33, 0xe6, 0x24, 0x05, 0x5e, 0x0a, 0x07, + 0x21, 0xc1, 0x1b, 0x50, 0x17, 0x6b, 0x9d, 0x53, 0x14, 0x91, 0xa2, 0x26, 0x60, 0x48, 0x82, 0x47, + 0x33, 0xf5, 0x91, 0xd9, 0xd5, 0x4d, 0xfc, 0x6d, 0xec, 0xc0, 0x7a, 0xbc, 0xd1, 0x42, 0x6e, 0xb8, + 0x0f, 0x15, 0xc1, 0x49, 0xa5, 0x8d, 0x6b, 0x39, 0x3e, 0x1a, 0xa6, 0xc2, 0x1b, 0xff, 0xae, 0x04, + 0x6b, 0x72, 0x8c, 0xd8, 0x64, 0x0f, 0x17, 0xb3, 0x99, 0xed, 0x67, 0xb0, 0xe8, 0xdc, 0x8b, 0x59, + 0x74, 0x3e, 0xc5, 0xa2, 0xe3, 0x46, 0x0e, 0xce, 0xe1, 0xe3, 0x46, 0x0e, 0xb6, 0xba, 0xb8, 0xde, + 0xa9, 0x9b, 0xd2, 0x1b, 0x02, 0x3c, 0xe2, 0x26, 0xfb, 0xd4, 0x81, 0x52, 0xca, 0x38, 0x50, 0xf4, + 0xe3, 0x60, 0x29, 0x71, 0x1c, 0xbc, 0x01, 0x7c, 0x19, 0xcb, 0xf5, 0x58, 0xe6, 0xaa, 0x28, 0xc2, + 0xc4, 0x82, 0x7c, 0x07, 0x56, 0x92, 0x1c, 0x98, 0xb3, 0xfa, 0xe5, 0x0c, 0xfe, 0xeb, 0xcc, 0x28, + 0x8a, 0x14, 0x1a, 0x71, 0x55, 0xf0, 0x5f, 0x67, 0x46, 0x0f, 0x10, 0x23, 0xe9, 0xbb, 0x00, 0xbc, + 0x6e, 0xdc, 0xc6, 0x80, 0xdb, 0xf8, 0xed, 0xc4, 0xca, 0xd4, 0x46, 0xfd, 0x01, 0x4b, 0x2c, 0x7c, + 0x8a, 0xfb, 0xba, 0x8a, 0x39, 0x71, 0x4b, 0x7f, 0x02, 0xcb, 0xde, 0x9c, 0xba, 0x56, 0xc4, 0x05, + 0x6b, 0x58, 0x54, 0x53, 0x14, 0xd5, 0x93, 0x70, 0xb3, 0xc1, 0xe8, 0x54, 0x92, 0x7c, 0xc6, 0x07, + 0x99, 0x6a, 0x39, 0xeb, 0xd7, 0xe4, 0x5c, 0x46, 0xc2, 0x28, 0xeb, 0x87, 0x50, 0xf3, 0x69, 0xe0, + 0x4d, 0x17, 0xdc, 0x2e, 0xdf, 0xc0, 0x75, 0x24, 0x0d, 0x95, 0xa6, 0xc2, 0x98, 0x3a, 0x95, 0xf1, + 0x1b, 0x39, 0xa8, 0x69, 0x7d, 0x20, 0x1b, 0xb0, 0xda, 0x19, 0x0c, 0x8e, 0xba, 0x66, 0x7b, 0xd4, + 0xfb, 0xa2, 0x6b, 0x75, 0x0e, 0x06, 0xc3, 0x6e, 0xf3, 0x06, 0x03, 0x1f, 0x0c, 0x3a, 0xed, 0x03, + 0x6b, 0x6f, 0x60, 0x76, 0x24, 0x38, 0x47, 0x36, 0x81, 0x98, 0xdd, 0xc3, 0xc1, 0xa8, 0x1b, 0x83, + 0xe7, 0x49, 0x13, 0xea, 0x3b, 0x66, 0xb7, 0xdd, 0xd9, 0x17, 0x90, 0x02, 0x59, 0x87, 0xe6, 0xde, + 0x71, 0x7f, 0xb7, 0xd7, 0x7f, 0x62, 0x75, 0xda, 0xfd, 0x4e, 0xf7, 0xa0, 0xbb, 0xdb, 0x2c, 0x92, + 0x06, 0x54, 0xdb, 0x3b, 0xed, 0xfe, 0xee, 0xa0, 0xdf, 0xdd, 0x6d, 0x96, 0x8c, 0xff, 0x9a, 0x03, + 0x88, 0x1a, 0xca, 0xf8, 0x6a, 0xd4, 0x54, 0xdd, 0x0f, 0xb6, 0x91, 0xea, 0x14, 0xe7, 0xab, 0x7e, + 0x2c, 0x4d, 0x1e, 0x41, 0xd9, 0x5b, 0x84, 0x63, 0x6f, 0xc6, 0x45, 0xf8, 0xe5, 0x47, 0xad, 0x54, + 0xbe, 0x01, 0xc7, 0x9b, 0x92, 0x30, 0xe6, 0xeb, 0x2a, 0xbc, 0xcc, 0xd7, 0x15, 0x77, 0xaa, 0x71, + 0xb9, 0x4e, 0x73, 0xaa, 0xdd, 0x06, 0x08, 0x9e, 0x53, 0x3a, 0x47, 0x33, 0x8d, 0xd8, 0x05, 0x55, + 0x84, 0x8c, 0x98, 0x86, 0xf7, 0x47, 0x39, 0xd8, 0xc0, 0xb5, 0x34, 0x49, 0x32, 0xb1, 0xbb, 0x50, + 0x1b, 0x7b, 0xde, 0x9c, 0x32, 0x91, 0x56, 0xc9, 0x6b, 0x3a, 0x88, 0x31, 0x28, 0xce, 0x90, 0x4f, + 0x3d, 0x7f, 0x4c, 0x05, 0x0f, 0x03, 0x04, 0xed, 0x31, 0x08, 0xdb, 0x43, 0x62, 0x13, 0x72, 0x0a, + 0xce, 0xc2, 0x6a, 0x1c, 0xc6, 0x49, 0x36, 0x61, 0xe9, 0xc4, 0xa7, 0xf6, 0xf8, 0x5c, 0x70, 0x2f, + 0x91, 0x22, 0xdf, 0x8d, 0xcc, 0x55, 0x63, 0xb6, 0x27, 0xa6, 0x94, 0x37, 0xbe, 0x62, 0xae, 0x08, + 0x78, 0x47, 0x80, 0xd9, 0x39, 0x6f, 0x9f, 0xd8, 0xee, 0xc4, 0x73, 0xe9, 0x44, 0xe8, 0xbf, 0x11, + 0xc0, 0x38, 0x82, 0xcd, 0x64, 0xff, 0x04, 0xbf, 0xfb, 0x58, 0xe3, 0x77, 0x5c, 0xf1, 0xdc, 0xbe, + 0x7e, 0x8f, 0x69, 0xbc, 0xef, 0x5f, 0x14, 0xa1, 0xc8, 0xd4, 0x8d, 0x6b, 0x35, 0x13, 0x5d, 0xb3, + 0x2c, 0xa4, 0x3c, 0xa0, 0x68, 0x15, 0xe3, 0x02, 0x98, 0x98, 0x2c, 0x84, 0xa0, 0xe0, 0xa5, 0xd0, + 0x3e, 0x1d, 0x5f, 0x08, 0xc9, 0x9b, 0xa3, 0x4d, 0x3a, 0xbe, 0x40, 0x45, 0xdf, 0x0e, 0x79, 0x5e, + 0xce, 0xaf, 0xca, 0x81, 0x1d, 0x62, 0x4e, 0x81, 0xc2, 0x7c, 0x65, 0x85, 0xc2, 0x5c, 0x2d, 0x28, + 0x3b, 0xee, 0x89, 0xb7, 0x70, 0x27, 0xc8, 0x9e, 0x2a, 0xa6, 0x4c, 0xa2, 0xc3, 0x15, 0x39, 0x29, + 0x3b, 0xda, 0x39, 0x37, 0xaa, 0x30, 0xc0, 0x88, 0x1d, 0xee, 0x1f, 0x40, 0x35, 0xb8, 0x72, 0xc7, + 0x3a, 0x0f, 0x5a, 0x17, 0xe3, 0xc3, 0x7a, 0xff, 0x60, 0x78, 0xe5, 0x8e, 0x71, 0xc5, 0x57, 0x02, + 0xf1, 0x8b, 0x3c, 0x86, 0x8a, 0x72, 0x51, 0xf0, 0x13, 0xe4, 0xa6, 0x9e, 0x43, 0xfa, 0x25, 0xb8, + 0x25, 0x48, 0x91, 0x92, 0xf7, 0x61, 0x09, 0xfd, 0x08, 0x41, 0xab, 0x8e, 0x99, 0xa4, 0xba, 0xc9, + 0x9a, 0x81, 0xbe, 0x4e, 0x3a, 0x41, 0x9f, 0x82, 0x29, 0xc8, 0xd8, 0x30, 0x9d, 0x4e, 0xed, 0xb9, + 0x35, 0x46, 0xf5, 0xad, 0xc1, 0x5d, 0x86, 0x0c, 0xd2, 0x41, 0x0d, 0xee, 0x2e, 0xd4, 0xd1, 0xfd, + 0x83, 0x34, 0x2e, 0x97, 0x43, 0x0b, 0x26, 0x30, 0xd8, 0xde, 0xd4, 0x9e, 0xf7, 0x83, 0xed, 0xa7, + 0xd0, 0x88, 0x35, 0x46, 0x37, 0x0d, 0x35, 0xb8, 0x69, 0xe8, 0x2d, 0xdd, 0x34, 0x14, 0x1d, 0x85, + 0x22, 0x9b, 0x6e, 0x2a, 0xfa, 0x21, 0x54, 0xe4, 0x58, 0x30, 0x9e, 0x73, 0xdc, 0x7f, 0xda, 0x1f, + 0x7c, 0xd9, 0xb7, 0x86, 0x5f, 0xf5, 0x3b, 0xcd, 0x1b, 0x64, 0x05, 0x6a, 0xed, 0x0e, 0xb2, 0x31, + 0x04, 0xe4, 0x18, 0xc9, 0x51, 0x7b, 0x38, 0x54, 0x90, 0xbc, 0xb1, 0x07, 0xcd, 0x64, 0x57, 0xd9, + 0xa2, 0x0e, 0x25, 0x4c, 0xb8, 0x69, 0x22, 0x00, 0x53, 0xf1, 0xb9, 0xe7, 0x85, 0xab, 0x49, 0x3c, + 0x61, 0x3c, 0x86, 0x26, 0x3b, 0xd8, 0xd9, 0x58, 0xeb, 0x0e, 0xd8, 0x29, 0x13, 0xbd, 0x75, 0x57, + 0x4d, 0xc5, 0xac, 0x71, 0x18, 0x56, 0x65, 0x7c, 0x0c, 0xab, 0x5a, 0xb6, 0xc8, 0x24, 0xc3, 0x84, + 0x85, 0xa4, 0x49, 0x06, 0xd5, 0x6c, 0x8e, 0x31, 0xb6, 0x60, 0x83, 0x25, 0xbb, 0x17, 0xd4, 0x0d, + 0x87, 0x8b, 0x13, 0xee, 0xb7, 0x77, 0x3c, 0x97, 0xa9, 0xdf, 0x55, 0x85, 0xb9, 0x7e, 0x97, 0x3c, + 0x10, 0xd6, 0x1b, 0xce, 0x16, 0xb7, 0xb5, 0x1a, 0x30, 0xe3, 0x03, 0xfc, 0x1b, 0xb3, 0xe2, 0x54, + 0x15, 0x88, 0x0d, 0xeb, 0x51, 0xb7, 0x6b, 0x5a, 0x83, 0xfe, 0x41, 0xaf, 0xcf, 0x0e, 0x07, 0x36, + 0xac, 0x08, 0xd8, 0xdb, 0x43, 0x48, 0xce, 0x68, 0xc2, 0xf2, 0x13, 0x1a, 0xf6, 0xdc, 0x53, 0x4f, + 0x0c, 0x86, 0xf1, 0x67, 0x97, 0x60, 0x45, 0x81, 0x22, 0x2b, 0xd0, 0x05, 0xf5, 0x03, 0xc7, 0x73, + 0x71, 0x9d, 0x54, 0x4d, 0x99, 0x64, 0xec, 0x4d, 0x68, 0x69, 0x28, 0x66, 0xac, 0x23, 0x56, 0xe8, + 0x75, 0x28, 0x63, 0xbc, 0x03, 0x2b, 0xce, 0x84, 0xba, 0xa1, 0x13, 0x5e, 0x59, 0x31, 0xfb, 0xf3, + 0xb2, 0x04, 0x0b, 0x39, 0x63, 0x1d, 0x4a, 0xf6, 0xd4, 0xb1, 0x65, 0x3c, 0x04, 0x4f, 0x30, 0xe8, + 0xd8, 0x9b, 0x7a, 0x3e, 0xea, 0x2d, 0x55, 0x93, 0x27, 0xc8, 0x43, 0x58, 0x67, 0x3a, 0x94, 0xee, + 0x14, 0x40, 0x0e, 0xc5, 0x4d, 0xe1, 0xc4, 0x5d, 0xcc, 0x8e, 0x22, 0xc7, 0x00, 0xc3, 0x30, 0xe9, + 0x82, 0xe5, 0x10, 0xe2, 0xa4, 0xca, 0xc0, 0xad, 0x12, 0xab, 0xee, 0x62, 0xd6, 0x46, 0x8c, 0xa2, + 0x7f, 0x04, 0x1b, 0x8c, 0x5e, 0x09, 0xa0, 0x2a, 0xc7, 0x0a, 0xe6, 0x60, 0x85, 0xf5, 0x04, 0x4e, + 0xe5, 0xb9, 0x05, 0x55, 0xde, 0x2a, 0xb6, 0x24, 0x4a, 0xdc, 0x66, 0x81, 0x4d, 0xa1, 0x7e, 0x90, + 0x0a, 0x5d, 0xe0, 0x86, 0x80, 0x64, 0xe8, 0x82, 0x16, 0xfc, 0x50, 0x49, 0x06, 0x3f, 0x3c, 0x82, + 0x8d, 0x13, 0xb6, 0x46, 0xcf, 0xa9, 0x3d, 0xa1, 0xbe, 0x15, 0xad, 0x7c, 0xae, 0x6e, 0xae, 0x31, + 0xe4, 0x3e, 0xe2, 0xd4, 0x46, 0x61, 0x92, 0x20, 0x63, 0x3c, 0x74, 0x62, 0x85, 0x9e, 0x85, 0x02, + 0x22, 0xb2, 0xb0, 0x8a, 0xd9, 0xe0, 0xe0, 0x91, 0xd7, 0x61, 0xc0, 0x38, 0xdd, 0x99, 0x6f, 0xcf, + 0xcf, 0x85, 0x32, 0xa8, 0xe8, 0x9e, 0x30, 0x20, 0x79, 0x0d, 0xca, 0x6c, 0x4f, 0xb8, 0x94, 0x7b, + 0x82, 0xb9, 0x9a, 0x25, 0x41, 0xe4, 0x2d, 0x58, 0xc2, 0x3a, 0x82, 0x56, 0x13, 0x37, 0x44, 0x3d, + 0x3a, 0x2a, 0x1c, 0xd7, 0x14, 0x38, 0x26, 0x6e, 0x2f, 0x7c, 0x87, 0xf3, 0xb1, 0xaa, 0x89, 0xbf, + 0xc9, 0x8f, 0x34, 0xa6, 0xb8, 0x86, 0x79, 0xdf, 0x12, 0x79, 0x13, 0x4b, 0xf1, 0x3a, 0xfe, 0xf8, + 0xad, 0x72, 0xab, 0x1f, 0x17, 0x2b, 0xb5, 0x66, 0xdd, 0x68, 0x61, 0xc4, 0x86, 0x49, 0xc7, 0xde, + 0x05, 0xf5, 0xaf, 0x62, 0x7b, 0x24, 0x07, 0x5b, 0x29, 0x54, 0xe4, 0xf8, 0xf5, 0x05, 0xdc, 0x9a, + 0x79, 0x13, 0x29, 0x14, 0xd4, 0x25, 0xf0, 0xd0, 0x9b, 0x30, 0xe1, 0x65, 0x55, 0x11, 0x9d, 0x3a, + 0xae, 0x13, 0x9c, 0xd3, 0x89, 0x90, 0x0d, 0x9a, 0x12, 0xb1, 0x27, 0xe0, 0x4c, 0x02, 0x9f, 0xfb, + 0xde, 0x99, 0x3a, 0x2a, 0x73, 0xa6, 0x4a, 0x1b, 0x9f, 0x40, 0x89, 0xcf, 0x20, 0xdb, 0x28, 0x38, + 0xbf, 0x39, 0xb1, 0x51, 0x10, 0xda, 0x82, 0xb2, 0x4b, 0xc3, 0xe7, 0x9e, 0xff, 0x4c, 0x7a, 0x91, + 0x44, 0xd2, 0xf8, 0x29, 0x9a, 0x34, 0x55, 0xe8, 0x0d, 0x37, 0x3e, 0xb0, 0x25, 0xcc, 0x97, 0x60, + 0x70, 0x6e, 0x0b, 0x2b, 0x6b, 0x05, 0x01, 0xc3, 0x73, 0x3b, 0xb5, 0x84, 0xf3, 0xe9, 0xe8, 0x9b, + 0xb7, 0x60, 0x59, 0x06, 0xfb, 0x04, 0xd6, 0x94, 0x9e, 0x86, 0x62, 0x4b, 0xd6, 0x45, 0xa4, 0x4f, + 0x70, 0x40, 0x4f, 0x43, 0xe3, 0x10, 0x56, 0xc5, 0xa6, 0x19, 0xcc, 0xa9, 0xac, 0xfa, 0xd3, 0x2c, + 0xad, 0xa8, 0xf6, 0x68, 0x2d, 0x2e, 0x6e, 0x70, 0xc1, 0x2e, 0xa6, 0x2a, 0x19, 0x3f, 0x89, 0x2c, + 0x88, 0x4c, 0x18, 0x11, 0xe5, 0x09, 0xdd, 0x44, 0x3a, 0xdf, 0xa4, 0x0f, 0x5b, 0x69, 0x40, 0xce, + 0x84, 0x8d, 0x4e, 0xb0, 0x18, 0x8f, 0x65, 0x10, 0x56, 0xc5, 0x94, 0x49, 0xe3, 0x5f, 0xe7, 0x60, + 0x0d, 0x0b, 0x93, 0x5a, 0x9d, 0x38, 0x29, 0x7e, 0xe6, 0x46, 0xb2, 0xf9, 0xd1, 0x25, 0x40, 0x9e, + 0xf8, 0xe6, 0x8e, 0x8d, 0x62, 0xca, 0xb1, 0xf1, 0x5d, 0x68, 0x4e, 0xe8, 0xd4, 0xc1, 0xa5, 0x24, + 0x05, 0x2a, 0x2e, 0xc1, 0xae, 0x48, 0xb8, 0xb0, 0x32, 0x18, 0x7f, 0x29, 0x07, 0xab, 0x5c, 0x5e, + 0x43, 0xbb, 0x8d, 0x18, 0xa8, 0xcf, 0xa5, 0x81, 0x42, 0xb0, 0x53, 0xd1, 0xa7, 0x48, 0x8e, 0x41, + 0x28, 0x27, 0xde, 0xbf, 0x21, 0x0c, 0x17, 0x02, 0x4a, 0xbe, 0x8f, 0x9a, 0xa8, 0x6b, 0x21, 0x50, + 0xc8, 0xe1, 0x37, 0x33, 0x24, 0x44, 0x95, 0x9d, 0xa9, 0xa9, 0x2e, 0x82, 0x76, 0x2a, 0xb0, 0xc4, + 0xad, 0x60, 0xc6, 0x1e, 0x34, 0x62, 0xd5, 0xc4, 0xfc, 0x2c, 0x75, 0xee, 0x67, 0x49, 0xf9, 0x3d, + 0xf3, 0x69, 0xbf, 0xe7, 0x15, 0xac, 0x99, 0xd4, 0x9e, 0x5c, 0xed, 0x79, 0xfe, 0x51, 0x70, 0x12, + 0xee, 0x71, 0x21, 0x98, 0x9d, 0x41, 0xca, 0x99, 0x1f, 0x73, 0x66, 0x48, 0x9f, 0xae, 0x34, 0xc3, + 0x7c, 0x07, 0x96, 0x23, 0xaf, 0xbf, 0x66, 0xf6, 0x6e, 0x28, 0xc7, 0x3f, 0xca, 0x4e, 0x04, 0x8a, + 0xf3, 0xe0, 0x24, 0x14, 0x86, 0x6f, 0xfc, 0x6d, 0xfc, 0x8f, 0x22, 0x10, 0xb6, 0x9a, 0x13, 0x0b, + 0x26, 0x11, 0xaf, 0x90, 0x4f, 0xc5, 0x2b, 0x3c, 0x04, 0xa2, 0x11, 0xc8, 0x30, 0x8a, 0x82, 0x0a, + 0xa3, 0x68, 0x46, 0xb4, 0x22, 0x8a, 0xe2, 0x21, 0xac, 0x0b, 0x8d, 0x22, 0xde, 0x54, 0xbe, 0x34, + 0x08, 0x57, 0x2d, 0x62, 0xed, 0x95, 0xb1, 0x0a, 0xd2, 0x52, 0x5d, 0xe0, 0xb1, 0x0a, 0xd2, 0xa0, + 0xa4, 0x2d, 0xc0, 0xa5, 0x97, 0x2e, 0xc0, 0x72, 0x6a, 0x01, 0x6a, 0xc6, 0xc5, 0x4a, 0xdc, 0xb8, + 0x98, 0x32, 0x93, 0x73, 0xf1, 0x39, 0x66, 0x26, 0xbf, 0x07, 0x4d, 0x69, 0x68, 0x52, 0x26, 0x4c, + 0x1e, 0x64, 0x24, 0x8c, 0xc8, 0x1d, 0x69, 0xc4, 0x8c, 0x79, 0xd4, 0x6a, 0x09, 0x8f, 0xda, 0xbb, + 0xb0, 0x1a, 0xb0, 0xf5, 0x6b, 0x2d, 0x5c, 0x11, 0x69, 0x48, 0x27, 0xa8, 0x8f, 0x57, 0xcc, 0x26, + 0x22, 0x8e, 0x23, 0x78, 0xda, 0x24, 0xd7, 0xc8, 0x30, 0xc9, 0x3d, 0x8e, 0x9c, 0xf7, 0xc1, 0xb9, + 0x33, 0x43, 0xc1, 0x27, 0x8a, 0x9e, 0x13, 0x03, 0x3c, 0x3c, 0x77, 0x66, 0xa6, 0x8c, 0x14, 0x61, + 0x09, 0xd2, 0x81, 0x3b, 0xa2, 0x3f, 0x19, 0x41, 0x1e, 0x7c, 0x14, 0x56, 0x50, 0x52, 0xdd, 0xe6, + 0x64, 0x87, 0x89, 0x78, 0x8f, 0xc4, 0xa0, 0xb0, 0x42, 0xb8, 0x15, 0xb8, 0xa9, 0x0f, 0xca, 0xa1, + 0x7d, 0xc9, 0xfd, 0x06, 0xff, 0x3d, 0x07, 0x4d, 0xb6, 0xec, 0x62, 0x3b, 0xfa, 0x33, 0x40, 0xde, + 0xf3, 0x8a, 0x1b, 0xba, 0xc6, 0x68, 0xe5, 0x7e, 0xfe, 0x04, 0x70, 0x83, 0x5a, 0xde, 0x9c, 0xba, + 0x62, 0x3b, 0xb7, 0xe2, 0xdb, 0x39, 0x62, 0xd9, 0xfb, 0x37, 0xb8, 0xc2, 0xc7, 0x20, 0xe4, 0x33, + 0xa8, 0xb2, 0x7d, 0x80, 0x8b, 0x52, 0xc4, 0x9e, 0x6e, 0x2b, 0x25, 0x3e, 0xb5, 0x25, 0x59, 0xd6, + 0xb9, 0x48, 0x66, 0x85, 0x77, 0x14, 0x33, 0xc2, 0x3b, 0x34, 0x7e, 0xb1, 0x0f, 0xf0, 0x94, 0x5e, + 0x1d, 0x78, 0x63, 0x34, 0xa7, 0xdc, 0x06, 0x60, 0x5b, 0xe7, 0xd4, 0x9e, 0x39, 0xc2, 0x90, 0x58, + 0x32, 0xab, 0xcf, 0xe8, 0xd5, 0x1e, 0x02, 0xd8, 0xba, 0x61, 0xe8, 0x88, 0x69, 0x94, 0xcc, 0xca, + 0x33, 0x7a, 0xc5, 0x39, 0x86, 0x05, 0x8d, 0xa7, 0xf4, 0x6a, 0x97, 0x72, 0xc1, 0xdc, 0xf3, 0xd9, + 0x9a, 0xf5, 0xed, 0xe7, 0x4c, 0x12, 0x8f, 0x85, 0x66, 0xd4, 0x7c, 0xfb, 0xf9, 0x53, 0x7a, 0x25, + 0xc3, 0x44, 0xca, 0x0c, 0x3f, 0xf5, 0xc6, 0x42, 0x94, 0x90, 0xb6, 0x9b, 0xa8, 0x51, 0xe6, 0xd2, + 0x33, 0xfc, 0x6d, 0xfc, 0x49, 0x0e, 0x1a, 0xac, 0xfd, 0x78, 0x0a, 0xe0, 0x0a, 0x11, 0xb1, 0x8a, + 0xb9, 0x28, 0x56, 0xf1, 0x91, 0x60, 0xa2, 0xfc, 0x48, 0xc9, 0x5f, 0x7f, 0xa4, 0xe0, 0xdc, 0xf0, + 0xf3, 0xe4, 0x03, 0xa8, 0x72, 0x2e, 0xc0, 0xd8, 0x4a, 0x21, 0x36, 0xc1, 0xb1, 0x0e, 0x99, 0x15, + 0x24, 0x7b, 0xca, 0x43, 0xa3, 0x34, 0x33, 0x39, 0x1f, 0xe2, 0xaa, 0xaf, 0x8c, 0xe3, 0x19, 0xd3, + 0x50, 0xba, 0x26, 0x34, 0x4a, 0xb7, 0x41, 0x2f, 0x25, 0x6d, 0xd0, 0x86, 0x0b, 0x15, 0x36, 0xd5, + 0xd8, 0xd9, 0x8c, 0x42, 0x73, 0x59, 0x85, 0x32, 0xc1, 0xc3, 0x66, 0x67, 0x10, 0xe3, 0xab, 0x79, + 0x21, 0x78, 0xd8, 0x01, 0x65, 0x05, 0xb1, 0x86, 0xbb, 0x9e, 0x85, 0x46, 0x5d, 0x61, 0xee, 0xac, + 0x98, 0x55, 0xd7, 0x3b, 0xe2, 0x00, 0xe3, 0xff, 0xcf, 0x41, 0x4d, 0xdb, 0x8f, 0x68, 0xe5, 0x57, + 0xc3, 0xc9, 0x37, 0x6f, 0x7c, 0x07, 0xc4, 0xe6, 0x63, 0xff, 0x86, 0xd9, 0x18, 0xc7, 0x26, 0xe8, + 0x81, 0x58, 0xca, 0x98, 0x33, 0x1f, 0x33, 0x2d, 0xc9, 0x7e, 0xc9, 0xf5, 0xcb, 0x7e, 0xef, 0x2c, + 0x41, 0x91, 0x91, 0x1a, 0x9f, 0xc3, 0xaa, 0xd6, 0x0c, 0x6e, 0x7a, 0x79, 0xd5, 0x01, 0x30, 0x7e, + 0x59, 0x65, 0x66, 0x75, 0x70, 0xa7, 0xb5, 0x8c, 0x42, 0xa3, 0x13, 0x3e, 0x2e, 0x22, 0xda, 0x8d, + 0x83, 0x70, 0x64, 0x5e, 0x35, 0x32, 0xea, 0xff, 0xcb, 0xc1, 0x9a, 0x56, 0xfc, 0x9e, 0xe3, 0xda, + 0x53, 0xe7, 0xa7, 0x28, 0x7f, 0x04, 0xce, 0x99, 0x9b, 0xa8, 0x80, 0x83, 0xbe, 0x49, 0x05, 0xec, + 0x98, 0xe0, 0x31, 0xad, 0x3c, 0x2e, 0x5a, 0x1c, 0x8d, 0x80, 0x30, 0xd3, 0x7e, 0x3e, 0xba, 0x34, + 0xfe, 0x72, 0x1e, 0xd6, 0x45, 0x13, 0x30, 0xf4, 0xd8, 0x61, 0x62, 0xe7, 0x61, 0x70, 0x46, 0x3e, + 0x83, 0x06, 0x1b, 0x3e, 0xcb, 0xa7, 0x67, 0x4e, 0x10, 0x52, 0xe9, 0x4f, 0xcf, 0xe0, 0xb4, 0x4c, + 0xfa, 0x60, 0xa4, 0xa6, 0xa0, 0x24, 0x9f, 0x43, 0x0d, 0xb3, 0x72, 0xeb, 0x97, 0x98, 0xab, 0x56, + 0x3a, 0x23, 0x9f, 0x8b, 0xfd, 0x1b, 0x26, 0x04, 0xd1, 0xcc, 0x7c, 0x0e, 0x35, 0x9c, 0xe6, 0x0b, + 0x1c, 0xeb, 0x04, 0xb3, 0x4b, 0xcd, 0x05, 0xcb, 0x3c, 0x8f, 0x66, 0xa6, 0x0d, 0x0d, 0xce, 0xee, + 0xc4, 0x48, 0x8a, 0x90, 0xc6, 0xed, 0x74, 0x76, 0x39, 0xd6, 0xac, 0xf1, 0x73, 0x2d, 0xbd, 0x53, + 0x85, 0x72, 0xe8, 0x3b, 0x67, 0x67, 0xd4, 0x37, 0x36, 0xd5, 0xd0, 0x30, 0x3e, 0x4e, 0x87, 0x21, + 0x9d, 0x33, 0x7d, 0xc2, 0xf8, 0x67, 0x39, 0xa8, 0x09, 0xce, 0xfc, 0x33, 0xbb, 0xea, 0xb7, 0x13, + 0x76, 0xd2, 0xaa, 0x66, 0x16, 0x7d, 0x07, 0x56, 0x66, 0x4c, 0xf9, 0x61, 0xca, 0x79, 0xcc, 0x4f, + 0xbf, 0x2c, 0xc1, 0x42, 0xae, 0x7f, 0x00, 0x6b, 0x28, 0xe6, 0x07, 0x56, 0xe8, 0x4c, 0x2d, 0x89, + 0x14, 0xf1, 0xf7, 0xab, 0x1c, 0x35, 0x72, 0xa6, 0x87, 0x02, 0xc1, 0xa4, 0xdd, 0x20, 0xb4, 0xcf, + 0xa8, 0xe0, 0x0e, 0x3c, 0xc1, 0x14, 0xaa, 0x84, 0x5e, 0x2e, 0x15, 0xaa, 0xff, 0xb5, 0x0a, 0x5b, + 0x29, 0x94, 0x50, 0xa8, 0x94, 0x63, 0x76, 0xea, 0xcc, 0x4e, 0x3c, 0xe5, 0x18, 0xc8, 0x69, 0x8e, + 0xd9, 0x03, 0x86, 0x91, 0x8e, 0x01, 0x0a, 0x1b, 0x72, 0xc9, 0xa2, 0x65, 0x5f, 0xa9, 0xee, 0x79, + 0x54, 0x2c, 0x3f, 0x88, 0x1f, 0x83, 0xc9, 0xea, 0x24, 0x5c, 0x97, 0xe5, 0xd6, 0xe6, 0x29, 0x58, + 0x40, 0xfe, 0x6f, 0x68, 0xa9, 0x9d, 0x21, 0xf4, 0x0c, 0xcd, 0x0e, 0xc1, 0x6a, 0x7a, 0xef, 0x25, + 0x35, 0xc5, 0x4c, 0xae, 0x28, 0xec, 0x6d, 0xca, 0x4d, 0xc5, 0x0b, 0x54, 0x75, 0x5d, 0xc0, 0xeb, + 0xb2, 0x2e, 0xd4, 0x1b, 0xd2, 0x35, 0x16, 0x5f, 0xa9, 0x6f, 0x68, 0x4e, 0x8e, 0x55, 0x6b, 0xde, + 0x12, 0x05, 0x2b, 0x94, 0x5e, 0xef, 0x39, 0x6c, 0x3e, 0xb7, 0x9d, 0x50, 0xf6, 0x51, 0x33, 0x83, + 0x94, 0xb0, 0xbe, 0x47, 0x2f, 0xa9, 0xef, 0x4b, 0x9e, 0x39, 0xa6, 0x49, 0xad, 0x3f, 0x4f, 0x03, + 0x83, 0xed, 0xbf, 0x59, 0x80, 0xe5, 0x78, 0x29, 0x8c, 0xf5, 0x88, 0xe3, 0x4a, 0x0a, 0xc8, 0x42, + 0x6a, 0x17, 0x4e, 0xab, 0x3e, 0x17, 0x8c, 0xd3, 0xee, 0xb4, 0x7c, 0x86, 0x3b, 0x4d, 0xf7, 0x62, + 0x15, 0x5e, 0x16, 0xd4, 0x50, 0x7c, 0xa5, 0xa0, 0x86, 0x52, 0x56, 0x50, 0xc3, 0x87, 0xd7, 0x7a, + 0xc1, 0xb9, 0x2d, 0x3a, 0xd3, 0x03, 0xfe, 0xf8, 0x7a, 0x0f, 0x38, 0x17, 0xb7, 0xaf, 0xf3, 0x7e, + 0x6b, 0xbe, 0xfb, 0xca, 0x35, 0xbe, 0x27, 0xcd, 0x9b, 0x9f, 0xe1, 0xfd, 0xae, 0x7e, 0x03, 0xef, + 0xf7, 0xf6, 0x9f, 0xe4, 0x80, 0xa4, 0x77, 0x07, 0x79, 0xc2, 0x3d, 0x95, 0x2e, 0x9d, 0x0a, 0xce, + 0xfd, 0xbd, 0x57, 0xdb, 0x61, 0x72, 0x41, 0xc8, 0xdc, 0xe4, 0x7d, 0x58, 0xd3, 0x6f, 0x09, 0xe9, + 0x66, 0x86, 0x86, 0x49, 0x74, 0x54, 0x64, 0x30, 0xd3, 0x22, 0x48, 0x8a, 0x2f, 0x8d, 0x20, 0x29, + 0xbd, 0x34, 0x82, 0x64, 0x29, 0x1e, 0x41, 0xb2, 0xfd, 0xaf, 0x72, 0xb0, 0x96, 0xb1, 0x88, 0xbf, + 0xbd, 0x3e, 0xb3, 0xb5, 0x17, 0x63, 0x6b, 0x79, 0xb1, 0xf6, 0x74, 0x8e, 0x76, 0x20, 0x8d, 0xac, + 0x6c, 0x2a, 0x02, 0x71, 0x52, 0xdd, 0x7f, 0x19, 0x77, 0x89, 0x72, 0x98, 0x7a, 0xf6, 0xed, 0xbf, + 0x9d, 0x87, 0x9a, 0x86, 0x64, 0xa3, 0xc8, 0x97, 0xac, 0x16, 0xd9, 0xc8, 0x65, 0x4b, 0x34, 0x92, + 0xdc, 0x01, 0xe1, 0x8b, 0xe2, 0x78, 0xbe, 0xb9, 0x84, 0x20, 0x89, 0x04, 0x0f, 0x60, 0x4d, 0x7a, + 0x91, 0x69, 0x14, 0xec, 0x2c, 0xce, 0x1a, 0x11, 0x10, 0x20, 0x1a, 0x89, 0xf4, 0xef, 0x4b, 0xfd, + 0x35, 0x9a, 0x3b, 0xcd, 0x2b, 0xb7, 0x2a, 0x42, 0x11, 0xc4, 0x24, 0xb2, 0x75, 0xfe, 0x01, 0x6c, + 0xa8, 0x58, 0x84, 0x58, 0x0e, 0xee, 0xfb, 0x21, 0x32, 0xe6, 0x40, 0xcb, 0xf2, 0x23, 0xb8, 0x9d, + 0x68, 0x53, 0x22, 0x2b, 0x8f, 0xca, 0xbf, 0x19, 0x6b, 0x9d, 0x5e, 0xc2, 0xf6, 0xff, 0x03, 0x8d, + 0x18, 0xa3, 0xfc, 0xf6, 0xa6, 0x3c, 0x69, 0x98, 0xe2, 0x23, 0xaa, 0x1b, 0xa6, 0xb6, 0xff, 0x5b, + 0x01, 0x48, 0x9a, 0x57, 0xff, 0x3c, 0x9b, 0x90, 0x5e, 0x98, 0x85, 0x8c, 0x85, 0xf9, 0x7f, 0x4c, + 0x7e, 0x88, 0xec, 0xa3, 0x5a, 0x28, 0x00, 0xdf, 0x9c, 0x4d, 0x85, 0x90, 0xad, 0xf8, 0x24, 0x19, + 0x30, 0x55, 0x89, 0x5d, 0x74, 0xd3, 0x04, 0xa8, 0x44, 0xdc, 0xd4, 0x31, 0x2c, 0xd9, 0xee, 0xf8, + 0xdc, 0xf3, 0x05, 0x1f, 0xfc, 0x85, 0x6f, 0x7c, 0x7c, 0x3e, 0x68, 0x63, 0x7e, 0x94, 0xda, 0x4c, + 0x51, 0x98, 0xf1, 0x01, 0xd4, 0x34, 0x30, 0xa9, 0x42, 0xe9, 0xa0, 0x77, 0xb8, 0x33, 0x68, 0xde, + 0x20, 0x0d, 0xa8, 0x9a, 0xdd, 0xce, 0xe0, 0x8b, 0xae, 0xd9, 0xdd, 0x6d, 0xe6, 0x48, 0x05, 0x8a, + 0x07, 0x83, 0xe1, 0xa8, 0x99, 0x37, 0xb6, 0xa1, 0x25, 0x4a, 0x4c, 0x7b, 0x8a, 0x7e, 0xab, 0xa8, + 0xec, 0x9b, 0x88, 0x14, 0x4a, 0xfe, 0x87, 0x50, 0xd7, 0xc5, 0x1b, 0xb1, 0x22, 0x12, 0xd1, 0x28, + 0x4c, 0xbd, 0xf7, 0x34, 0x5e, 0xdd, 0x01, 0x1e, 0x8b, 0x30, 0x51, 0xd9, 0xf2, 0x31, 0xb9, 0x35, + 0xc3, 0xa9, 0x8b, 0xfa, 0x51, 0x6c, 0x19, 0xfe, 0x5f, 0xb0, 0x1c, 0xf7, 0x8a, 0x08, 0x8e, 0x94, + 0xa5, 0xb2, 0xb2, 0xdc, 0x31, 0x37, 0x09, 0xf9, 0x11, 0x34, 0x93, 0x5e, 0x15, 0x21, 0x3c, 0x5f, + 0x93, 0x7f, 0xc5, 0x89, 0x3b, 0x5a, 0xc8, 0x3e, 0xac, 0x67, 0x09, 0x78, 0xb8, 0x3e, 0xae, 0x37, + 0x73, 0x90, 0xb4, 0x10, 0x47, 0x3e, 0x15, 0xde, 0xb5, 0x12, 0x4e, 0xff, 0x5b, 0xf1, 0xfa, 0xb5, + 0xc1, 0x7e, 0xc0, 0xff, 0x69, 0x7e, 0xb6, 0x0b, 0x80, 0x08, 0x46, 0x9a, 0x50, 0x1f, 0x1c, 0x75, + 0xfb, 0x56, 0x67, 0xbf, 0xdd, 0xef, 0x77, 0x0f, 0x9a, 0x37, 0x08, 0x81, 0x65, 0x0c, 0xa8, 0xd8, + 0x55, 0xb0, 0x1c, 0x83, 0x09, 0x2f, 0xa7, 0x84, 0xe5, 0xc9, 0x3a, 0x34, 0x7b, 0xfd, 0x04, 0xb4, + 0x40, 0x5a, 0xb0, 0x7e, 0xd4, 0xe5, 0x31, 0x18, 0xb1, 0x72, 0x8b, 0x4c, 0x69, 0x10, 0xdd, 0x65, + 0x4a, 0xc3, 0x97, 0xf6, 0x74, 0x4a, 0x43, 0xb1, 0x0f, 0xa4, 0x2c, 0xfd, 0x57, 0x72, 0xb0, 0x91, + 0x40, 0x44, 0xae, 0x09, 0x2e, 0x49, 0xc7, 0x65, 0xe8, 0x3a, 0x02, 0xe5, 0x6e, 0x7a, 0x17, 0x56, + 0x95, 0xa5, 0x2c, 0x71, 0x2a, 0x35, 0x15, 0x42, 0x12, 0xbf, 0x0f, 0x6b, 0x9a, 0xc1, 0x2d, 0xc1, + 0x2b, 0x88, 0x86, 0x12, 0x19, 0x8c, 0x2d, 0x75, 0xf7, 0x27, 0xd1, 0xea, 0x09, 0x6c, 0x26, 0x11, + 0x91, 0xf3, 0x31, 0xde, 0x5e, 0x99, 0x24, 0x0f, 0x13, 0x0b, 0x21, 0xde, 0x5a, 0x7d, 0xc2, 0x65, + 0xf5, 0xbf, 0xb3, 0x04, 0xe4, 0x27, 0x0b, 0xea, 0x5f, 0xe1, 0x9d, 0xb3, 0xe0, 0x65, 0xe1, 0xd3, + 0xd2, 0x56, 0x93, 0x7f, 0xa5, 0x7b, 0xa5, 0x59, 0xf7, 0x3a, 0x8b, 0x2f, 0xbf, 0xd7, 0x59, 0x7a, + 0xd9, 0xbd, 0xce, 0x37, 0xa1, 0xe1, 0x9c, 0xb9, 0x1e, 0x63, 0x85, 0x4c, 0x12, 0x0e, 0x5a, 0x4b, + 0x77, 0x0b, 0xf7, 0xea, 0x66, 0x5d, 0x00, 0x99, 0x1c, 0x1c, 0x90, 0xcf, 0x23, 0x22, 0x3a, 0x39, + 0xc3, 0xbb, 0xcd, 0x3a, 0x13, 0xec, 0x4e, 0xce, 0xa8, 0x30, 0x4d, 0xa1, 0xa6, 0x21, 0x33, 0x33, + 0x78, 0x40, 0xde, 0x82, 0xe5, 0xc0, 0x5b, 0x30, 0xc5, 0x42, 0x0e, 0x03, 0xf7, 0x3e, 0xd6, 0x39, + 0xf4, 0x48, 0xfa, 0xa2, 0xd7, 0x16, 0x01, 0xb5, 0x66, 0x4e, 0x10, 0x30, 0xf1, 0x6c, 0xec, 0xb9, + 0xa1, 0xef, 0x4d, 0x85, 0x43, 0x71, 0x75, 0x11, 0xd0, 0x43, 0x8e, 0xe9, 0x70, 0x04, 0xf9, 0x28, + 0x6a, 0xd2, 0xdc, 0x76, 0xfc, 0xa0, 0x05, 0xd8, 0x24, 0xd9, 0x53, 0x94, 0xdf, 0x6d, 0xc7, 0x57, + 0x6d, 0x61, 0x89, 0x20, 0x71, 0xdf, 0xb4, 0x96, 0xbc, 0x6f, 0xfa, 0x6b, 0xd9, 0xf7, 0x4d, 0x79, + 0x0c, 0xd5, 0x43, 0x51, 0x74, 0x7a, 0x8a, 0xbf, 0xd1, 0xb5, 0xd3, 0xf4, 0x35, 0xda, 0xe5, 0x6f, + 0x72, 0x8d, 0x76, 0x25, 0xeb, 0x1a, 0xed, 0x07, 0x50, 0xc3, 0x0b, 0x8e, 0xd6, 0x39, 0x46, 0x52, + 0x72, 0x07, 0x69, 0x53, 0xbf, 0x01, 0xb9, 0xef, 0xb8, 0xa1, 0x09, 0xbe, 0xfc, 0x19, 0xa4, 0x6f, + 0xb4, 0xae, 0xfe, 0x1c, 0x6f, 0xb4, 0x8a, 0x8b, 0x98, 0x0f, 0xa0, 0x22, 0xe7, 0x89, 0x10, 0x28, + 0x9e, 0xfa, 0xde, 0x4c, 0x3a, 0x65, 0xd8, 0x6f, 0xb2, 0x0c, 0xf9, 0xd0, 0x13, 0x99, 0xf3, 0xa1, + 0x67, 0xfc, 0x0a, 0xd4, 0xb4, 0xa5, 0x46, 0xde, 0xe0, 0x96, 0x4d, 0xa6, 0x9b, 0x09, 0xd9, 0x92, + 0x8f, 0x62, 0x55, 0x40, 0x7b, 0x13, 0xc6, 0x6f, 0x26, 0x8e, 0x4f, 0xf1, 0xee, 0xb9, 0xe5, 0xd3, + 0x0b, 0xea, 0x07, 0xd2, 0x49, 0xd6, 0x54, 0x08, 0x93, 0xc3, 0x8d, 0x5f, 0x85, 0xb5, 0xd8, 0xdc, + 0x0a, 0x16, 0xf1, 0x16, 0x2c, 0xe1, 0xb8, 0xc9, 0x48, 0x8c, 0xf8, 0xcd, 0x52, 0x81, 0xc3, 0x7b, + 0xf6, 0xdc, 0xbf, 0x67, 0xcd, 0x7d, 0xef, 0x04, 0x2b, 0xc9, 0x99, 0x35, 0x01, 0x3b, 0xf2, 0xbd, + 0x13, 0xe3, 0x0f, 0x0b, 0x50, 0xd8, 0xf7, 0xe6, 0x7a, 0xf4, 0x65, 0x2e, 0x15, 0x7d, 0x29, 0x14, + 0x4e, 0x4b, 0x29, 0x94, 0x42, 0x66, 0x47, 0xcf, 0x96, 0x54, 0x2a, 0xef, 0xc1, 0x32, 0xe3, 0x13, + 0xa1, 0xc7, 0x34, 0xf6, 0xe7, 0xb6, 0xcf, 0x05, 0x62, 0x1e, 0xcc, 0x5c, 0xb7, 0x67, 0xe1, 0xc8, + 0xdb, 0xe3, 0x70, 0xb2, 0x0e, 0x05, 0xa5, 0xbe, 0x20, 0x9a, 0x25, 0xc9, 0x26, 0x2c, 0xe1, 0x5d, + 0x89, 0x2b, 0x11, 0x49, 0x20, 0x52, 0xe4, 0x7b, 0xb0, 0x16, 0x2f, 0x97, 0xb3, 0x22, 0x21, 0x1b, + 0xe9, 0x05, 0x23, 0x4f, 0xba, 0x09, 0x8c, 0x8f, 0x70, 0x1a, 0x11, 0xf2, 0x74, 0x4a, 0x29, 0xa2, + 0x34, 0xa6, 0x57, 0x89, 0x31, 0xbd, 0x3b, 0x50, 0x0b, 0xa7, 0x17, 0xd6, 0xdc, 0xbe, 0x9a, 0x7a, + 0xf6, 0x44, 0xec, 0x6f, 0x08, 0xa7, 0x17, 0x47, 0x1c, 0x42, 0xde, 0x07, 0x98, 0xcd, 0xe7, 0x62, + 0xef, 0xa1, 0xb7, 0x26, 0x5a, 0xca, 0x87, 0x47, 0x47, 0x7c, 0xc9, 0x99, 0xd5, 0xd9, 0x7c, 0xce, + 0x7f, 0x92, 0x5d, 0x58, 0xce, 0xbc, 0x1f, 0x7e, 0x5b, 0xc6, 0xb4, 0x7b, 0xf3, 0x07, 0x19, 0x9b, + 0xb3, 0x31, 0xd6, 0x61, 0xdb, 0x3f, 0x02, 0xf2, 0xa7, 0xbc, 0xa5, 0x3d, 0x82, 0xaa, 0x6a, 0x9f, + 0x7e, 0xc9, 0x19, 0xaf, 0xf1, 0xd4, 0x62, 0x97, 0x9c, 0xdb, 0x93, 0x89, 0xcf, 0xf8, 0x22, 0x3f, + 0x30, 0x15, 0xcb, 0x07, 0xed, 0xc4, 0x14, 0xb7, 0x41, 0x8c, 0xff, 0x98, 0x83, 0x12, 0xbf, 0x71, + 0xfd, 0x36, 0xac, 0x70, 0x7a, 0x15, 0xc9, 0x2a, 0xe2, 0x0f, 0xf8, 0xb9, 0x3b, 0x12, 0x41, 0xac, + 0x6c, 0x5b, 0x68, 0xaf, 0x50, 0xe4, 0xd5, 0xcc, 0x6b, 0x2f, 0x51, 0xdc, 0x81, 0xaa, 0xaa, 0x5a, + 0x5b, 0x3a, 0x15, 0x59, 0x33, 0x79, 0x1d, 0x8a, 0xe7, 0xde, 0x5c, 0x5a, 0x7e, 0x20, 0x1a, 0x49, + 0x13, 0xe1, 0x51, 0x5b, 0x58, 0x1d, 0xd1, 0x2d, 0x95, 0x82, 0x68, 0x0b, 0xab, 0x04, 0x97, 0x41, + 0xba, 0x8f, 0x4b, 0x19, 0x7d, 0x3c, 0x86, 0x15, 0xc6, 0x07, 0xb4, 0x20, 0x88, 0xeb, 0x0f, 0xcd, + 0xef, 0x32, 0x09, 0x6f, 0x3c, 0x5d, 0x4c, 0xa8, 0x6e, 0x7b, 0xc3, 0xb0, 0x44, 0x01, 0x97, 0x92, + 0xb5, 0xf1, 0x3b, 0x39, 0xce, 0x5f, 0x58, 0xb9, 0xe4, 0x1e, 0x14, 0x5d, 0x19, 0x30, 0x11, 0xc9, + 0x71, 0xea, 0x3e, 0x15, 0xa3, 0x33, 0x91, 0x82, 0x4d, 0x1d, 0x86, 0x19, 0xe8, 0xa5, 0x37, 0xcc, + 0x9a, 0xbb, 0x98, 0x29, 0xd3, 0xd5, 0x77, 0x64, 0xb7, 0x12, 0x66, 0x1f, 0xde, 0x7b, 0xb5, 0x4d, + 0x1f, 0x68, 0xf1, 0x8d, 0xc5, 0xd8, 0x89, 0x29, 0xa5, 0xc0, 0xc9, 0x19, 0xd5, 0xe2, 0x1a, 0x7f, + 0x2f, 0x0f, 0x8d, 0x58, 0x8b, 0x30, 0xc0, 0x93, 0x1d, 0x00, 0xdc, 0x35, 0x25, 0xe6, 0x1b, 0xe3, + 0xe8, 0x84, 0xa0, 0xae, 0x8d, 0x53, 0x3e, 0x36, 0x4e, 0x2a, 0xe2, 0xa9, 0xa0, 0x47, 0x3c, 0x3d, + 0x84, 0x6a, 0xf4, 0xfa, 0x48, 0xbc, 0x49, 0xac, 0x3e, 0x79, 0xab, 0x2c, 0x22, 0x8a, 0x62, 0xa4, + 0x4a, 0x7a, 0x8c, 0xd4, 0x0f, 0xb4, 0x90, 0x9a, 0x25, 0x2c, 0xc6, 0xc8, 0x1a, 0xd1, 0x9f, 0x4b, + 0x40, 0x8d, 0xf1, 0x39, 0xd4, 0xb4, 0xc6, 0xeb, 0x61, 0x29, 0xb9, 0x58, 0x58, 0x8a, 0xba, 0x15, + 0x9a, 0x8f, 0x6e, 0x85, 0x1a, 0x7f, 0x26, 0x0f, 0x0d, 0xb6, 0xbf, 0x1c, 0xf7, 0xec, 0xc8, 0x9b, + 0x3a, 0x63, 0x74, 0x55, 0xa9, 0x1d, 0x26, 0x04, 0x2d, 0xb9, 0xcf, 0xc4, 0x16, 0xe3, 0x72, 0x96, + 0x7e, 0x25, 0x9e, 0x33, 0x69, 0x75, 0x25, 0xde, 0x80, 0x06, 0x63, 0x8c, 0xe8, 0x74, 0x8a, 0xde, + 0x30, 0x31, 0x6b, 0xa7, 0x94, 0xee, 0xd8, 0x01, 0xe7, 0x90, 0xdf, 0x83, 0x35, 0x46, 0x83, 0xb7, + 0x81, 0x67, 0xce, 0x74, 0xea, 0x44, 0xd7, 0xc2, 0x0a, 0x66, 0xf3, 0x94, 0x52, 0xd3, 0x0e, 0xe9, + 0x21, 0x43, 0x88, 0x27, 0x4f, 0x2a, 0x13, 0x27, 0xb0, 0x4f, 0xa2, 0x30, 0x5c, 0x95, 0x46, 0x57, + 0xb8, 0x70, 0xe5, 0x46, 0x9b, 0xac, 0x68, 0xd6, 0x66, 0xdc, 0x91, 0x8b, 0xf9, 0x13, 0x2b, 0xa9, + 0x9c, 0x5c, 0x49, 0xc6, 0x3f, 0xce, 0x43, 0x4d, 0x5b, 0x96, 0xaf, 0x72, 0xba, 0xde, 0x4e, 0xb9, + 0x16, 0xab, 0xba, 0x17, 0xf1, 0xcd, 0x78, 0x95, 0x05, 0x75, 0x77, 0x48, 0x5f, 0xc0, 0xb7, 0xa0, + 0xca, 0x76, 0xdd, 0x07, 0x68, 0x82, 0x15, 0x4f, 0x0e, 0x21, 0xe0, 0x68, 0x71, 0x22, 0x91, 0x8f, + 0x10, 0x59, 0x8a, 0x90, 0x8f, 0x18, 0xf2, 0x45, 0x77, 0x07, 0x3e, 0x81, 0xba, 0x28, 0x15, 0xe7, + 0x14, 0xbb, 0x1b, 0xed, 0xfa, 0xd8, 0x7c, 0x9b, 0x35, 0x5e, 0x1d, 0x9f, 0x7c, 0x91, 0xf1, 0x91, + 0xcc, 0x58, 0x79, 0x59, 0xc6, 0x47, 0x3c, 0x61, 0xec, 0xa9, 0xeb, 0x18, 0x18, 0xcc, 0x26, 0xf9, + 0xd8, 0xfb, 0xb0, 0x26, 0xd9, 0xd5, 0xc2, 0xb5, 0x5d, 0xd7, 0x5b, 0xb8, 0x63, 0x2a, 0x2f, 0x86, + 0x12, 0x81, 0x3a, 0x8e, 0x30, 0xc6, 0x44, 0xbd, 0x32, 0xc0, 0x83, 0xe2, 0xee, 0x43, 0x89, 0xcb, + 0xe5, 0x5c, 0xf8, 0xc8, 0x66, 0x5c, 0x9c, 0x84, 0xdc, 0x83, 0x12, 0x17, 0xcf, 0xf3, 0xd7, 0x32, + 0x1b, 0x4e, 0x60, 0xb4, 0x81, 0xb0, 0x8c, 0x87, 0x34, 0xf4, 0x9d, 0x71, 0x10, 0xdd, 0x39, 0x2d, + 0x31, 0xfd, 0x93, 0xd7, 0x15, 0x59, 0x6e, 0x23, 0x4a, 0xd4, 0x51, 0x39, 0x0d, 0x3b, 0x98, 0xd6, + 0x62, 0x65, 0x08, 0x71, 0x69, 0x0a, 0x9b, 0x27, 0x34, 0x7c, 0x4e, 0xa9, 0xeb, 0x32, 0x61, 0x68, + 0x4c, 0xdd, 0xd0, 0xb7, 0xa7, 0x6c, 0x92, 0x78, 0x0f, 0x1e, 0xa7, 0x4a, 0x8d, 0x6c, 0x20, 0x3b, + 0x51, 0xc6, 0x8e, 0xca, 0xc7, 0x79, 0xc7, 0xc6, 0x49, 0x16, 0x6e, 0xfb, 0x97, 0x61, 0xfb, 0xfa, + 0x4c, 0x19, 0xf7, 0xcd, 0xef, 0xc5, 0xb9, 0x8a, 0xf2, 0x03, 0x4e, 0x3d, 0x3b, 0xe4, 0xad, 0xd1, + 0x39, 0x4b, 0x1f, 0x6a, 0x1a, 0x26, 0x3a, 0xfb, 0x73, 0x28, 0xdc, 0xf1, 0x04, 0x3b, 0x91, 0x5c, + 0xcf, 0x9f, 0xa1, 0xdf, 0x6d, 0x62, 0x45, 0xa5, 0xe7, 0xcc, 0x95, 0x08, 0x8e, 0x61, 0x18, 0xc6, + 0x03, 0x58, 0x41, 0xc9, 0x5e, 0x3b, 0xe8, 0x5e, 0x24, 0x0c, 0x1a, 0xeb, 0x40, 0xfa, 0x9c, 0x77, + 0xe9, 0x01, 0x82, 0xff, 0xa6, 0x00, 0x35, 0x0d, 0xcc, 0x4e, 0x23, 0x8c, 0xaa, 0xb4, 0x26, 0x8e, + 0x3d, 0xa3, 0xd2, 0xc9, 0xd9, 0x30, 0x1b, 0x08, 0xdd, 0x15, 0x40, 0x76, 0x16, 0xdb, 0x17, 0x67, + 0x96, 0xb7, 0x08, 0xad, 0x09, 0x3d, 0xf3, 0xa9, 0x6c, 0x65, 0xdd, 0xbe, 0x38, 0x1b, 0x2c, 0xc2, + 0x5d, 0x84, 0x31, 0x2a, 0xc6, 0x4b, 0x34, 0x2a, 0x11, 0x64, 0x37, 0xb3, 0x2f, 0x23, 0x2a, 0x11, + 0x8d, 0xca, 0x57, 0x66, 0x51, 0x45, 0xa3, 0x72, 0x6d, 0x31, 0x79, 0x80, 0x96, 0xd2, 0x07, 0xe8, + 0x47, 0xb0, 0xc9, 0x0f, 0x50, 0xc1, 0x9a, 0xad, 0xc4, 0x4e, 0x5e, 0x47, 0xac, 0xe8, 0xa4, 0x26, + 0xf6, 0x36, 0x59, 0x0f, 0x24, 0x5b, 0x0a, 0x9c, 0x9f, 0x72, 0x46, 0x96, 0x33, 0x59, 0xcf, 0x44, + 0xe1, 0x43, 0xe7, 0xa7, 0x94, 0x51, 0x62, 0x38, 0x8f, 0x4e, 0x29, 0x6e, 0x06, 0xcd, 0x1c, 0x37, + 0x49, 0x69, 0x5f, 0xc6, 0x29, 0xab, 0x82, 0xd2, 0xbe, 0xd4, 0x29, 0x1f, 0xc3, 0xd6, 0x8c, 0x4e, + 0x1c, 0x3b, 0x5e, 0xac, 0x15, 0x09, 0x6e, 0xeb, 0x1c, 0xad, 0xe5, 0x19, 0x72, 0xc5, 0x9d, 0x8d, + 0xc6, 0x4f, 0xbd, 0xd9, 0x89, 0xc3, 0x65, 0x16, 0x1e, 0x60, 0x54, 0x34, 0x97, 0xdd, 0xc5, 0xec, + 0x97, 0x10, 0xcc, 0xb2, 0x04, 0x46, 0x03, 0x6a, 0xc3, 0xd0, 0x9b, 0xcb, 0x69, 0x5e, 0x86, 0x3a, + 0x4f, 0x8a, 0x3b, 0xd5, 0xb7, 0xe0, 0x26, 0xb2, 0x84, 0x91, 0x37, 0xf7, 0xa6, 0xde, 0xd9, 0x55, + 0xcc, 0x8e, 0xf7, 0xcf, 0x73, 0xb0, 0x16, 0xc3, 0x0a, 0xf6, 0xfa, 0x11, 0xe7, 0x67, 0xea, 0x46, + 0x68, 0x2e, 0x76, 0x1d, 0x88, 0xcd, 0x17, 0x27, 0xe4, 0xcc, 0x4c, 0xde, 0x12, 0x6d, 0x47, 0xcf, + 0xc2, 0xc8, 0x8c, 0x9c, 0xa5, 0xb4, 0xd2, 0x2c, 0x45, 0xe4, 0x97, 0x0f, 0xc6, 0xc8, 0x22, 0x7e, + 0x41, 0xdc, 0xde, 0x9a, 0x88, 0x2e, 0x17, 0xe2, 0xf7, 0x3b, 0x74, 0x9b, 0x9f, 0x6c, 0x41, 0x64, + 0x08, 0x0c, 0x8c, 0xbf, 0x95, 0x03, 0x88, 0x5a, 0x87, 0x37, 0x4c, 0x94, 0xdc, 0x92, 0xc3, 0xd8, + 0x5e, 0x4d, 0x46, 0x79, 0x03, 0xea, 0x2a, 0x0c, 0x3c, 0x92, 0x84, 0x6a, 0x12, 0xc6, 0xc4, 0xa1, + 0x77, 0x60, 0xe5, 0x6c, 0xea, 0x9d, 0xa0, 0xc4, 0x2a, 0xe4, 0x16, 0x1e, 0x45, 0xb0, 0xcc, 0xc1, + 0x52, 0x1a, 0x89, 0xe4, 0xa6, 0x62, 0x66, 0xa4, 0xb8, 0x2e, 0x05, 0x19, 0x7f, 0x21, 0xaf, 0x62, + 0x4d, 0xa3, 0x91, 0x78, 0xb1, 0x7a, 0xf7, 0xb3, 0x44, 0xe3, 0xbc, 0xc8, 0xbd, 0xf8, 0x39, 0x2c, + 0xfb, 0xfc, 0x50, 0x92, 0x27, 0x56, 0xf1, 0x05, 0x27, 0x56, 0xc3, 0x8f, 0x49, 0x3a, 0xdf, 0x85, + 0xa6, 0x3d, 0xb9, 0xa0, 0x7e, 0xe8, 0xa0, 0xb5, 0x1e, 0xe5, 0x63, 0x11, 0xdd, 0xa9, 0xc1, 0x51, + 0x10, 0x7d, 0x07, 0x56, 0xc4, 0x3d, 0x7f, 0x45, 0x29, 0xde, 0x1f, 0x8b, 0xc0, 0x8c, 0xd0, 0xf8, + 0x7b, 0x32, 0xb8, 0x35, 0x3e, 0xbb, 0x2f, 0x1e, 0x15, 0xbd, 0x87, 0xf9, 0xb4, 0x03, 0x55, 0x2c, + 0x24, 0xe1, 0x04, 0x10, 0xfc, 0x88, 0x03, 0x85, 0x0b, 0x20, 0x3e, 0xac, 0xc5, 0x57, 0x19, 0x56, + 0xe3, 0x5f, 0xe6, 0xa0, 0xbc, 0xef, 0xcd, 0xf7, 0x1d, 0x7e, 0x45, 0x02, 0xb7, 0x89, 0xf2, 0x51, + 0x2d, 0xb1, 0x24, 0x86, 0x0e, 0xbd, 0xe0, 0xa6, 0x64, 0xa6, 0x98, 0xd7, 0x88, 0x8b, 0x79, 0x3f, + 0x80, 0x5b, 0xe8, 0x02, 0xf4, 0xbd, 0xb9, 0xe7, 0xb3, 0xad, 0x6a, 0x4f, 0xb9, 0xb8, 0xe7, 0xb9, + 0xe1, 0xb9, 0xe4, 0x9d, 0x37, 0x4f, 0x29, 0x3d, 0xd2, 0x28, 0x0e, 0x15, 0x01, 0xde, 0x92, 0x9e, + 0x86, 0x17, 0x16, 0xd7, 0xd0, 0x85, 0x3c, 0xca, 0x39, 0xea, 0x0a, 0x43, 0x74, 0x11, 0x8e, 0x12, + 0xa9, 0xf1, 0x29, 0x54, 0x95, 0xb1, 0x87, 0xbc, 0x0b, 0xd5, 0x73, 0x6f, 0x2e, 0x2c, 0x42, 0xb9, + 0xd8, 0x6d, 0x52, 0xd1, 0x6b, 0xb3, 0x72, 0xce, 0x7f, 0x04, 0xc6, 0x1f, 0x96, 0xa1, 0xdc, 0x73, + 0x2f, 0x3c, 0x67, 0x8c, 0xe1, 0xb1, 0x33, 0x3a, 0xf3, 0xe4, 0x33, 0x24, 0xec, 0x37, 0x46, 0x77, + 0x45, 0xaf, 0x88, 0x15, 0x44, 0x74, 0x97, 0x7a, 0x3f, 0x6c, 0x03, 0x96, 0x7c, 0xfd, 0x19, 0xb0, + 0x92, 0x8f, 0x97, 0x0a, 0xd4, 0x79, 0x59, 0xd2, 0x1e, 0x77, 0x61, 0x65, 0xf1, 0xc8, 0x45, 0x1c, + 0x32, 0x7e, 0xd3, 0xb9, 0x8a, 0x10, 0x1c, 0xb0, 0xd7, 0xa0, 0x2c, 0x2e, 0x6f, 0xf2, 0xab, 0x64, + 0xfc, 0x16, 0x80, 0x00, 0xe1, 0x6a, 0xf0, 0x29, 0x77, 0xe1, 0x2a, 0x41, 0xb6, 0x60, 0xd6, 0x25, + 0x70, 0x97, 0xad, 0xb5, 0x3b, 0x50, 0xe3, 0xf4, 0x9c, 0xa4, 0x22, 0xa2, 0x4a, 0x11, 0x84, 0x04, + 0x19, 0xaf, 0xe9, 0x55, 0x33, 0x5f, 0xd3, 0xc3, 0xf8, 0x67, 0xc5, 0x65, 0x79, 0x17, 0x81, 0xbf, + 0xa1, 0xa6, 0xc1, 0xe5, 0x13, 0x95, 0xc2, 0xa6, 0xc2, 0x1f, 0x01, 0x90, 0x36, 0x95, 0x37, 0xa1, + 0x71, 0x6a, 0x4f, 0xa7, 0x27, 0xf6, 0xf8, 0x19, 0x37, 0x05, 0xd4, 0xb9, 0xf5, 0x53, 0x02, 0xd1, + 0x16, 0x70, 0x07, 0x6a, 0xda, 0x2c, 0x63, 0xc8, 0x68, 0xd1, 0x84, 0x68, 0x7e, 0x93, 0x16, 0xbe, + 0xe5, 0x57, 0xb0, 0xf0, 0x69, 0xa1, 0xb3, 0x2b, 0xf1, 0xd0, 0xd9, 0x5b, 0xc8, 0x4d, 0x45, 0xd0, + 0x62, 0x93, 0x3f, 0xd8, 0x65, 0x4f, 0x26, 0x18, 0xb4, 0x88, 0x86, 0x2c, 0x3e, 0x78, 0x1c, 0xbf, + 0xca, 0x75, 0x09, 0x0e, 0xe3, 0x24, 0xb7, 0xb9, 0x99, 0x7a, 0x6e, 0x3b, 0x13, 0xbc, 0xc9, 0xc1, + 0xad, 0x07, 0x65, 0x7b, 0x16, 0x1e, 0xd9, 0x0e, 0x86, 0x6b, 0x49, 0x34, 0x9e, 0x8e, 0x6b, 0x7c, + 0xfc, 0x05, 0x7a, 0xc8, 0x9f, 0xb8, 0x50, 0x14, 0x33, 0x75, 0x8b, 0xdf, 0xac, 0x09, 0x12, 0x5c, + 0x07, 0x1f, 0x60, 0x94, 0x4f, 0x48, 0xf1, 0x9e, 0xfe, 0xf2, 0xa3, 0x5b, 0x2a, 0xf8, 0x00, 0x57, + 0xa9, 0xfc, 0xcf, 0x9d, 0x63, 0x9c, 0x92, 0x09, 0x77, 0xdc, 0x47, 0xb7, 0x19, 0x93, 0x7f, 0x05, + 0x29, 0xfa, 0xe8, 0x38, 0x01, 0xf9, 0x54, 0xd3, 0x5f, 0x5b, 0x48, 0xfc, 0x5a, 0xa2, 0xfc, 0xeb, + 0xae, 0xca, 0xdd, 0x06, 0x70, 0x02, 0x76, 0xca, 0x04, 0xd4, 0x9d, 0xe0, 0x75, 0xfb, 0x8a, 0x59, + 0x75, 0x82, 0xa7, 0x1c, 0xf0, 0xed, 0x2a, 0xb6, 0x6d, 0xa8, 0xeb, 0xdd, 0x24, 0x15, 0x28, 0x0e, + 0x8e, 0xba, 0xfd, 0xe6, 0x0d, 0x52, 0x83, 0xf2, 0xb0, 0x3b, 0x1a, 0x1d, 0xa0, 0xa7, 0xaf, 0x0e, + 0x15, 0x75, 0x99, 0x36, 0xcf, 0x52, 0xed, 0x4e, 0xa7, 0x7b, 0x34, 0xea, 0xee, 0x36, 0x0b, 0x3f, + 0x2e, 0x56, 0xf2, 0xcd, 0x82, 0xf1, 0x47, 0x05, 0xa8, 0x69, 0xa3, 0xf0, 0x62, 0x66, 0x7c, 0x1b, + 0x00, 0x35, 0xc9, 0x28, 0xa6, 0xb5, 0x68, 0x56, 0x19, 0x84, 0x4f, 0xbe, 0xee, 0xa3, 0x10, 0x0f, + 0xcb, 0x48, 0x1f, 0xc5, 0x9b, 0xd0, 0xe0, 0x2f, 0x92, 0xe8, 0xfe, 0xda, 0x92, 0x59, 0xe7, 0x40, + 0xc1, 0xaa, 0xf1, 0x6a, 0x3e, 0x12, 0xe1, 0xa5, 0x47, 0xf1, 0x98, 0x12, 0x07, 0xe1, 0xb5, 0x47, + 0xbc, 0xb3, 0x1a, 0x78, 0xd3, 0x0b, 0xca, 0x29, 0xb8, 0x44, 0x58, 0x13, 0xb0, 0x91, 0x78, 0xf6, + 0x40, 0xf0, 0x43, 0xed, 0x6e, 0x78, 0xc9, 0xac, 0x73, 0xa0, 0xa8, 0xe8, 0x7b, 0x72, 0x01, 0xf1, + 0xe8, 0x95, 0xad, 0xf4, 0x6a, 0x88, 0x2d, 0x9e, 0x83, 0x94, 0x19, 0xb1, 0x8a, 0x0b, 0xe3, 0x3b, + 0xe9, 0x7c, 0x2f, 0x37, 0x27, 0x92, 0x77, 0x81, 0xcc, 0xe6, 0x73, 0x2b, 0xc3, 0xc0, 0x57, 0x34, + 0x57, 0x66, 0xf3, 0xf9, 0x48, 0xb3, 0x7f, 0x7d, 0x0b, 0xb6, 0xc7, 0xaf, 0x81, 0xb4, 0xd9, 0x06, + 0xc6, 0x26, 0x2a, 0x55, 0x2c, 0x62, 0xcb, 0x39, 0x9d, 0x2d, 0x67, 0x70, 0xbf, 0x7c, 0x26, 0xf7, + 0x7b, 0x11, 0x9f, 0x30, 0xf6, 0xa0, 0x76, 0xa4, 0x3d, 0xd9, 0x78, 0x97, 0x9d, 0x10, 0xf2, 0xb1, + 0x46, 0x7e, 0x76, 0x70, 0x9b, 0xa2, 0x2f, 0xde, 0x68, 0xd4, 0x5a, 0x93, 0xd7, 0x5a, 0x63, 0xfc, + 0x8d, 0x1c, 0x7f, 0xe2, 0x4a, 0x35, 0x3e, 0x7a, 0x25, 0x52, 0xba, 0xdf, 0xa2, 0x27, 0x1c, 0x6a, + 0xd2, 0xed, 0x26, 0x5e, 0x5f, 0xc0, 0xa6, 0x59, 0xde, 0xe9, 0x69, 0x40, 0x65, 0x8c, 0x47, 0x0d, + 0x61, 0x03, 0x04, 0x49, 0xe1, 0x9b, 0x49, 0xf8, 0x0e, 0x2f, 0x3f, 0x10, 0x81, 0x1d, 0x4c, 0xf8, + 0x3e, 0xb4, 0x2f, 0x45, 0xad, 0x01, 0x13, 0x41, 0x84, 0x7f, 0x40, 0x5e, 0x61, 0x56, 0x69, 0xe3, + 0xaf, 0x8a, 0x57, 0x26, 0x92, 0xe3, 0x7b, 0x1f, 0x2a, 0xaa, 0xd4, 0xf8, 0x09, 0x2b, 0x29, 0x15, + 0x9e, 0x9d, 0xe3, 0x68, 0x0c, 0x89, 0xb5, 0x98, 0x6f, 0x2e, 0xf4, 0xf1, 0xf4, 0xb4, 0x56, 0xbf, + 0x07, 0xe4, 0xd4, 0xf1, 0x93, 0xc4, 0x7c, 0xb3, 0x35, 0x11, 0xa3, 0x51, 0x1b, 0xc7, 0xb0, 0x26, + 0xb9, 0x84, 0xa6, 0x11, 0xc4, 0x27, 0x2f, 0xf7, 0x12, 0x26, 0x9f, 0x4f, 0x31, 0x79, 0xe3, 0x37, + 0x4a, 0x50, 0x96, 0xcf, 0x9f, 0x66, 0x3d, 0xd9, 0x59, 0x8d, 0x3f, 0xd9, 0xd9, 0x8a, 0x3d, 0xe4, + 0x86, 0x53, 0x2f, 0xce, 0xfb, 0x77, 0x92, 0x47, 0xb6, 0xe6, 0xab, 0x88, 0x1d, 0xdb, 0xc2, 0x57, + 0x51, 0x8a, 0xfb, 0x2a, 0xb2, 0x9e, 0x31, 0xe5, 0xa2, 0x67, 0xea, 0x19, 0xd3, 0x5b, 0xc0, 0xe5, + 0x08, 0x2d, 0xb8, 0xad, 0x82, 0x00, 0x71, 0x0d, 0x5f, 0x13, 0x3b, 0x2a, 0x49, 0xb1, 0xe3, 0x95, + 0x45, 0x82, 0x8f, 0x60, 0x89, 0xbf, 0x58, 0x23, 0xae, 0x64, 0xcb, 0x83, 0x43, 0x8c, 0x95, 0xfc, + 0xcf, 0xef, 0x4c, 0x98, 0x82, 0x56, 0x7f, 0x13, 0xb0, 0x16, 0x7b, 0x13, 0x50, 0xf7, 0xa1, 0xd4, + 0xe3, 0x3e, 0x94, 0x7b, 0xd0, 0x54, 0x03, 0x87, 0x16, 0x49, 0x37, 0x10, 0xd7, 0x31, 0x97, 0x25, + 0x9c, 0x71, 0xc3, 0x7e, 0x10, 0x1d, 0x7c, 0xcb, 0xb1, 0x83, 0x8f, 0xf1, 0xaa, 0x76, 0x18, 0xd2, + 0xd9, 0x3c, 0x94, 0x07, 0x9f, 0xf6, 0x72, 0x2c, 0x9f, 0x79, 0x7e, 0x5f, 0x44, 0x4e, 0x2f, 0x5f, + 0x1d, 0x3b, 0xb0, 0x7c, 0x6a, 0x3b, 0xd3, 0x85, 0x4f, 0x2d, 0x9f, 0xda, 0x81, 0xe7, 0xe2, 0xe6, + 0x8f, 0xce, 0x60, 0xd1, 0xc5, 0x3d, 0x4e, 0x63, 0x22, 0x89, 0xd9, 0x38, 0xd5, 0x93, 0x78, 0xeb, + 0x4a, 0x1f, 0x09, 0x76, 0x64, 0x89, 0x8b, 0xd9, 0x3c, 0x56, 0xa5, 0xd7, 0xb7, 0xf6, 0x0e, 0x7a, + 0x4f, 0xf6, 0x47, 0xcd, 0x1c, 0x4b, 0x0e, 0x8f, 0x3b, 0x9d, 0x6e, 0x77, 0x17, 0x8f, 0x30, 0x80, + 0xa5, 0xbd, 0x76, 0xef, 0x40, 0x1c, 0x60, 0xc5, 0x66, 0xc9, 0xf8, 0x47, 0x79, 0xa8, 0x69, 0xbd, + 0x21, 0x8f, 0xd5, 0x24, 0xf0, 0xa7, 0x20, 0x6e, 0xa7, 0x7b, 0xfc, 0x40, 0x72, 0x78, 0x6d, 0x16, + 0xd4, 0x1b, 0xb1, 0xf9, 0x6b, 0xdf, 0x88, 0x25, 0x6f, 0xc3, 0x8a, 0xcd, 0x4b, 0x50, 0x83, 0x2e, + 0x8c, 0xfb, 0x02, 0x2c, 0xc6, 0xfc, 0x6d, 0xf1, 0x2c, 0x85, 0x38, 0xa6, 0x18, 0x5d, 0x51, 0x06, + 0x6d, 0xaa, 0x93, 0x0a, 0xe7, 0xa6, 0x2c, 0x46, 0x46, 0x38, 0xe3, 0xd5, 0x81, 0x2f, 0xc6, 0x4b, + 0xa2, 0xf9, 0x55, 0x4c, 0x6d, 0x85, 0xd7, 0x4d, 0x95, 0x36, 0x3e, 0x06, 0x88, 0xfa, 0x13, 0x1f, + 0xbe, 0x1b, 0xf1, 0xe1, 0xcb, 0x69, 0xc3, 0x97, 0x37, 0xfe, 0xae, 0x60, 0x5d, 0x62, 0x2e, 0x94, + 0xa9, 0xef, 0x7b, 0x20, 0x8d, 0x8f, 0x16, 0x06, 0x79, 0xcf, 0xa7, 0x34, 0x94, 0xb7, 0x49, 0x57, + 0x05, 0xa6, 0xa7, 0x10, 0x29, 0x56, 0x9b, 0x4f, 0xb3, 0xda, 0x37, 0xa0, 0x8e, 0xef, 0x9c, 0x89, + 0x8a, 0x04, 0xbb, 0xaa, 0xcd, 0xec, 0x4b, 0x59, 0x77, 0x8c, 0xc7, 0x16, 0x13, 0x3c, 0xf6, 0xaf, + 0xe5, 0xf8, 0xa3, 0x38, 0x51, 0x43, 0x23, 0x26, 0xab, 0xca, 0x8c, 0x33, 0x59, 0x41, 0x6a, 0x2a, + 0xfc, 0x35, 0x8c, 0x33, 0x9f, 0xcd, 0x38, 0xb3, 0x59, 0x72, 0x21, 0x93, 0x25, 0x1b, 0xdb, 0xd0, + 0xda, 0xa5, 0x6c, 0x28, 0xda, 0xd3, 0x69, 0x62, 0x2c, 0x8d, 0x5b, 0x70, 0x33, 0x03, 0x27, 0xac, + 0x36, 0xbf, 0x99, 0x83, 0x8d, 0x36, 0x7f, 0x0b, 0xe3, 0x5b, 0xbb, 0xee, 0xf9, 0x19, 0xdc, 0x54, + 0x11, 0xdb, 0xda, 0x2d, 0x32, 0xfd, 0x21, 0x23, 0x19, 0xec, 0xad, 0xdd, 0x53, 0x60, 0x67, 0xa6, + 0xd1, 0x82, 0xcd, 0x64, 0x6b, 0x44, 0x43, 0xf7, 0x60, 0x75, 0x97, 0x9e, 0x2c, 0xce, 0x0e, 0xe8, + 0x45, 0xd4, 0x46, 0x02, 0xc5, 0xe0, 0xdc, 0x7b, 0x2e, 0x16, 0x06, 0xfe, 0xc6, 0x90, 0x4e, 0x46, + 0x63, 0x05, 0x73, 0x3a, 0x96, 0x56, 0x7f, 0x84, 0x0c, 0xe7, 0x74, 0x6c, 0x3c, 0x06, 0xa2, 0x97, + 0x23, 0x66, 0x91, 0xa9, 0x64, 0x8b, 0x13, 0x2b, 0xb8, 0x0a, 0x42, 0x3a, 0x93, 0x37, 0x24, 0x21, + 0x58, 0x9c, 0x0c, 0x39, 0xc4, 0x78, 0x07, 0xea, 0x47, 0xf6, 0x95, 0x49, 0xbf, 0x16, 0x17, 0x11, + 0xb7, 0xa0, 0x3c, 0xb7, 0xaf, 0x18, 0x2f, 0x56, 0x0e, 0x40, 0x44, 0x1b, 0x7f, 0xbf, 0x08, 0x4b, + 0x9c, 0x92, 0xdc, 0xe5, 0xaf, 0xb7, 0x3b, 0x2e, 0xf2, 0x42, 0x79, 0x2a, 0x69, 0xa0, 0xd4, 0xc1, + 0x95, 0x4f, 0x1f, 0x5c, 0xc2, 0x5a, 0x29, 0x1f, 0x5a, 0x93, 0xae, 0x1a, 0x77, 0x31, 0x93, 0xaf, + 0xab, 0xc5, 0x9f, 0x82, 0x28, 0x46, 0xaf, 0xfe, 0xf3, 0x6b, 0xf0, 0x71, 0x67, 0x7a, 0xa4, 0xf8, + 0xf1, 0xd6, 0xc9, 0xf3, 0x58, 0x9c, 0x59, 0x3a, 0x28, 0x53, 0xbb, 0x2c, 0xcb, 0xdb, 0xb5, 0x71, + 0xed, 0x32, 0xa5, 0x45, 0x56, 0x5e, 0xae, 0x45, 0x72, 0x33, 0xe6, 0x0b, 0xb4, 0x48, 0x78, 0x05, + 0x2d, 0xf2, 0x15, 0x1c, 0xd9, 0x37, 0xa1, 0x82, 0x42, 0x96, 0x76, 0x84, 0x31, 0xe1, 0x8a, 0x1d, + 0x61, 0x9f, 0x68, 0x7a, 0x16, 0x8f, 0xa2, 0xd1, 0xce, 0x10, 0x93, 0x7e, 0xfd, 0xf3, 0x71, 0x10, + 0x7e, 0x05, 0x65, 0x01, 0x65, 0x0b, 0xda, 0xb5, 0x67, 0xf2, 0x31, 0x4f, 0xfc, 0xcd, 0x86, 0x0d, + 0x1f, 0xd8, 0xfb, 0x7a, 0xe1, 0xf8, 0x74, 0x22, 0x9f, 0xf9, 0x72, 0x70, 0x7f, 0x33, 0x08, 0xeb, + 0x20, 0xd3, 0xf9, 0x5c, 0xef, 0xb9, 0x2b, 0xf8, 0x56, 0xd9, 0x09, 0x9e, 0xb2, 0xa4, 0x41, 0xa0, + 0x89, 0x4f, 0xff, 0xce, 0x3d, 0x5f, 0x4a, 0x08, 0xc6, 0xef, 0xe6, 0xa0, 0x29, 0x76, 0x97, 0xc2, + 0xe9, 0x2a, 0x57, 0xe9, 0xba, 0xa0, 0x8f, 0x17, 0x3f, 0xda, 0x65, 0x40, 0x03, 0x2d, 0x4d, 0x4a, + 0x5c, 0xe0, 0x96, 0xb2, 0x1a, 0x03, 0xee, 0x09, 0x91, 0xe1, 0x75, 0xa8, 0xc9, 0x80, 0xf3, 0x99, + 0x33, 0x95, 0x1f, 0xf8, 0xe0, 0x11, 0xe7, 0x87, 0xce, 0x54, 0x4a, 0x1b, 0xbe, 0x2d, 0x6e, 0x7b, + 0xe7, 0x50, 0xda, 0x30, 0xed, 0x90, 0x1a, 0xff, 0x30, 0x07, 0xab, 0x5a, 0x57, 0xc4, 0xbe, 0xfd, + 0x3e, 0xd4, 0xd5, 0x9b, 0xdb, 0x54, 0x89, 0xb9, 0x5b, 0x71, 0x1e, 0x15, 0x65, 0xab, 0x8d, 0x15, + 0x24, 0x60, 0x8d, 0x99, 0xd8, 0x57, 0x3c, 0x2a, 0x7a, 0x31, 0x93, 0x9a, 0xe4, 0xc4, 0xbe, 0xda, + 0xa3, 0x74, 0xb8, 0x98, 0x91, 0xbb, 0x50, 0x7f, 0x4e, 0xe9, 0x33, 0x45, 0xc0, 0x59, 0x2f, 0x30, + 0x98, 0xa0, 0x30, 0xa0, 0x31, 0xf3, 0xdc, 0xf0, 0x5c, 0x91, 0x08, 0x11, 0x1f, 0x81, 0x9c, 0xc6, + 0xf8, 0x83, 0x3c, 0xac, 0x71, 0x7b, 0xa6, 0xb0, 0x23, 0x0b, 0xd6, 0xd5, 0x82, 0x25, 0x6e, 0xda, + 0xe5, 0xcc, 0x6b, 0xff, 0x86, 0x29, 0xd2, 0xe4, 0xa3, 0x57, 0xb4, 0xc1, 0xca, 0x0b, 0xe5, 0xd7, + 0x0c, 0x7f, 0x21, 0x3d, 0xfc, 0xd7, 0x0f, 0x6f, 0x96, 0x57, 0xb9, 0x94, 0xe5, 0x55, 0x7e, 0x15, + 0x5f, 0x6e, 0xea, 0xea, 0x73, 0x39, 0xfd, 0x42, 0xe8, 0x63, 0xd8, 0x8a, 0xd1, 0x20, 0xb7, 0x76, + 0x4e, 0x1d, 0x2a, 0xdf, 0x20, 0x5a, 0xd7, 0xa8, 0x87, 0x12, 0xb7, 0x53, 0x86, 0x52, 0x30, 0xf6, + 0xe6, 0xd4, 0xd8, 0x84, 0xf5, 0xf8, 0xa8, 0x8a, 0x63, 0xe2, 0xb7, 0x73, 0xd0, 0x12, 0x31, 0x40, + 0x8e, 0x7b, 0xb6, 0xef, 0x04, 0xa1, 0xe7, 0xab, 0xb7, 0xa9, 0x6f, 0x03, 0xf0, 0x8f, 0x8d, 0xa0, + 0xe2, 0x2e, 0x1e, 0xcd, 0x41, 0x08, 0xaa, 0xed, 0x37, 0xa1, 0x42, 0xdd, 0x09, 0x47, 0xf2, 0xd5, + 0x50, 0xa6, 0xee, 0x44, 0x2a, 0xfd, 0xa9, 0x63, 0xb8, 0x11, 0x17, 0x30, 0xc4, 0xf3, 0x0f, 0x6c, + 0x74, 0xe8, 0x05, 0x8a, 0x03, 0x45, 0xf5, 0xfc, 0xc3, 0xa1, 0x7d, 0x89, 0x11, 0xb5, 0x81, 0xf1, + 0x17, 0xf3, 0xb0, 0x12, 0xb5, 0x8f, 0x3f, 0x80, 0xf3, 0xe2, 0xa7, 0x7c, 0xee, 0x8a, 0xe5, 0xe0, + 0x30, 0x65, 0x49, 0xb3, 0xf2, 0x56, 0xf8, 0xe6, 0xec, 0xb9, 0xc4, 0x80, 0x9a, 0xa4, 0xf0, 0x16, + 0xa1, 0xf6, 0xaa, 0x69, 0x95, 0x93, 0x0c, 0x16, 0x21, 0xd3, 0x6e, 0x99, 0x9a, 0xef, 0xb8, 0x42, + 0xbf, 0x2c, 0xd9, 0xb3, 0xb0, 0x87, 0x5f, 0xb4, 0x61, 0x60, 0x96, 0x8d, 0x4f, 0x24, 0xa3, 0x62, + 0xf4, 0x4d, 0xae, 0xec, 0xf0, 0x99, 0x43, 0x45, 0x47, 0xd7, 0x04, 0xf8, 0x23, 0xfc, 0x4a, 0x13, + 0x78, 0x1d, 0x6a, 0xbc, 0xf0, 0xe8, 0xa6, 0x3b, 0x3e, 0x31, 0x16, 0xf6, 0x5c, 0xc4, 0x0b, 0x8b, + 0x9b, 0xb7, 0x88, 0xd9, 0x19, 0x80, 0x57, 0x85, 0x21, 0x36, 0xbf, 0x99, 0x83, 0x9b, 0x19, 0xd3, + 0x26, 0x76, 0x79, 0x07, 0x56, 0x4f, 0x15, 0x52, 0x8e, 0x2e, 0xdf, 0xea, 0x9b, 0x92, 0xad, 0xc6, + 0xc7, 0xd4, 0x6c, 0x9e, 0xc6, 0x01, 0x91, 0x86, 0xcb, 0x67, 0x30, 0xf6, 0x8e, 0x02, 0x8a, 0x53, + 0x7c, 0x1a, 0xb9, 0x72, 0x79, 0x04, 0xdb, 0xdd, 0x4b, 0xc6, 0x31, 0x54, 0x58, 0xee, 0xf8, 0xd9, + 0x42, 0x7a, 0xbe, 0x12, 0xd6, 0xfc, 0xdc, 0x2b, 0x59, 0xf3, 0x27, 0xfc, 0x26, 0xb4, 0x2a, 0xeb, + 0x67, 0x29, 0x04, 0x0f, 0x50, 0x96, 0xe7, 0x04, 0x8b, 0x90, 0x0f, 0x2a, 0x30, 0x10, 0x2f, 0xd4, + 0x08, 0x60, 0xe5, 0x70, 0x31, 0x0d, 0x9d, 0x8e, 0x02, 0x91, 0x8f, 0x44, 0x1e, 0xac, 0x47, 0x8e, + 0x5a, 0x66, 0x45, 0xa0, 0x2a, 0xc2, 0xc1, 0x9a, 0xb1, 0x82, 0xac, 0x74, 0x7d, 0x2b, 0xb3, 0x78, + 0x0d, 0xc6, 0x4d, 0xd8, 0x8a, 0x52, 0x7c, 0xd8, 0xe4, 0x51, 0xf3, 0xd7, 0x73, 0x3c, 0x7c, 0x9f, + 0xe3, 0x86, 0xae, 0x3d, 0x0f, 0xce, 0xbd, 0x90, 0x74, 0x61, 0x2d, 0x70, 0xdc, 0xb3, 0x29, 0xd5, + 0x8b, 0x0f, 0xc4, 0x20, 0x6c, 0xc4, 0xdb, 0xc6, 0xb3, 0x06, 0xe6, 0x2a, 0xcf, 0x11, 0x95, 0x16, + 0x90, 0x9d, 0xeb, 0x1a, 0x19, 0x2d, 0x8b, 0xc4, 0x68, 0xa4, 0x1b, 0xdf, 0x83, 0xe5, 0x78, 0x45, + 0xe4, 0x13, 0xf1, 0x80, 0x40, 0xd4, 0xaa, 0x42, 0xe2, 0xfa, 0x74, 0xb4, 0x20, 0x6a, 0xd1, 0xd8, + 0x07, 0xc6, 0x9f, 0xcf, 0x41, 0xcb, 0xa4, 0x6c, 0xe5, 0x6a, 0xad, 0x94, 0x6b, 0xe6, 0xfb, 0xa9, + 0x52, 0xaf, 0xef, 0xab, 0x7c, 0x97, 0x40, 0xb6, 0xe8, 0xbd, 0x6b, 0x27, 0x63, 0xff, 0x46, 0xaa, + 0x47, 0x3b, 0x15, 0x58, 0xe2, 0x24, 0xc6, 0x16, 0x6c, 0x88, 0xf6, 0xc8, 0xb6, 0x44, 0xae, 0xda, + 0x58, 0x8d, 0x31, 0x57, 0xed, 0x36, 0xb4, 0xf8, 0x3d, 0x5f, 0xbd, 0x13, 0x22, 0xe3, 0x2e, 0x90, + 0x43, 0x7b, 0x6c, 0xfb, 0x9e, 0xe7, 0x1e, 0x51, 0x5f, 0x04, 0x43, 0xa3, 0x84, 0x89, 0x9e, 0x4c, + 0x29, 0x0a, 0xf3, 0x94, 0x7c, 0xcb, 0xd9, 0x73, 0x65, 0xec, 0x17, 0x4f, 0x19, 0x3e, 0xac, 0xed, + 0xd8, 0xcf, 0xa8, 0x2c, 0x49, 0x0e, 0xd1, 0xe7, 0x50, 0x9b, 0xab, 0x42, 0xe5, 0xb8, 0xcb, 0xf7, + 0x54, 0xd2, 0xd5, 0x9a, 0x3a, 0x35, 0x63, 0x41, 0xbe, 0xe7, 0x85, 0xf8, 0x76, 0x81, 0x74, 0x86, + 0x99, 0x55, 0x06, 0x7a, 0x4a, 0xaf, 0x7a, 0x13, 0xe3, 0x11, 0xac, 0xc7, 0xeb, 0x14, 0xac, 0x65, + 0x1b, 0x2a, 0x33, 0x01, 0x13, 0xad, 0x57, 0x69, 0xa6, 0x8c, 0x30, 0x95, 0x4f, 0xe6, 0xe9, 0xed, + 0x2a, 0x95, 0xea, 0x73, 0xd8, 0x4a, 0x61, 0x44, 0x81, 0x77, 0xa1, 0xae, 0x35, 0x84, 0x77, 0xa3, + 0xc8, 0x44, 0x56, 0xd1, 0x92, 0xc0, 0xf8, 0x0c, 0xb6, 0xb8, 0x3e, 0x16, 0x65, 0x97, 0x43, 0x90, + 0xe8, 0x45, 0x2e, 0xd9, 0x8b, 0x8f, 0xa4, 0x9a, 0xa7, 0x67, 0x8d, 0xae, 0x0a, 0x4c, 0x10, 0x27, + 0xc3, 0x77, 0x64, 0xd2, 0x38, 0x86, 0xcd, 0xf4, 0xf0, 0xb1, 0xf6, 0xff, 0xa9, 0x86, 0x5c, 0x0e, + 0x4f, 0x84, 0x56, 0xc3, 0xf3, 0x9f, 0x72, 0x7c, 0x7c, 0x62, 0x28, 0xd1, 0xcc, 0x09, 0x90, 0x19, + 0x0d, 0xcf, 0xbd, 0x89, 0x95, 0xae, 0xf9, 0xb1, 0x8a, 0x1e, 0xca, 0xcc, 0xfb, 0xe0, 0x10, 0x33, + 0x6a, 0x18, 0x11, 0xc7, 0x3e, 0x4b, 0xc2, 0xb7, 0xc7, 0xb0, 0x99, 0x4d, 0x9c, 0x11, 0x73, 0xf3, + 0x61, 0x5c, 0x50, 0xbf, 0x7d, 0x6d, 0xf7, 0x59, 0xb3, 0x74, 0xb9, 0xfd, 0xb7, 0x2a, 0x50, 0x16, + 0x56, 0x12, 0xf2, 0x00, 0x8a, 0x63, 0x19, 0xbf, 0x19, 0xbd, 0x55, 0x27, 0xb0, 0xf2, 0x7f, 0x07, + 0xa3, 0x38, 0x19, 0x1d, 0xf9, 0x1c, 0x96, 0xe3, 0x21, 0x0c, 0x89, 0x77, 0x2c, 0xe2, 0xb1, 0x07, + 0x8d, 0x71, 0xc2, 0x59, 0x5d, 0x8d, 0x84, 0x2b, 0x2e, 0x73, 0x56, 0xce, 0x35, 0xe9, 0xcb, 0x73, + 0x99, 0xbe, 0x16, 0x9c, 0xdb, 0xd6, 0xa3, 0xc7, 0x1f, 0x8b, 0x87, 0x2c, 0x6a, 0x08, 0x1c, 0x9e, + 0xdb, 0x8f, 0x1e, 0x7f, 0x9c, 0xd4, 0xc4, 0xc4, 0x33, 0x16, 0x9a, 0x26, 0xb6, 0x0e, 0x25, 0xfe, + 0xe0, 0x35, 0x0f, 0xc4, 0xe3, 0x09, 0xf2, 0x10, 0xd6, 0xa5, 0xe1, 0x4d, 0x5c, 0x99, 0xe0, 0xa7, + 0x68, 0x85, 0xdf, 0x52, 0x15, 0xb8, 0x21, 0xa2, 0xb8, 0xa9, 0x6e, 0x13, 0x96, 0xce, 0xa3, 0x17, + 0xcc, 0x1b, 0xa6, 0x48, 0x19, 0x7f, 0x50, 0x82, 0x9a, 0x36, 0x28, 0xa4, 0x0e, 0x15, 0xb3, 0x3b, + 0xec, 0x9a, 0x5f, 0x74, 0x77, 0x9b, 0x37, 0xc8, 0x3d, 0x78, 0xab, 0xd7, 0xef, 0x0c, 0x4c, 0xb3, + 0xdb, 0x19, 0x59, 0x03, 0xd3, 0x92, 0x2f, 0x26, 0x1e, 0xb5, 0xbf, 0x3a, 0xec, 0xf6, 0x47, 0xd6, + 0x6e, 0x77, 0xd4, 0xee, 0x1d, 0x0c, 0x9b, 0x39, 0xf2, 0x1a, 0xb4, 0x22, 0x4a, 0x89, 0x6e, 0x1f, + 0x0e, 0x8e, 0xfb, 0xa3, 0x66, 0x9e, 0xdc, 0x81, 0x5b, 0x7b, 0xbd, 0x7e, 0xfb, 0xc0, 0x8a, 0x68, + 0x3a, 0x07, 0xa3, 0x2f, 0xac, 0xee, 0x2f, 0x1e, 0xf5, 0xcc, 0xaf, 0x9a, 0x85, 0x2c, 0x82, 0xfd, + 0xd1, 0x41, 0x47, 0x96, 0x50, 0x24, 0x37, 0x61, 0x83, 0x13, 0xf0, 0x2c, 0xd6, 0x68, 0x30, 0xb0, + 0x86, 0x83, 0x41, 0xbf, 0x59, 0x22, 0xab, 0xd0, 0xe8, 0xf5, 0xbf, 0x68, 0x1f, 0xf4, 0x76, 0x2d, + 0xb3, 0xdb, 0x3e, 0x38, 0x6c, 0x2e, 0x91, 0x35, 0x58, 0x49, 0xd2, 0x95, 0x59, 0x11, 0x92, 0x6e, + 0xd0, 0xef, 0x0d, 0xfa, 0xd6, 0x17, 0x5d, 0x73, 0xd8, 0x1b, 0xf4, 0x9b, 0x15, 0xb2, 0x09, 0x24, + 0x8e, 0xda, 0x3f, 0x6c, 0x77, 0x9a, 0x55, 0xb2, 0x01, 0xab, 0x71, 0xf8, 0xd3, 0xee, 0x57, 0x4d, + 0x20, 0x2d, 0x58, 0xe7, 0x0d, 0xb3, 0x76, 0xba, 0x07, 0x83, 0x2f, 0xad, 0xc3, 0x5e, 0xbf, 0x77, + 0x78, 0x7c, 0xd8, 0xac, 0xe1, 0xbb, 0xb5, 0xdd, 0xae, 0xd5, 0xeb, 0x0f, 0x8f, 0xf7, 0xf6, 0x7a, + 0x9d, 0x5e, 0xb7, 0x3f, 0x6a, 0xd6, 0x79, 0xcd, 0x59, 0x1d, 0x6f, 0xb0, 0x0c, 0xe2, 0x5e, 0x95, + 0xb5, 0xdb, 0x1b, 0xb6, 0x77, 0x0e, 0xba, 0xbb, 0xcd, 0x65, 0x72, 0x1b, 0x6e, 0x8e, 0xba, 0x87, + 0x47, 0x03, 0xb3, 0x6d, 0x7e, 0x25, 0xef, 0x5d, 0x59, 0x7b, 0xed, 0xde, 0xc1, 0xb1, 0xd9, 0x6d, + 0xae, 0x90, 0x37, 0xe0, 0xb6, 0xd9, 0xfd, 0xc9, 0x71, 0xcf, 0xec, 0xee, 0x5a, 0xfd, 0xc1, 0x6e, + 0xd7, 0xda, 0xeb, 0xb6, 0x47, 0xc7, 0x66, 0xd7, 0x3a, 0xec, 0x0d, 0x87, 0xbd, 0xfe, 0x93, 0x66, + 0x93, 0xbc, 0x05, 0x77, 0x15, 0x89, 0x2a, 0x20, 0x41, 0xb5, 0xca, 0xfa, 0x27, 0xa7, 0xb4, 0xdf, + 0xfd, 0xc5, 0x91, 0x75, 0xd4, 0xed, 0x9a, 0x4d, 0x42, 0xb6, 0x61, 0x33, 0xaa, 0x9e, 0x57, 0x20, + 0xea, 0x5e, 0x63, 0xb8, 0xa3, 0xae, 0x79, 0xd8, 0xee, 0xb3, 0x09, 0x8e, 0xe1, 0xd6, 0x59, 0xb3, + 0x23, 0x5c, 0xb2, 0xd9, 0x1b, 0x84, 0xc0, 0xb2, 0x36, 0x2b, 0x7b, 0x6d, 0xb3, 0xb9, 0x49, 0x56, + 0xa0, 0x76, 0x78, 0x74, 0x64, 0x8d, 0x7a, 0x87, 0xdd, 0xc1, 0xf1, 0xa8, 0xb9, 0x45, 0x36, 0xa0, + 0xd9, 0xeb, 0x8f, 0xba, 0x26, 0x9b, 0x6b, 0x99, 0xf5, 0x3f, 0x97, 0xc9, 0x3a, 0xac, 0xc8, 0x96, + 0x4a, 0xe8, 0x1f, 0x97, 0xc9, 0x16, 0x90, 0xe3, 0xbe, 0xd9, 0x6d, 0xef, 0xb2, 0x81, 0x53, 0x88, + 0xff, 0x52, 0x16, 0xee, 0xcc, 0xdf, 0x2d, 0x28, 0x61, 0x2f, 0x8a, 0x0f, 0x8a, 0x7f, 0xf0, 0xa3, + 0xae, 0x7d, 0xa8, 0xe3, 0x65, 0x9f, 0xed, 0xd2, 0x54, 0xf3, 0x42, 0x4a, 0x35, 0x4f, 0xd9, 0x7e, + 0x1a, 0xba, 0xee, 0xf0, 0x26, 0x34, 0x66, 0xfc, 0xe3, 0x1f, 0xe2, 0xfd, 0x7a, 0x10, 0xc1, 0x72, + 0x1c, 0xc8, 0x1f, 0xaf, 0x4f, 0x7d, 0xb7, 0xaa, 0x94, 0xfe, 0x6e, 0x55, 0x96, 0x7e, 0xb8, 0x94, + 0xa5, 0x1f, 0xde, 0x87, 0x55, 0xce, 0x9a, 0x1c, 0xd7, 0x99, 0x49, 0xab, 0x0b, 0xd7, 0x22, 0x56, + 0x90, 0x45, 0x71, 0xb8, 0x54, 0x47, 0xa5, 0xca, 0x2a, 0x58, 0x48, 0x59, 0x68, 0xab, 0x31, 0x4d, + 0x95, 0x73, 0x0e, 0xa5, 0xa9, 0xaa, 0x1a, 0xec, 0xcb, 0xa8, 0x86, 0x9a, 0x56, 0x03, 0x87, 0x63, + 0x0d, 0xf7, 0x61, 0x95, 0x5e, 0x86, 0xbe, 0x6d, 0x79, 0x73, 0xfb, 0xeb, 0x05, 0xc6, 0x5b, 0xd8, + 0x68, 0x03, 0xaa, 0x9b, 0x2b, 0x88, 0x18, 0x20, 0x7c, 0xd7, 0x0e, 0x6d, 0xe3, 0x57, 0x00, 0xd4, + 0xa9, 0x3a, 0x61, 0x0c, 0xd0, 0xf5, 0xe4, 0xb5, 0xbb, 0xba, 0xc9, 0x13, 0x38, 0x8f, 0xa1, 0xe7, + 0xdb, 0x67, 0xb4, 0x27, 0xdf, 0x82, 0x89, 0x00, 0xe4, 0x16, 0x14, 0xbc, 0xb9, 0x0c, 0x25, 0xab, + 0xca, 0x07, 0x99, 0xe7, 0x26, 0x83, 0x1a, 0x1f, 0x43, 0x7e, 0x30, 0xbf, 0x56, 0x54, 0x6a, 0x41, + 0x59, 0x7e, 0xa9, 0x32, 0x8f, 0xe1, 0x63, 0x32, 0x79, 0xff, 0xff, 0x85, 0x9a, 0xf6, 0xbd, 0x1a, + 0xb2, 0x05, 0x6b, 0x5f, 0xf6, 0x46, 0xfd, 0xee, 0x70, 0x68, 0x1d, 0x1d, 0xef, 0x3c, 0xed, 0x7e, + 0x65, 0xed, 0xb7, 0x87, 0xfb, 0xcd, 0x1b, 0x8c, 0x97, 0xf4, 0xbb, 0xc3, 0x51, 0x77, 0x37, 0x06, + 0xcf, 0x91, 0xd7, 0x61, 0xfb, 0xb8, 0x7f, 0x3c, 0xec, 0xee, 0x5a, 0x59, 0xf9, 0xf2, 0x6c, 0xf3, + 0x08, 0x7c, 0x46, 0xf6, 0xc2, 0xfd, 0x5f, 0x85, 0xe5, 0xf8, 0xcb, 0x08, 0x04, 0x60, 0xe9, 0xa0, + 0xfb, 0xa4, 0xdd, 0xf9, 0x8a, 0x3f, 0xb8, 0x3d, 0x1c, 0xb5, 0x47, 0xbd, 0x8e, 0x25, 0x1e, 0xd8, + 0x66, 0x8c, 0x2a, 0x47, 0x6a, 0x50, 0x6e, 0xf7, 0x3b, 0xfb, 0x03, 0x73, 0xd8, 0xcc, 0x93, 0xd7, + 0x60, 0x4b, 0x6e, 0xa1, 0xce, 0xe0, 0xf0, 0xb0, 0x37, 0x42, 0x1e, 0x3d, 0xfa, 0xea, 0x88, 0xed, + 0x98, 0xfb, 0x36, 0x54, 0xa3, 0xb7, 0xc1, 0x91, 0xef, 0xf5, 0x46, 0xbd, 0xf6, 0x28, 0x62, 0xfa, + 0xcd, 0x1b, 0x8c, 0xad, 0x46, 0x60, 0x7c, 0xe0, 0xbb, 0x99, 0xe3, 0x97, 0x47, 0x25, 0x90, 0xd7, + 0xde, 0xcc, 0xb3, 0xbd, 0x1e, 0x41, 0x77, 0x06, 0x23, 0xd6, 0x85, 0x5f, 0x83, 0xe5, 0xf8, 0x13, + 0xdc, 0xa4, 0x09, 0x75, 0x56, 0xbf, 0x56, 0x05, 0xc0, 0x12, 0x6f, 0x71, 0x33, 0xc7, 0x19, 0x7b, + 0x67, 0x70, 0xd8, 0xeb, 0x3f, 0xc1, 0xd3, 0xa0, 0x99, 0x67, 0xa0, 0xc1, 0xf1, 0xe8, 0xc9, 0x40, + 0x81, 0x0a, 0x2c, 0x07, 0xef, 0x4e, 0xb3, 0x78, 0xff, 0x6b, 0x58, 0x4d, 0x3d, 0xd6, 0xcd, 0x5a, + 0x3d, 0x38, 0x1e, 0x75, 0x06, 0x87, 0x7a, 0x3d, 0x35, 0x28, 0x77, 0x0e, 0xda, 0xbd, 0x43, 0x74, + 0x84, 0x34, 0xa0, 0x7a, 0xdc, 0x97, 0xc9, 0x7c, 0xfc, 0x99, 0xf1, 0x02, 0x63, 0x51, 0x7b, 0x3d, + 0x73, 0x38, 0xb2, 0x86, 0xa3, 0xf6, 0x93, 0x6e, 0xb3, 0xc8, 0xf2, 0x4a, 0x7e, 0x55, 0xba, 0xff, + 0x19, 0x2c, 0xc7, 0xe3, 0x9e, 0xe3, 0x0e, 0xac, 0x6d, 0xd8, 0xdc, 0xe9, 0x8e, 0xbe, 0xec, 0x76, + 0xfb, 0x38, 0xe5, 0x9d, 0x6e, 0x7f, 0x64, 0xb6, 0x0f, 0x7a, 0xa3, 0xaf, 0x9a, 0xb9, 0xfb, 0x9f, + 0x43, 0x33, 0x19, 0x64, 0x10, 0x8b, 0xca, 0x78, 0x51, 0xf8, 0xc6, 0xfd, 0x7f, 0x9f, 0x83, 0xf5, + 0x2c, 0xff, 0x1a, 0x5b, 0x98, 0x82, 0x11, 0xb2, 0xe3, 0x70, 0x38, 0xe8, 0x5b, 0xfd, 0x01, 0xbe, + 0xbb, 0xbb, 0x0d, 0x9b, 0x09, 0x84, 0xec, 0x45, 0x8e, 0xdc, 0x82, 0xad, 0x54, 0x26, 0xcb, 0x1c, + 0x1c, 0xe3, 0x5c, 0xb6, 0x60, 0x3d, 0x81, 0xec, 0x9a, 0xe6, 0xc0, 0x6c, 0x16, 0xc8, 0x7b, 0x70, + 0x2f, 0x81, 0x49, 0x0b, 0x01, 0x52, 0x46, 0x28, 0x92, 0x77, 0xe0, 0xcd, 0x14, 0x75, 0x74, 0x4e, + 0x5a, 0x3b, 0xed, 0x03, 0xd6, 0xbd, 0x66, 0xe9, 0xfe, 0xdf, 0x29, 0x00, 0x44, 0x17, 0x0b, 0x59, + 0xfd, 0xbb, 0xed, 0x51, 0xfb, 0x60, 0xc0, 0xf6, 0x8c, 0x39, 0x18, 0xb1, 0xd2, 0xcd, 0xee, 0x4f, + 0x9a, 0x37, 0x32, 0x31, 0x83, 0x23, 0xd6, 0xa1, 0x2d, 0x58, 0xe3, 0xeb, 0xef, 0x80, 0x75, 0x83, + 0x2d, 0x17, 0x7c, 0xc2, 0x19, 0x25, 0x8d, 0xe3, 0xa3, 0x3d, 0x73, 0xd0, 0x1f, 0x59, 0xc3, 0xfd, + 0xe3, 0xd1, 0x2e, 0x3e, 0x00, 0xdd, 0x31, 0x7b, 0x47, 0xbc, 0xcc, 0xe2, 0x8b, 0x08, 0x58, 0xd1, + 0x25, 0xb6, 0xc1, 0x9f, 0x0c, 0x86, 0xc3, 0xde, 0x91, 0xf5, 0x93, 0xe3, 0xae, 0xd9, 0xeb, 0x0e, + 0x31, 0xe3, 0x52, 0x06, 0x9c, 0xd1, 0x97, 0xd9, 0x9a, 0x1d, 0x1d, 0x7c, 0x21, 0x04, 0x08, 0x46, + 0x5a, 0x89, 0x83, 0x18, 0x55, 0x95, 0xcd, 0x0e, 0x3b, 0x81, 0x33, 0x4a, 0x86, 0x6b, 0x70, 0x2c, + 0x5f, 0x8d, 0xc9, 0x16, 0xa9, 0x9d, 0x8f, 0xd9, 0xea, 0xd9, 0x28, 0x96, 0x0b, 0xc5, 0x0e, 0x25, + 0xa4, 0xed, 0xee, 0x9a, 0x98, 0x61, 0x39, 0x05, 0x65, 0xb4, 0x2b, 0x6c, 0x11, 0xb2, 0x23, 0x9a, + 0x91, 0x34, 0x65, 0x82, 0x61, 0x56, 0x1f, 0xfd, 0xd3, 0x37, 0xa0, 0xaa, 0x2e, 0x18, 0x90, 0x1f, + 0x43, 0x23, 0x76, 0xe3, 0x9b, 0x48, 0x13, 0x7e, 0xd6, 0x05, 0xf1, 0xed, 0xd7, 0xb2, 0x91, 0x42, + 0x39, 0x39, 0xd4, 0xac, 0x01, 0xbc, 0xb0, 0xd7, 0x92, 0x1a, 0x7a, 0xac, 0xb4, 0xdb, 0xd7, 0x60, + 0x45, 0x71, 0x4f, 0xf1, 0x35, 0x69, 0xfd, 0xb3, 0xc7, 0xe4, 0x76, 0xf4, 0xb4, 0x6f, 0xc6, 0xe7, + 0x90, 0xb7, 0x6f, 0xa6, 0x3f, 0x50, 0x2c, 0xbf, 0x68, 0xbc, 0x0b, 0x35, 0xed, 0x6b, 0x7e, 0xe4, + 0xe6, 0xb5, 0x5f, 0x1e, 0xdc, 0xde, 0xce, 0x42, 0x89, 0x26, 0xfd, 0x00, 0xaa, 0xea, 0xcb, 0x6e, + 0x64, 0x4b, 0xfb, 0x2a, 0x9f, 0xfe, 0x7d, 0xba, 0xed, 0x56, 0x1a, 0x21, 0xf2, 0xef, 0x42, 0x4d, + 0xfb, 0x40, 0x9b, 0x6a, 0x45, 0xfa, 0x23, 0x70, 0xaa, 0x15, 0x59, 0xdf, 0x73, 0x3b, 0x80, 0x0d, + 0x61, 0x73, 0x38, 0xa1, 0xdf, 0x64, 0x78, 0x32, 0xbe, 0xdf, 0xfc, 0x30, 0x47, 0x3e, 0x87, 0x8a, + 0xfc, 0x14, 0x1f, 0xd9, 0xcc, 0xfe, 0xd0, 0xe0, 0xf6, 0x56, 0x0a, 0x2e, 0x9a, 0xd2, 0x06, 0x88, + 0x3e, 0xfd, 0x46, 0x64, 0xc7, 0x53, 0x9f, 0x92, 0x53, 0x33, 0x93, 0xf1, 0x9d, 0xb8, 0x5d, 0xa8, + 0x69, 0x5f, 0x79, 0x53, 0x63, 0x92, 0xfe, 0x42, 0x9c, 0x1a, 0x93, 0xac, 0x8f, 0xc2, 0xfd, 0x18, + 0x1a, 0xb1, 0xcf, 0xb5, 0xa9, 0x75, 0x9c, 0xf5, 0x31, 0x38, 0xb5, 0x8e, 0xb3, 0xbf, 0xf0, 0xb6, + 0x0b, 0x35, 0xed, 0x13, 0x6a, 0xaa, 0x45, 0xe9, 0xef, 0xb8, 0xa9, 0x16, 0x65, 0x7c, 0x71, 0x8d, + 0xed, 0x86, 0xf8, 0xf7, 0xd3, 0xd4, 0x6e, 0xc8, 0xfc, 0x10, 0x9b, 0xda, 0x0d, 0xd9, 0x1f, 0x5d, + 0x63, 0x4b, 0x4f, 0x3d, 0x23, 0x4f, 0xb6, 0x62, 0xaa, 0x7e, 0xf4, 0x1e, 0xbd, 0x5a, 0x7a, 0xe9, + 0x17, 0xe7, 0x9f, 0xc0, 0x9a, 0x5a, 0x34, 0xea, 0x11, 0xf8, 0x40, 0xb5, 0x29, 0xf3, 0xa9, 0xf9, + 0xed, 0x66, 0x12, 0xfb, 0x30, 0x47, 0x3e, 0x85, 0xb2, 0x78, 0x59, 0x9b, 0x6c, 0x24, 0x5f, 0xda, + 0xe6, 0x8d, 0xd8, 0xcc, 0x7e, 0x80, 0x9b, 0x1c, 0xe1, 0x86, 0xd6, 0x9f, 0xbe, 0xd6, 0x57, 0x6c, + 0xc6, 0x6b, 0xd9, 0xdb, 0xaf, 0x5f, 0x87, 0x8e, 0x4a, 0x4c, 0x3e, 0xd7, 0x7e, 0xfb, 0xba, 0x97, + 0x58, 0xe2, 0x25, 0x5e, 0xf7, 0x64, 0xdc, 0x13, 0xa8, 0xeb, 0x5f, 0xef, 0x21, 0xfa, 0x3e, 0x4c, + 0x96, 0x75, 0x2b, 0x13, 0x27, 0x0a, 0xfa, 0x02, 0x36, 0xd5, 0x78, 0xeb, 0xcf, 0x82, 0x04, 0xe4, + 0x4e, 0xc6, 0x63, 0x21, 0xb1, 0x51, 0xbf, 0x79, 0xed, 0x6b, 0x22, 0x0f, 0x73, 0xc8, 0x64, 0x63, + 0x1f, 0xdc, 0x88, 0x98, 0x6c, 0xd6, 0x77, 0x46, 0x22, 0x26, 0x9b, 0xfd, 0x95, 0x8e, 0x36, 0xac, + 0x68, 0xcf, 0x9a, 0x0c, 0xaf, 0xdc, 0xb1, 0x5a, 0xef, 0xe9, 0x37, 0x89, 0xb7, 0xb3, 0x2c, 0xdf, + 0xa4, 0x03, 0x35, 0xfd, 0x65, 0x94, 0x17, 0x64, 0xdf, 0xd2, 0x50, 0xfa, 0xb3, 0xb3, 0x0f, 0x73, + 0xe4, 0x00, 0x9a, 0xc9, 0x77, 0x0c, 0xd5, 0x16, 0xce, 0x7a, 0xfb, 0x71, 0x3b, 0x81, 0x8c, 0xbd, + 0x7e, 0xc8, 0xd6, 0x45, 0xec, 0x3b, 0xc1, 0x9e, 0x9f, 0x3c, 0x8a, 0xe2, 0xdf, 0x0f, 0x56, 0xa5, + 0x65, 0x7d, 0x39, 0xfa, 0x5e, 0xee, 0x61, 0x8e, 0xec, 0x41, 0x3d, 0xf6, 0x8c, 0x57, 0xec, 0xae, + 0x4b, 0xa2, 0x9b, 0x2d, 0x1d, 0x97, 0xe8, 0xe7, 0x21, 0x2c, 0xc7, 0x43, 0x34, 0x54, 0xc3, 0x32, + 0xe3, 0x48, 0xd4, 0xf4, 0x65, 0xc7, 0x75, 0x90, 0x1f, 0xf2, 0xaf, 0xe0, 0xcb, 0x50, 0x3e, 0x92, + 0xfe, 0x6a, 0xba, 0x9a, 0x33, 0xfd, 0x1b, 0xe3, 0x46, 0xe1, 0xcf, 0xe5, 0x73, 0xd8, 0xaf, 0xef, + 0xf3, 0x6f, 0xd0, 0xca, 0x68, 0x2e, 0x36, 0xff, 0xaf, 0x5a, 0x08, 0xd9, 0xe3, 0x95, 0x8b, 0x2f, + 0x80, 0x47, 0x9c, 0x3b, 0xf5, 0x55, 0xf0, 0x97, 0xb4, 0xa1, 0xcd, 0xdb, 0x20, 0xf2, 0xc4, 0xd6, + 0xe0, 0x2b, 0x96, 0x45, 0x3e, 0x01, 0x88, 0x42, 0x64, 0x49, 0x22, 0x50, 0x53, 0x6d, 0xa8, 0x8c, + 0x28, 0xda, 0x2e, 0xdf, 0xef, 0x2a, 0x52, 0x54, 0x3f, 0x92, 0xe3, 0x41, 0xab, 0xb1, 0x23, 0x39, + 0x59, 0xcc, 0x87, 0xd0, 0x38, 0xf0, 0xbc, 0x67, 0x8b, 0xb9, 0xba, 0x67, 0x11, 0x0f, 0x63, 0xda, + 0xb7, 0x83, 0xf3, 0xed, 0x44, 0xb3, 0x48, 0x1b, 0x56, 0x15, 0x8b, 0x88, 0x42, 0x55, 0xe3, 0x44, + 0x31, 0xc6, 0x90, 0x28, 0xe0, 0x61, 0x8e, 0x3c, 0x82, 0xfa, 0x2e, 0x1d, 0xe3, 0x33, 0x1b, 0x18, + 0x34, 0xb3, 0x16, 0x0b, 0xc0, 0xe0, 0xd1, 0x36, 0xdb, 0x8d, 0x18, 0x50, 0xb2, 0xb8, 0x28, 0x70, + 0x4b, 0x3f, 0x33, 0xe2, 0xd1, 0x4f, 0x31, 0x16, 0x97, 0x0a, 0xde, 0xfa, 0x02, 0x56, 0x53, 0xa1, + 0x51, 0x8a, 0xbb, 0x5d, 0x17, 0x50, 0xb5, 0x7d, 0xf7, 0x7a, 0x02, 0x51, 0xee, 0x8f, 0xa0, 0xc1, + 0x5f, 0x21, 0x3e, 0xa1, 0xfc, 0x9a, 0x6c, 0xe2, 0x8d, 0x29, 0xfd, 0x0e, 0x6e, 0x92, 0x25, 0xf1, + 0x0c, 0x4f, 0xf0, 0xdb, 0x24, 0xda, 0x25, 0x54, 0x35, 0xaf, 0xe9, 0x8b, 0xb1, 0x6a, 0x5e, 0xb3, + 0xee, 0xbb, 0x7e, 0x06, 0xb5, 0x27, 0x34, 0x94, 0xd7, 0x3a, 0x95, 0x7c, 0x94, 0xb8, 0xe7, 0xb9, + 0x9d, 0x71, 0x19, 0x97, 0x7c, 0x8c, 0x59, 0xd5, 0x13, 0x05, 0x9b, 0x5a, 0x2d, 0x7a, 0xd6, 0x95, + 0x04, 0x9c, 0x49, 0x1f, 0xda, 0x43, 0x25, 0xaa, 0xe1, 0xe9, 0x87, 0x69, 0x54, 0xc3, 0xb3, 0xde, + 0x35, 0xf9, 0x21, 0x1f, 0x01, 0xed, 0x22, 0x69, 0x24, 0x82, 0x25, 0xef, 0x9c, 0xaa, 0xe6, 0xeb, + 0xe4, 0x8f, 0x01, 0x86, 0xa1, 0x37, 0xdf, 0xb5, 0xe9, 0xcc, 0x73, 0x23, 0x9e, 0x10, 0x5d, 0x61, + 0x8c, 0x36, 0xa2, 0x76, 0x8f, 0x91, 0x7c, 0xa9, 0xc9, 0xa6, 0xb1, 0x29, 0x91, 0xd3, 0x7e, 0xed, + 0x2d, 0x47, 0xd5, 0x9d, 0x8c, 0x9b, 0x8e, 0xc8, 0x24, 0x20, 0x8a, 0x3c, 0x53, 0x92, 0x66, 0x2a, + 0xa8, 0x4d, 0xed, 0xf5, 0x8c, 0x30, 0xb5, 0x1f, 0x40, 0x35, 0x0a, 0xd9, 0xd9, 0x8a, 0x5e, 0x4d, + 0x8a, 0x05, 0xf8, 0x28, 0xee, 0x9d, 0x0e, 0x97, 0xe9, 0xc3, 0x1a, 0x6f, 0x8e, 0x3a, 0xfe, 0xf0, + 0xa2, 0x9d, 0xfa, 0xb4, 0x4e, 0x3a, 0x4e, 0x45, 0xed, 0x9f, 0xac, 0x68, 0x0b, 0xb6, 0x7f, 0x52, + 0x5e, 0x7b, 0xb5, 0x7f, 0xae, 0x0b, 0xc3, 0x50, 0xfb, 0xe7, 0x7a, 0x87, 0x7f, 0x1f, 0xd6, 0x32, + 0xfc, 0xef, 0xe4, 0x0d, 0xa9, 0xd8, 0x5c, 0xeb, 0x9b, 0xdf, 0xce, 0xf4, 0xd3, 0x92, 0x11, 0x6c, + 0xf1, 0x3c, 0xed, 0xe9, 0x34, 0xe1, 0xee, 0x7d, 0x5d, 0xcb, 0x90, 0xe1, 0xc2, 0x8e, 0x89, 0x32, + 0x09, 0x37, 0x76, 0x1f, 0x9a, 0x49, 0x4f, 0x29, 0xb9, 0x9e, 0x7c, 0xfb, 0x4e, 0x4c, 0x64, 0x4f, + 0x7b, 0x57, 0xc9, 0x17, 0xca, 0x5f, 0x9b, 0x68, 0xe3, 0x9d, 0xe8, 0x8b, 0x70, 0x99, 0xde, 0x65, + 0xa5, 0x0d, 0x64, 0xba, 0x7b, 0xc9, 0x2f, 0xc2, 0x56, 0x72, 0x45, 0xcb, 0x92, 0xef, 0x66, 0x0d, + 0xd7, 0xb5, 0xa2, 0x5c, 0xbc, 0x43, 0x0f, 0x73, 0x8c, 0x11, 0xeb, 0x5e, 0x55, 0xb5, 0x90, 0x32, + 0xdc, 0xbb, 0x6a, 0x21, 0x65, 0xba, 0x61, 0x8f, 0x60, 0x25, 0xe1, 0x50, 0x55, 0x62, 0x70, 0xb6, + 0x0b, 0x56, 0x89, 0xc1, 0xd7, 0xf9, 0x61, 0x87, 0xd0, 0x4c, 0xba, 0x4a, 0xd5, 0x5c, 0x5f, 0xe3, + 0x7e, 0xdd, 0xbe, 0x73, 0x2d, 0x3e, 0xde, 0x4c, 0xcd, 0xa9, 0x18, 0x6b, 0x66, 0xda, 0x15, 0x1a, + 0x6b, 0x66, 0x86, 0x4b, 0x73, 0x67, 0xed, 0x97, 0x56, 0x03, 0xea, 0x5f, 0x38, 0x63, 0xfa, 0xfe, + 0xd4, 0x9d, 0xbc, 0x8f, 0xc4, 0x27, 0x4b, 0x73, 0xdf, 0x0b, 0xbd, 0x0f, 0xff, 0x77, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x2f, 0x01, 0x0b, 0x81, 0x7b, 0x8b, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// LightningClient is the client API for Lightning service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type LightningClient interface { + // lncli: `walletbalance` + //WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + //confirmed unspent outputs and all unconfirmed unspent outputs under control + //of the wallet. + WalletBalance(ctx context.Context, in *WalletBalanceRequest, opts ...grpc.CallOption) (*WalletBalanceResponse, error) + // lncli: `channelbalance` + //ChannelBalance returns the total funds available across all open channels + //in satoshis. + ChannelBalance(ctx context.Context, in *ChannelBalanceRequest, opts ...grpc.CallOption) (*ChannelBalanceResponse, error) + // lncli: `listchaintxns` + //GetTransactions returns a list describing all the known transactions + //relevant to the wallet. + GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (*TransactionDetails, error) + // lncli: `estimatefee` + //EstimateFee asks the chain backend to estimate the fee rate and total fees + //for a transaction that pays to multiple specified outputs. + // + //When using REST, the `AddrToAmount` map type can be set by appending + //`&AddrToAmount[
]=` to the URL. Unfortunately this + //map type doesn't appear in the REST API documentation because of a bug in + //the grpc-gateway library. + EstimateFee(ctx context.Context, in *EstimateFeeRequest, opts ...grpc.CallOption) (*EstimateFeeResponse, error) + // lncli: `sendcoins` + //SendCoins executes a request to send coins to a particular address. Unlike + //SendMany, this RPC call only allows creating a single output at a time. If + //neither target_conf, or sat_per_byte are set, then the internal wallet will + //consult its fee model to determine a fee for the default confirmation + //target. + SendCoins(ctx context.Context, in *SendCoinsRequest, opts ...grpc.CallOption) (*SendCoinsResponse, error) + // lncli: `listunspent` + //Deprecated, use walletrpc.ListUnspent instead. + // + //ListUnspent returns a list of all utxos spendable by the wallet with a + //number of confirmations between the specified minimum and maximum. + ListUnspent(ctx context.Context, in *ListUnspentRequest, opts ...grpc.CallOption) (*ListUnspentResponse, error) + // + //SubscribeTransactions creates a uni-directional stream from the server to + //the client in which any newly discovered transactions relevant to the + //wallet are sent over. + SubscribeTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (Lightning_SubscribeTransactionsClient, error) + // lncli: `sendmany` + //SendMany handles a request for a transaction that creates multiple specified + //outputs in parallel. If neither target_conf, or sat_per_byte are set, then + //the internal wallet will consult its fee model to determine a fee for the + //default confirmation target. + SendMany(ctx context.Context, in *SendManyRequest, opts ...grpc.CallOption) (*SendManyResponse, error) + // lncli: `newaddress` + //NewAddress creates a new address under control of the local wallet. + NewAddress(ctx context.Context, in *NewAddressRequest, opts ...grpc.CallOption) (*NewAddressResponse, error) + // lncli: `signmessage` + //SignMessage signs a message with this node's private key. The returned + //signature string is `zbase32` encoded and pubkey recoverable, meaning that + //only the message digest and signature are needed for verification. + SignMessage(ctx context.Context, in *SignMessageRequest, opts ...grpc.CallOption) (*SignMessageResponse, error) + // lncli: `verifymessage` + //VerifyMessage verifies a signature over a msg. The signature must be + //zbase32 encoded and signed by an active node in the resident node's + //channel database. In addition to returning the validity of the signature, + //VerifyMessage also returns the recovered pubkey from the signature. + VerifyMessage(ctx context.Context, in *VerifyMessageRequest, opts ...grpc.CallOption) (*VerifyMessageResponse, error) + // lncli: `connect` + //ConnectPeer attempts to establish a connection to a remote peer. This is at + //the networking level, and is used for communication between nodes. This is + //distinct from establishing a channel with a peer. + ConnectPeer(ctx context.Context, in *ConnectPeerRequest, opts ...grpc.CallOption) (*ConnectPeerResponse, error) + // lncli: `disconnect` + //DisconnectPeer attempts to disconnect one peer from another identified by a + //given pubKey. In the case that we currently have a pending or active channel + //with the target peer, then this action will be not be allowed. + DisconnectPeer(ctx context.Context, in *DisconnectPeerRequest, opts ...grpc.CallOption) (*DisconnectPeerResponse, error) + // lncli: `listpeers` + //ListPeers returns a verbose listing of all currently active peers. + ListPeers(ctx context.Context, in *ListPeersRequest, opts ...grpc.CallOption) (*ListPeersResponse, error) + // + //SubscribePeerEvents creates a uni-directional stream from the server to + //the client in which any events relevant to the state of peers are sent + //over. Events include peers going online and offline. + SubscribePeerEvents(ctx context.Context, in *PeerEventSubscription, opts ...grpc.CallOption) (Lightning_SubscribePeerEventsClient, error) + // lncli: `getinfo` + //GetInfo returns general information concerning the lightning node including + //it's identity pubkey, alias, the chains it is connected to, and information + //concerning the number of open+pending channels. + GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) + //* lncli: `getrecoveryinfo` + //GetRecoveryInfo returns information concerning the recovery mode including + //whether it's in a recovery mode, whether the recovery is finished, and the + //progress made so far. + GetRecoveryInfo(ctx context.Context, in *GetRecoveryInfoRequest, opts ...grpc.CallOption) (*GetRecoveryInfoResponse, error) + // lncli: `pendingchannels` + //PendingChannels returns a list of all the channels that are currently + //considered "pending". A channel is pending if it has finished the funding + //workflow and is waiting for confirmations for the funding txn, or is in the + //process of closure, either initiated cooperatively or non-cooperatively. + PendingChannels(ctx context.Context, in *PendingChannelsRequest, opts ...grpc.CallOption) (*PendingChannelsResponse, error) + // lncli: `listchannels` + //ListChannels returns a description of all the open channels that this node + //is a participant in. + ListChannels(ctx context.Context, in *ListChannelsRequest, opts ...grpc.CallOption) (*ListChannelsResponse, error) + // + //SubscribeChannelEvents creates a uni-directional stream from the server to + //the client in which any updates relevant to the state of the channels are + //sent over. Events include new active channels, inactive channels, and closed + //channels. + SubscribeChannelEvents(ctx context.Context, in *ChannelEventSubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelEventsClient, error) + // lncli: `closedchannels` + //ClosedChannels returns a description of all the closed channels that + //this node was a participant in. + ClosedChannels(ctx context.Context, in *ClosedChannelsRequest, opts ...grpc.CallOption) (*ClosedChannelsResponse, error) + // + //OpenChannelSync is a synchronous version of the OpenChannel RPC call. This + //call is meant to be consumed by clients to the REST proxy. As with all + //other sync calls, all byte slices are intended to be populated as hex + //encoded strings. + OpenChannelSync(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (*ChannelPoint, error) + // lncli: `openchannel` + //OpenChannel attempts to open a singly funded channel specified in the + //request to a remote peer. Users are able to specify a target number of + //blocks that the funding transaction should be confirmed in, or a manual fee + //rate to us for the funding transaction. If neither are specified, then a + //lax block confirmation target is used. Each OpenStatusUpdate will return + //the pending channel ID of the in-progress channel. Depending on the + //arguments specified in the OpenChannelRequest, this pending channel ID can + //then be used to manually progress the channel funding flow. + OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (Lightning_OpenChannelClient, error) + // + //FundingStateStep is an advanced funding related call that allows the caller + //to either execute some preparatory steps for a funding workflow, or + //manually progress a funding workflow. The primary way a funding flow is + //identified is via its pending channel ID. As an example, this method can be + //used to specify that we're expecting a funding flow for a particular + //pending channel ID, for which we need to use specific parameters. + //Alternatively, this can be used to interactively drive PSBT signing for + //funding for partially complete funding transactions. + FundingStateStep(ctx context.Context, in *FundingTransitionMsg, opts ...grpc.CallOption) (*FundingStateStepResp, error) + // + //ChannelAcceptor dispatches a bi-directional streaming RPC in which + //OpenChannel requests are sent to the client and the client responds with + //a boolean that tells LND whether or not to accept the channel. This allows + //node operators to specify their own criteria for accepting inbound channels + //through a single persistent connection. + ChannelAcceptor(ctx context.Context, opts ...grpc.CallOption) (Lightning_ChannelAcceptorClient, error) + // lncli: `closechannel` + //CloseChannel attempts to close an active channel identified by its channel + //outpoint (ChannelPoint). The actions of this method can additionally be + //augmented to attempt a force close after a timeout period in the case of an + //inactive peer. If a non-force close (cooperative closure) is requested, + //then the user can specify either a target number of blocks until the + //closure transaction is confirmed, or a manual fee rate. If neither are + //specified, then a default lax, block confirmation target is used. + CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (Lightning_CloseChannelClient, error) + // lncli: `abandonchannel` + //AbandonChannel removes all channel state from the database except for a + //close summary. This method can be used to get rid of permanently unusable + //channels due to bugs fixed in newer versions of lnd. This method can also be + //used to remove externally funded channels where the funding transaction was + //never broadcast. Only available for non-externally funded channels in dev + //build. + AbandonChannel(ctx context.Context, in *AbandonChannelRequest, opts ...grpc.CallOption) (*AbandonChannelResponse, error) + // lncli: `sendpayment` + //Deprecated, use routerrpc.SendPaymentV2. SendPayment dispatches a + //bi-directional streaming RPC for sending payments through the Lightning + //Network. A single RPC invocation creates a persistent bi-directional + //stream allowing clients to rapidly send payments through the Lightning + //Network with a single persistent connection. + SendPayment(ctx context.Context, opts ...grpc.CallOption) (Lightning_SendPaymentClient, error) + // + //SendPaymentSync is the synchronous non-streaming version of SendPayment. + //This RPC is intended to be consumed by clients of the REST proxy. + //Additionally, this RPC expects the destination's public key and the payment + //hash (if any) to be encoded as hex strings. + SendPaymentSync(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error) + // lncli: `sendtoroute` + //Deprecated, use routerrpc.SendToRouteV2. SendToRoute is a bi-directional + //streaming RPC for sending payment through the Lightning Network. 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. + SendToRoute(ctx context.Context, opts ...grpc.CallOption) (Lightning_SendToRouteClient, error) + // + //SendToRouteSync is a synchronous version of SendToRoute. It Will block + //until the payment either fails or succeeds. + SendToRouteSync(ctx context.Context, in *SendToRouteRequest, opts ...grpc.CallOption) (*SendResponse, error) + // lncli: `addinvoice` + //AddInvoice attempts to add a new invoice to the invoice database. Any + //duplicated invoices are rejected, therefore all invoices *must* have a + //unique payment preimage. + AddInvoice(ctx context.Context, in *Invoice, opts ...grpc.CallOption) (*AddInvoiceResponse, error) + // lncli: `listinvoices` + //ListInvoices returns a list of all the invoices currently stored within the + //database. Any active debug invoices are ignored. It has full support for + //paginated responses, allowing users to query for specific invoices through + //their add_index. This can be done by using either the first_index_offset or + //last_index_offset fields included in the response as the index_offset of the + //next request. By default, the first 100 invoices created will be returned. + //Backwards pagination is also supported through the Reversed flag. + ListInvoices(ctx context.Context, in *ListInvoiceRequest, opts ...grpc.CallOption) (*ListInvoiceResponse, error) + // lncli: `lookupinvoice` + //LookupInvoice attempts to look up an invoice according to its payment hash. + //The passed payment hash *must* be exactly 32 bytes, if not, an error is + //returned. + LookupInvoice(ctx context.Context, in *PaymentHash, opts ...grpc.CallOption) (*Invoice, error) + // + //SubscribeInvoices returns a uni-directional stream (server -> client) for + //notifying the client of newly added/settled invoices. The caller can + //optionally specify the add_index and/or the settle_index. If the add_index + //is specified, then we'll first start by sending add invoice events for all + //invoices with an add_index greater than the specified value. If the + //settle_index is specified, the next, we'll send out all settle events for + //invoices with a settle_index greater than the specified value. One or both + //of these fields can be set. If no fields are set, then we'll only send out + //the latest add/settle events. + SubscribeInvoices(ctx context.Context, in *InvoiceSubscription, opts ...grpc.CallOption) (Lightning_SubscribeInvoicesClient, error) + // lncli: `decodepayreq` + //DecodePayReq takes an encoded payment request string and attempts to decode + //it, returning a full description of the conditions encoded within the + //payment request. + DecodePayReq(ctx context.Context, in *PayReqString, opts ...grpc.CallOption) (*PayReq, error) + // lncli: `listpayments` + //ListPayments returns a list of all outgoing payments. + ListPayments(ctx context.Context, in *ListPaymentsRequest, opts ...grpc.CallOption) (*ListPaymentsResponse, error) + // + //DeleteAllPayments deletes all outgoing payments from DB. + DeleteAllPayments(ctx context.Context, in *DeleteAllPaymentsRequest, opts ...grpc.CallOption) (*DeleteAllPaymentsResponse, error) + // lncli: `describegraph` + //DescribeGraph returns a description of the latest graph state from the + //point of view of the node. The graph information is partitioned into two + //components: all the nodes/vertexes, and all the edges that connect the + //vertexes themselves. As this is a directed graph, the edges also contain + //the node directional specific routing policy which includes: the time lock + //delta, fee information, etc. + DescribeGraph(ctx context.Context, in *ChannelGraphRequest, opts ...grpc.CallOption) (*ChannelGraph, error) + // lncli: `getnodemetrics` + //GetNodeMetrics returns node metrics calculated from the graph. Currently + //the only supported metric is betweenness centrality of individual nodes. + GetNodeMetrics(ctx context.Context, in *NodeMetricsRequest, opts ...grpc.CallOption) (*NodeMetricsResponse, error) + // lncli: `getchaninfo` + //GetChanInfo returns the latest authenticated network announcement for the + //given channel identified by its channel ID: an 8-byte integer which + //uniquely identifies the location of transaction's funding output within the + //blockchain. + GetChanInfo(ctx context.Context, in *ChanInfoRequest, opts ...grpc.CallOption) (*ChannelEdge, error) + // lncli: `getnodeinfo` + //GetNodeInfo returns the latest advertised, aggregated, and authenticated + //channel information for the specified node identified by its public key. + GetNodeInfo(ctx context.Context, in *NodeInfoRequest, opts ...grpc.CallOption) (*NodeInfo, error) + // lncli: `queryroutes` + //QueryRoutes attempts to query the daemon's Channel Router for a possible + //route to a target destination capable of carrying a specific amount of + //satoshis. The returned route contains the full details required to craft and + //send an HTLC, also including the necessary information that should be + //present within the Sphinx packet encapsulated within the HTLC. + // + //When using REST, the `dest_custom_records` map type can be set by appending + //`&dest_custom_records[]=` + //to the URL. Unfortunately this map type doesn't appear in the REST API + //documentation because of a bug in the grpc-gateway library. + QueryRoutes(ctx context.Context, in *QueryRoutesRequest, opts ...grpc.CallOption) (*QueryRoutesResponse, error) + // lncli: `getnetworkinfo` + //GetNetworkInfo returns some basic stats about the known channel graph from + //the point of view of the node. + GetNetworkInfo(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfo, error) + // lncli: `stop` + //StopDaemon will send a shutdown request to the interrupt handler, triggering + //a graceful shutdown of the daemon. + StopDaemon(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error) + // + //SubscribeChannelGraph launches a streaming RPC that allows the caller to + //receive notifications upon any changes to the channel graph topology from + //the point of view of the responding node. Events notified include: new + //nodes coming online, nodes updating their authenticated attributes, new + //channels being advertised, updates in the routing policy for a directional + //channel edge, and when channels are closed on-chain. + SubscribeChannelGraph(ctx context.Context, in *GraphTopologySubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelGraphClient, error) + // lncli: `debuglevel` + //DebugLevel allows a caller to programmatically set the logging verbosity of + //lnd. The logging can be targeted according to a coarse daemon-wide logging + //level, or in a granular fashion to specify the logging for a target + //sub-system. + DebugLevel(ctx context.Context, in *DebugLevelRequest, opts ...grpc.CallOption) (*DebugLevelResponse, error) + // lncli: `feereport` + //FeeReport allows the caller to obtain a report detailing the current fee + //schedule enforced by the node globally for each channel. + FeeReport(ctx context.Context, in *FeeReportRequest, opts ...grpc.CallOption) (*FeeReportResponse, error) + // lncli: `updatechanpolicy` + //UpdateChannelPolicy allows the caller to update the fee schedule and + //channel policies for all channels globally, or a particular channel. + UpdateChannelPolicy(ctx context.Context, in *PolicyUpdateRequest, opts ...grpc.CallOption) (*PolicyUpdateResponse, error) + // lncli: `fwdinghistory` + //ForwardingHistory allows the caller to query the htlcswitch for a record of + //all HTLCs forwarded within the target time range, and integer offset + //within that time range. If no time-range is specified, then the first chunk + //of the past 24 hrs of forwarding history are returned. + // + //A list of forwarding events are returned. The size of each forwarding event + //is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB. + //As a result each message can only contain 50k entries. Each response has + //the index offset of the last entry. The index offset can be provided to the + //request to allow the caller to skip a series of records. + ForwardingHistory(ctx context.Context, in *ForwardingHistoryRequest, opts ...grpc.CallOption) (*ForwardingHistoryResponse, error) + // lncli: `exportchanbackup` + //ExportChannelBackup attempts to return an encrypted static channel backup + //for the target channel identified by it channel point. The backup is + //encrypted with a key generated from the aezeed seed of the user. The + //returned backup can either be restored using the RestoreChannelBackup + //method once lnd is running, or via the InitWallet and UnlockWallet methods + //from the WalletUnlocker service. + ExportChannelBackup(ctx context.Context, in *ExportChannelBackupRequest, opts ...grpc.CallOption) (*ChannelBackup, error) + // + //ExportAllChannelBackups returns static channel backups for all existing + //channels known to lnd. A set of regular singular static channel backups for + //each channel are returned. Additionally, a multi-channel backup is returned + //as well, which contains a single encrypted blob containing the backups of + //each channel. + ExportAllChannelBackups(ctx context.Context, in *ChanBackupExportRequest, opts ...grpc.CallOption) (*ChanBackupSnapshot, error) + // + //VerifyChanBackup allows a caller to verify the integrity of a channel backup + //snapshot. This method will accept either a packed Single or a packed Multi. + //Specifying both will result in an error. + VerifyChanBackup(ctx context.Context, in *ChanBackupSnapshot, opts ...grpc.CallOption) (*VerifyChanBackupResponse, error) + // lncli: `restorechanbackup` + //RestoreChannelBackups accepts a set of singular channel backups, or a + //single encrypted multi-chan backup and attempts to recover any funds + //remaining within the channel. If we are able to unpack the backup, then the + //new channel will be shown under listchannels, as well as pending channels. + RestoreChannelBackups(ctx context.Context, in *RestoreChanBackupRequest, opts ...grpc.CallOption) (*RestoreBackupResponse, error) + // + //SubscribeChannelBackups allows a client to sub-subscribe to the most up to + //date information concerning the state of all channel backups. Each time a + //new channel is added, we return the new set of channels, along with a + //multi-chan backup containing the backup info for all channels. Each time a + //channel is closed, we send a new update, which contains new new chan back + //ups, but the updated set of encrypted multi-chan backups with the closed + //channel(s) removed. + SubscribeChannelBackups(ctx context.Context, in *ChannelBackupSubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelBackupsClient, error) + // lncli: `bakemacaroon` + //BakeMacaroon allows the creation of a new macaroon with custom read and + //write permissions. No first-party caveats are added since this can be done + //offline. + BakeMacaroon(ctx context.Context, in *BakeMacaroonRequest, opts ...grpc.CallOption) (*BakeMacaroonResponse, error) + // lncli: `listmacaroonids` + //ListMacaroonIDs returns all root key IDs that are in use. + ListMacaroonIDs(ctx context.Context, in *ListMacaroonIDsRequest, opts ...grpc.CallOption) (*ListMacaroonIDsResponse, error) + // lncli: `deletemacaroonid` + //DeleteMacaroonID deletes the specified macaroon ID and invalidates all + //macaroons derived from that ID. + DeleteMacaroonID(ctx context.Context, in *DeleteMacaroonIDRequest, opts ...grpc.CallOption) (*DeleteMacaroonIDResponse, error) + // lncli: `listpermissions` + //ListPermissions lists all RPC method URIs and their required macaroon + //permissions to access them. + ListPermissions(ctx context.Context, in *ListPermissionsRequest, opts ...grpc.CallOption) (*ListPermissionsResponse, error) +} + +type lightningClient struct { + cc *grpc.ClientConn +} + +func NewLightningClient(cc *grpc.ClientConn) LightningClient { + return &lightningClient{cc} +} + +func (c *lightningClient) WalletBalance(ctx context.Context, in *WalletBalanceRequest, opts ...grpc.CallOption) (*WalletBalanceResponse, error) { + out := new(WalletBalanceResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/WalletBalance", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ChannelBalance(ctx context.Context, in *ChannelBalanceRequest, opts ...grpc.CallOption) (*ChannelBalanceResponse, error) { + out := new(ChannelBalanceResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ChannelBalance", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (*TransactionDetails, error) { + out := new(TransactionDetails) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetTransactions", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) EstimateFee(ctx context.Context, in *EstimateFeeRequest, opts ...grpc.CallOption) (*EstimateFeeResponse, error) { + out := new(EstimateFeeResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/EstimateFee", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SendCoins(ctx context.Context, in *SendCoinsRequest, opts ...grpc.CallOption) (*SendCoinsResponse, error) { + out := new(SendCoinsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/SendCoins", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListUnspent(ctx context.Context, in *ListUnspentRequest, opts ...grpc.CallOption) (*ListUnspentResponse, error) { + out := new(ListUnspentResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListUnspent", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribeTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (Lightning_SubscribeTransactionsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[0], "/lnrpc.Lightning/SubscribeTransactions", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribeTransactionsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribeTransactionsClient interface { + Recv() (*Transaction, error) + grpc.ClientStream +} + +type lightningSubscribeTransactionsClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribeTransactionsClient) Recv() (*Transaction, error) { + m := new(Transaction) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) SendMany(ctx context.Context, in *SendManyRequest, opts ...grpc.CallOption) (*SendManyResponse, error) { + out := new(SendManyResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/SendMany", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) NewAddress(ctx context.Context, in *NewAddressRequest, opts ...grpc.CallOption) (*NewAddressResponse, error) { + out := new(NewAddressResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/NewAddress", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SignMessage(ctx context.Context, in *SignMessageRequest, opts ...grpc.CallOption) (*SignMessageResponse, error) { + out := new(SignMessageResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/SignMessage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) VerifyMessage(ctx context.Context, in *VerifyMessageRequest, opts ...grpc.CallOption) (*VerifyMessageResponse, error) { + out := new(VerifyMessageResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/VerifyMessage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ConnectPeer(ctx context.Context, in *ConnectPeerRequest, opts ...grpc.CallOption) (*ConnectPeerResponse, error) { + out := new(ConnectPeerResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ConnectPeer", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) DisconnectPeer(ctx context.Context, in *DisconnectPeerRequest, opts ...grpc.CallOption) (*DisconnectPeerResponse, error) { + out := new(DisconnectPeerResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DisconnectPeer", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListPeers(ctx context.Context, in *ListPeersRequest, opts ...grpc.CallOption) (*ListPeersResponse, error) { + out := new(ListPeersResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListPeers", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribePeerEvents(ctx context.Context, in *PeerEventSubscription, opts ...grpc.CallOption) (Lightning_SubscribePeerEventsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[1], "/lnrpc.Lightning/SubscribePeerEvents", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribePeerEventsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribePeerEventsClient interface { + Recv() (*PeerEvent, error) + grpc.ClientStream +} + +type lightningSubscribePeerEventsClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribePeerEventsClient) Recv() (*PeerEvent, error) { + m := new(PeerEvent) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) { + out := new(GetInfoResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetRecoveryInfo(ctx context.Context, in *GetRecoveryInfoRequest, opts ...grpc.CallOption) (*GetRecoveryInfoResponse, error) { + out := new(GetRecoveryInfoResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetRecoveryInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) PendingChannels(ctx context.Context, in *PendingChannelsRequest, opts ...grpc.CallOption) (*PendingChannelsResponse, error) { + out := new(PendingChannelsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/PendingChannels", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListChannels(ctx context.Context, in *ListChannelsRequest, opts ...grpc.CallOption) (*ListChannelsResponse, error) { + out := new(ListChannelsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListChannels", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribeChannelEvents(ctx context.Context, in *ChannelEventSubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelEventsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[2], "/lnrpc.Lightning/SubscribeChannelEvents", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribeChannelEventsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribeChannelEventsClient interface { + Recv() (*ChannelEventUpdate, error) + grpc.ClientStream +} + +type lightningSubscribeChannelEventsClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribeChannelEventsClient) Recv() (*ChannelEventUpdate, error) { + m := new(ChannelEventUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) ClosedChannels(ctx context.Context, in *ClosedChannelsRequest, opts ...grpc.CallOption) (*ClosedChannelsResponse, error) { + out := new(ClosedChannelsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ClosedChannels", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) OpenChannelSync(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (*ChannelPoint, error) { + out := new(ChannelPoint) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/OpenChannelSync", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (Lightning_OpenChannelClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[3], "/lnrpc.Lightning/OpenChannel", opts...) + if err != nil { + return nil, err + } + x := &lightningOpenChannelClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_OpenChannelClient interface { + Recv() (*OpenStatusUpdate, error) + grpc.ClientStream +} + +type lightningOpenChannelClient struct { + grpc.ClientStream +} + +func (x *lightningOpenChannelClient) Recv() (*OpenStatusUpdate, error) { + m := new(OpenStatusUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) FundingStateStep(ctx context.Context, in *FundingTransitionMsg, opts ...grpc.CallOption) (*FundingStateStepResp, error) { + out := new(FundingStateStepResp) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/FundingStateStep", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ChannelAcceptor(ctx context.Context, opts ...grpc.CallOption) (Lightning_ChannelAcceptorClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[4], "/lnrpc.Lightning/ChannelAcceptor", opts...) + if err != nil { + return nil, err + } + x := &lightningChannelAcceptorClient{stream} + return x, nil +} + +type Lightning_ChannelAcceptorClient interface { + Send(*ChannelAcceptResponse) error + Recv() (*ChannelAcceptRequest, error) + grpc.ClientStream +} + +type lightningChannelAcceptorClient struct { + grpc.ClientStream +} + +func (x *lightningChannelAcceptorClient) Send(m *ChannelAcceptResponse) error { + return x.ClientStream.SendMsg(m) +} + +func (x *lightningChannelAcceptorClient) Recv() (*ChannelAcceptRequest, error) { + m := new(ChannelAcceptRequest) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (Lightning_CloseChannelClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[5], "/lnrpc.Lightning/CloseChannel", opts...) + if err != nil { + return nil, err + } + x := &lightningCloseChannelClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_CloseChannelClient interface { + Recv() (*CloseStatusUpdate, error) + grpc.ClientStream +} + +type lightningCloseChannelClient struct { + grpc.ClientStream +} + +func (x *lightningCloseChannelClient) Recv() (*CloseStatusUpdate, error) { + m := new(CloseStatusUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) AbandonChannel(ctx context.Context, in *AbandonChannelRequest, opts ...grpc.CallOption) (*AbandonChannelResponse, error) { + out := new(AbandonChannelResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/AbandonChannel", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *lightningClient) SendPayment(ctx context.Context, opts ...grpc.CallOption) (Lightning_SendPaymentClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[6], "/lnrpc.Lightning/SendPayment", opts...) + if err != nil { + return nil, err + } + x := &lightningSendPaymentClient{stream} + return x, nil +} + +type Lightning_SendPaymentClient interface { + Send(*SendRequest) error + Recv() (*SendResponse, error) + grpc.ClientStream +} + +type lightningSendPaymentClient struct { + grpc.ClientStream +} + +func (x *lightningSendPaymentClient) Send(m *SendRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *lightningSendPaymentClient) Recv() (*SendResponse, error) { + m := new(SendResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) SendPaymentSync(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error) { + out := new(SendResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/SendPaymentSync", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Deprecated: Do not use. +func (c *lightningClient) SendToRoute(ctx context.Context, opts ...grpc.CallOption) (Lightning_SendToRouteClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[7], "/lnrpc.Lightning/SendToRoute", opts...) + if err != nil { + return nil, err + } + x := &lightningSendToRouteClient{stream} + return x, nil +} + +type Lightning_SendToRouteClient interface { + Send(*SendToRouteRequest) error + Recv() (*SendResponse, error) + grpc.ClientStream +} + +type lightningSendToRouteClient struct { + grpc.ClientStream +} + +func (x *lightningSendToRouteClient) Send(m *SendToRouteRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *lightningSendToRouteClient) Recv() (*SendResponse, error) { + m := new(SendResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) SendToRouteSync(ctx context.Context, in *SendToRouteRequest, opts ...grpc.CallOption) (*SendResponse, error) { + out := new(SendResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/SendToRouteSync", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) AddInvoice(ctx context.Context, in *Invoice, opts ...grpc.CallOption) (*AddInvoiceResponse, error) { + out := new(AddInvoiceResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/AddInvoice", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListInvoices(ctx context.Context, in *ListInvoiceRequest, opts ...grpc.CallOption) (*ListInvoiceResponse, error) { + out := new(ListInvoiceResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListInvoices", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) LookupInvoice(ctx context.Context, in *PaymentHash, opts ...grpc.CallOption) (*Invoice, error) { + out := new(Invoice) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/LookupInvoice", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribeInvoices(ctx context.Context, in *InvoiceSubscription, opts ...grpc.CallOption) (Lightning_SubscribeInvoicesClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[8], "/lnrpc.Lightning/SubscribeInvoices", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribeInvoicesClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribeInvoicesClient interface { + Recv() (*Invoice, error) + grpc.ClientStream +} + +type lightningSubscribeInvoicesClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribeInvoicesClient) Recv() (*Invoice, error) { + m := new(Invoice) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) DecodePayReq(ctx context.Context, in *PayReqString, opts ...grpc.CallOption) (*PayReq, error) { + out := new(PayReq) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DecodePayReq", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListPayments(ctx context.Context, in *ListPaymentsRequest, opts ...grpc.CallOption) (*ListPaymentsResponse, error) { + out := new(ListPaymentsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListPayments", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) DeleteAllPayments(ctx context.Context, in *DeleteAllPaymentsRequest, opts ...grpc.CallOption) (*DeleteAllPaymentsResponse, error) { + out := new(DeleteAllPaymentsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DeleteAllPayments", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) DescribeGraph(ctx context.Context, in *ChannelGraphRequest, opts ...grpc.CallOption) (*ChannelGraph, error) { + out := new(ChannelGraph) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DescribeGraph", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetNodeMetrics(ctx context.Context, in *NodeMetricsRequest, opts ...grpc.CallOption) (*NodeMetricsResponse, error) { + out := new(NodeMetricsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetNodeMetrics", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetChanInfo(ctx context.Context, in *ChanInfoRequest, opts ...grpc.CallOption) (*ChannelEdge, error) { + out := new(ChannelEdge) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetChanInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetNodeInfo(ctx context.Context, in *NodeInfoRequest, opts ...grpc.CallOption) (*NodeInfo, error) { + out := new(NodeInfo) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetNodeInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) QueryRoutes(ctx context.Context, in *QueryRoutesRequest, opts ...grpc.CallOption) (*QueryRoutesResponse, error) { + out := new(QueryRoutesResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/QueryRoutes", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) GetNetworkInfo(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfo, error) { + out := new(NetworkInfo) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/GetNetworkInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) StopDaemon(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error) { + out := new(StopResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/StopDaemon", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribeChannelGraph(ctx context.Context, in *GraphTopologySubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelGraphClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[9], "/lnrpc.Lightning/SubscribeChannelGraph", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribeChannelGraphClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribeChannelGraphClient interface { + Recv() (*GraphTopologyUpdate, error) + grpc.ClientStream +} + +type lightningSubscribeChannelGraphClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribeChannelGraphClient) Recv() (*GraphTopologyUpdate, error) { + m := new(GraphTopologyUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) DebugLevel(ctx context.Context, in *DebugLevelRequest, opts ...grpc.CallOption) (*DebugLevelResponse, error) { + out := new(DebugLevelResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DebugLevel", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) FeeReport(ctx context.Context, in *FeeReportRequest, opts ...grpc.CallOption) (*FeeReportResponse, error) { + out := new(FeeReportResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/FeeReport", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) UpdateChannelPolicy(ctx context.Context, in *PolicyUpdateRequest, opts ...grpc.CallOption) (*PolicyUpdateResponse, error) { + out := new(PolicyUpdateResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/UpdateChannelPolicy", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ForwardingHistory(ctx context.Context, in *ForwardingHistoryRequest, opts ...grpc.CallOption) (*ForwardingHistoryResponse, error) { + out := new(ForwardingHistoryResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ForwardingHistory", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ExportChannelBackup(ctx context.Context, in *ExportChannelBackupRequest, opts ...grpc.CallOption) (*ChannelBackup, error) { + out := new(ChannelBackup) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ExportChannelBackup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ExportAllChannelBackups(ctx context.Context, in *ChanBackupExportRequest, opts ...grpc.CallOption) (*ChanBackupSnapshot, error) { + out := new(ChanBackupSnapshot) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ExportAllChannelBackups", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) VerifyChanBackup(ctx context.Context, in *ChanBackupSnapshot, opts ...grpc.CallOption) (*VerifyChanBackupResponse, error) { + out := new(VerifyChanBackupResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/VerifyChanBackup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) RestoreChannelBackups(ctx context.Context, in *RestoreChanBackupRequest, opts ...grpc.CallOption) (*RestoreBackupResponse, error) { + out := new(RestoreBackupResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/RestoreChannelBackups", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) SubscribeChannelBackups(ctx context.Context, in *ChannelBackupSubscription, opts ...grpc.CallOption) (Lightning_SubscribeChannelBackupsClient, error) { + stream, err := c.cc.NewStream(ctx, &_Lightning_serviceDesc.Streams[10], "/lnrpc.Lightning/SubscribeChannelBackups", opts...) + if err != nil { + return nil, err + } + x := &lightningSubscribeChannelBackupsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_SubscribeChannelBackupsClient interface { + Recv() (*ChanBackupSnapshot, error) + grpc.ClientStream +} + +type lightningSubscribeChannelBackupsClient struct { + grpc.ClientStream +} + +func (x *lightningSubscribeChannelBackupsClient) Recv() (*ChanBackupSnapshot, error) { + m := new(ChanBackupSnapshot) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) BakeMacaroon(ctx context.Context, in *BakeMacaroonRequest, opts ...grpc.CallOption) (*BakeMacaroonResponse, error) { + out := new(BakeMacaroonResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/BakeMacaroon", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListMacaroonIDs(ctx context.Context, in *ListMacaroonIDsRequest, opts ...grpc.CallOption) (*ListMacaroonIDsResponse, error) { + out := new(ListMacaroonIDsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListMacaroonIDs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) DeleteMacaroonID(ctx context.Context, in *DeleteMacaroonIDRequest, opts ...grpc.CallOption) (*DeleteMacaroonIDResponse, error) { + out := new(DeleteMacaroonIDResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/DeleteMacaroonID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *lightningClient) ListPermissions(ctx context.Context, in *ListPermissionsRequest, opts ...grpc.CallOption) (*ListPermissionsResponse, error) { + out := new(ListPermissionsResponse) + err := c.cc.Invoke(ctx, "/lnrpc.Lightning/ListPermissions", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// LightningServer is the server API for Lightning service. +type LightningServer interface { + // lncli: `walletbalance` + //WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + //confirmed unspent outputs and all unconfirmed unspent outputs under control + //of the wallet. + WalletBalance(context.Context, *WalletBalanceRequest) (*WalletBalanceResponse, error) + // lncli: `channelbalance` + //ChannelBalance returns the total funds available across all open channels + //in satoshis. + ChannelBalance(context.Context, *ChannelBalanceRequest) (*ChannelBalanceResponse, error) + // lncli: `listchaintxns` + //GetTransactions returns a list describing all the known transactions + //relevant to the wallet. + GetTransactions(context.Context, *GetTransactionsRequest) (*TransactionDetails, error) + // lncli: `estimatefee` + //EstimateFee asks the chain backend to estimate the fee rate and total fees + //for a transaction that pays to multiple specified outputs. + // + //When using REST, the `AddrToAmount` map type can be set by appending + //`&AddrToAmount[
]=` to the URL. Unfortunately this + //map type doesn't appear in the REST API documentation because of a bug in + //the grpc-gateway library. + EstimateFee(context.Context, *EstimateFeeRequest) (*EstimateFeeResponse, error) + // lncli: `sendcoins` + //SendCoins executes a request to send coins to a particular address. Unlike + //SendMany, this RPC call only allows creating a single output at a time. If + //neither target_conf, or sat_per_byte are set, then the internal wallet will + //consult its fee model to determine a fee for the default confirmation + //target. + SendCoins(context.Context, *SendCoinsRequest) (*SendCoinsResponse, error) + // lncli: `listunspent` + //Deprecated, use walletrpc.ListUnspent instead. + // + //ListUnspent returns a list of all utxos spendable by the wallet with a + //number of confirmations between the specified minimum and maximum. + ListUnspent(context.Context, *ListUnspentRequest) (*ListUnspentResponse, error) + // + //SubscribeTransactions creates a uni-directional stream from the server to + //the client in which any newly discovered transactions relevant to the + //wallet are sent over. + SubscribeTransactions(*GetTransactionsRequest, Lightning_SubscribeTransactionsServer) error + // lncli: `sendmany` + //SendMany handles a request for a transaction that creates multiple specified + //outputs in parallel. If neither target_conf, or sat_per_byte are set, then + //the internal wallet will consult its fee model to determine a fee for the + //default confirmation target. + SendMany(context.Context, *SendManyRequest) (*SendManyResponse, error) + // lncli: `newaddress` + //NewAddress creates a new address under control of the local wallet. + NewAddress(context.Context, *NewAddressRequest) (*NewAddressResponse, error) + // lncli: `signmessage` + //SignMessage signs a message with this node's private key. The returned + //signature string is `zbase32` encoded and pubkey recoverable, meaning that + //only the message digest and signature are needed for verification. + SignMessage(context.Context, *SignMessageRequest) (*SignMessageResponse, error) + // lncli: `verifymessage` + //VerifyMessage verifies a signature over a msg. The signature must be + //zbase32 encoded and signed by an active node in the resident node's + //channel database. In addition to returning the validity of the signature, + //VerifyMessage also returns the recovered pubkey from the signature. + VerifyMessage(context.Context, *VerifyMessageRequest) (*VerifyMessageResponse, error) + // lncli: `connect` + //ConnectPeer attempts to establish a connection to a remote peer. This is at + //the networking level, and is used for communication between nodes. This is + //distinct from establishing a channel with a peer. + ConnectPeer(context.Context, *ConnectPeerRequest) (*ConnectPeerResponse, error) + // lncli: `disconnect` + //DisconnectPeer attempts to disconnect one peer from another identified by a + //given pubKey. In the case that we currently have a pending or active channel + //with the target peer, then this action will be not be allowed. + DisconnectPeer(context.Context, *DisconnectPeerRequest) (*DisconnectPeerResponse, error) + // lncli: `listpeers` + //ListPeers returns a verbose listing of all currently active peers. + ListPeers(context.Context, *ListPeersRequest) (*ListPeersResponse, error) + // + //SubscribePeerEvents creates a uni-directional stream from the server to + //the client in which any events relevant to the state of peers are sent + //over. Events include peers going online and offline. + SubscribePeerEvents(*PeerEventSubscription, Lightning_SubscribePeerEventsServer) error + // lncli: `getinfo` + //GetInfo returns general information concerning the lightning node including + //it's identity pubkey, alias, the chains it is connected to, and information + //concerning the number of open+pending channels. + GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) + //* lncli: `getrecoveryinfo` + //GetRecoveryInfo returns information concerning the recovery mode including + //whether it's in a recovery mode, whether the recovery is finished, and the + //progress made so far. + GetRecoveryInfo(context.Context, *GetRecoveryInfoRequest) (*GetRecoveryInfoResponse, error) + // lncli: `pendingchannels` + //PendingChannels returns a list of all the channels that are currently + //considered "pending". A channel is pending if it has finished the funding + //workflow and is waiting for confirmations for the funding txn, or is in the + //process of closure, either initiated cooperatively or non-cooperatively. + PendingChannels(context.Context, *PendingChannelsRequest) (*PendingChannelsResponse, error) + // lncli: `listchannels` + //ListChannels returns a description of all the open channels that this node + //is a participant in. + ListChannels(context.Context, *ListChannelsRequest) (*ListChannelsResponse, error) + // + //SubscribeChannelEvents creates a uni-directional stream from the server to + //the client in which any updates relevant to the state of the channels are + //sent over. Events include new active channels, inactive channels, and closed + //channels. + SubscribeChannelEvents(*ChannelEventSubscription, Lightning_SubscribeChannelEventsServer) error + // lncli: `closedchannels` + //ClosedChannels returns a description of all the closed channels that + //this node was a participant in. + ClosedChannels(context.Context, *ClosedChannelsRequest) (*ClosedChannelsResponse, error) + // + //OpenChannelSync is a synchronous version of the OpenChannel RPC call. This + //call is meant to be consumed by clients to the REST proxy. As with all + //other sync calls, all byte slices are intended to be populated as hex + //encoded strings. + OpenChannelSync(context.Context, *OpenChannelRequest) (*ChannelPoint, error) + // lncli: `openchannel` + //OpenChannel attempts to open a singly funded channel specified in the + //request to a remote peer. Users are able to specify a target number of + //blocks that the funding transaction should be confirmed in, or a manual fee + //rate to us for the funding transaction. If neither are specified, then a + //lax block confirmation target is used. Each OpenStatusUpdate will return + //the pending channel ID of the in-progress channel. Depending on the + //arguments specified in the OpenChannelRequest, this pending channel ID can + //then be used to manually progress the channel funding flow. + OpenChannel(*OpenChannelRequest, Lightning_OpenChannelServer) error + // + //FundingStateStep is an advanced funding related call that allows the caller + //to either execute some preparatory steps for a funding workflow, or + //manually progress a funding workflow. The primary way a funding flow is + //identified is via its pending channel ID. As an example, this method can be + //used to specify that we're expecting a funding flow for a particular + //pending channel ID, for which we need to use specific parameters. + //Alternatively, this can be used to interactively drive PSBT signing for + //funding for partially complete funding transactions. + FundingStateStep(context.Context, *FundingTransitionMsg) (*FundingStateStepResp, error) + // + //ChannelAcceptor dispatches a bi-directional streaming RPC in which + //OpenChannel requests are sent to the client and the client responds with + //a boolean that tells LND whether or not to accept the channel. This allows + //node operators to specify their own criteria for accepting inbound channels + //through a single persistent connection. + ChannelAcceptor(Lightning_ChannelAcceptorServer) error + // lncli: `closechannel` + //CloseChannel attempts to close an active channel identified by its channel + //outpoint (ChannelPoint). The actions of this method can additionally be + //augmented to attempt a force close after a timeout period in the case of an + //inactive peer. If a non-force close (cooperative closure) is requested, + //then the user can specify either a target number of blocks until the + //closure transaction is confirmed, or a manual fee rate. If neither are + //specified, then a default lax, block confirmation target is used. + CloseChannel(*CloseChannelRequest, Lightning_CloseChannelServer) error + // lncli: `abandonchannel` + //AbandonChannel removes all channel state from the database except for a + //close summary. This method can be used to get rid of permanently unusable + //channels due to bugs fixed in newer versions of lnd. This method can also be + //used to remove externally funded channels where the funding transaction was + //never broadcast. Only available for non-externally funded channels in dev + //build. + AbandonChannel(context.Context, *AbandonChannelRequest) (*AbandonChannelResponse, error) + // lncli: `sendpayment` + //Deprecated, use routerrpc.SendPaymentV2. SendPayment dispatches a + //bi-directional streaming RPC for sending payments through the Lightning + //Network. A single RPC invocation creates a persistent bi-directional + //stream allowing clients to rapidly send payments through the Lightning + //Network with a single persistent connection. + SendPayment(Lightning_SendPaymentServer) error + // + //SendPaymentSync is the synchronous non-streaming version of SendPayment. + //This RPC is intended to be consumed by clients of the REST proxy. + //Additionally, this RPC expects the destination's public key and the payment + //hash (if any) to be encoded as hex strings. + SendPaymentSync(context.Context, *SendRequest) (*SendResponse, error) + // lncli: `sendtoroute` + //Deprecated, use routerrpc.SendToRouteV2. SendToRoute is a bi-directional + //streaming RPC for sending payment through the Lightning Network. 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. + SendToRoute(Lightning_SendToRouteServer) error + // + //SendToRouteSync is a synchronous version of SendToRoute. It Will block + //until the payment either fails or succeeds. + SendToRouteSync(context.Context, *SendToRouteRequest) (*SendResponse, error) + // lncli: `addinvoice` + //AddInvoice attempts to add a new invoice to the invoice database. Any + //duplicated invoices are rejected, therefore all invoices *must* have a + //unique payment preimage. + AddInvoice(context.Context, *Invoice) (*AddInvoiceResponse, error) + // lncli: `listinvoices` + //ListInvoices returns a list of all the invoices currently stored within the + //database. Any active debug invoices are ignored. It has full support for + //paginated responses, allowing users to query for specific invoices through + //their add_index. This can be done by using either the first_index_offset or + //last_index_offset fields included in the response as the index_offset of the + //next request. By default, the first 100 invoices created will be returned. + //Backwards pagination is also supported through the Reversed flag. + ListInvoices(context.Context, *ListInvoiceRequest) (*ListInvoiceResponse, error) + // lncli: `lookupinvoice` + //LookupInvoice attempts to look up an invoice according to its payment hash. + //The passed payment hash *must* be exactly 32 bytes, if not, an error is + //returned. + LookupInvoice(context.Context, *PaymentHash) (*Invoice, error) + // + //SubscribeInvoices returns a uni-directional stream (server -> client) for + //notifying the client of newly added/settled invoices. The caller can + //optionally specify the add_index and/or the settle_index. If the add_index + //is specified, then we'll first start by sending add invoice events for all + //invoices with an add_index greater than the specified value. If the + //settle_index is specified, the next, we'll send out all settle events for + //invoices with a settle_index greater than the specified value. One or both + //of these fields can be set. If no fields are set, then we'll only send out + //the latest add/settle events. + SubscribeInvoices(*InvoiceSubscription, Lightning_SubscribeInvoicesServer) error + // lncli: `decodepayreq` + //DecodePayReq takes an encoded payment request string and attempts to decode + //it, returning a full description of the conditions encoded within the + //payment request. + DecodePayReq(context.Context, *PayReqString) (*PayReq, error) + // lncli: `listpayments` + //ListPayments returns a list of all outgoing payments. + ListPayments(context.Context, *ListPaymentsRequest) (*ListPaymentsResponse, error) + // + //DeleteAllPayments deletes all outgoing payments from DB. + DeleteAllPayments(context.Context, *DeleteAllPaymentsRequest) (*DeleteAllPaymentsResponse, error) + // lncli: `describegraph` + //DescribeGraph returns a description of the latest graph state from the + //point of view of the node. The graph information is partitioned into two + //components: all the nodes/vertexes, and all the edges that connect the + //vertexes themselves. As this is a directed graph, the edges also contain + //the node directional specific routing policy which includes: the time lock + //delta, fee information, etc. + DescribeGraph(context.Context, *ChannelGraphRequest) (*ChannelGraph, error) + // lncli: `getnodemetrics` + //GetNodeMetrics returns node metrics calculated from the graph. Currently + //the only supported metric is betweenness centrality of individual nodes. + GetNodeMetrics(context.Context, *NodeMetricsRequest) (*NodeMetricsResponse, error) + // lncli: `getchaninfo` + //GetChanInfo returns the latest authenticated network announcement for the + //given channel identified by its channel ID: an 8-byte integer which + //uniquely identifies the location of transaction's funding output within the + //blockchain. + GetChanInfo(context.Context, *ChanInfoRequest) (*ChannelEdge, error) + // lncli: `getnodeinfo` + //GetNodeInfo returns the latest advertised, aggregated, and authenticated + //channel information for the specified node identified by its public key. + GetNodeInfo(context.Context, *NodeInfoRequest) (*NodeInfo, error) + // lncli: `queryroutes` + //QueryRoutes attempts to query the daemon's Channel Router for a possible + //route to a target destination capable of carrying a specific amount of + //satoshis. The returned route contains the full details required to craft and + //send an HTLC, also including the necessary information that should be + //present within the Sphinx packet encapsulated within the HTLC. + // + //When using REST, the `dest_custom_records` map type can be set by appending + //`&dest_custom_records[]=` + //to the URL. Unfortunately this map type doesn't appear in the REST API + //documentation because of a bug in the grpc-gateway library. + QueryRoutes(context.Context, *QueryRoutesRequest) (*QueryRoutesResponse, error) + // lncli: `getnetworkinfo` + //GetNetworkInfo returns some basic stats about the known channel graph from + //the point of view of the node. + GetNetworkInfo(context.Context, *NetworkInfoRequest) (*NetworkInfo, error) + // lncli: `stop` + //StopDaemon will send a shutdown request to the interrupt handler, triggering + //a graceful shutdown of the daemon. + StopDaemon(context.Context, *StopRequest) (*StopResponse, error) + // + //SubscribeChannelGraph launches a streaming RPC that allows the caller to + //receive notifications upon any changes to the channel graph topology from + //the point of view of the responding node. Events notified include: new + //nodes coming online, nodes updating their authenticated attributes, new + //channels being advertised, updates in the routing policy for a directional + //channel edge, and when channels are closed on-chain. + SubscribeChannelGraph(*GraphTopologySubscription, Lightning_SubscribeChannelGraphServer) error + // lncli: `debuglevel` + //DebugLevel allows a caller to programmatically set the logging verbosity of + //lnd. The logging can be targeted according to a coarse daemon-wide logging + //level, or in a granular fashion to specify the logging for a target + //sub-system. + DebugLevel(context.Context, *DebugLevelRequest) (*DebugLevelResponse, error) + // lncli: `feereport` + //FeeReport allows the caller to obtain a report detailing the current fee + //schedule enforced by the node globally for each channel. + FeeReport(context.Context, *FeeReportRequest) (*FeeReportResponse, error) + // lncli: `updatechanpolicy` + //UpdateChannelPolicy allows the caller to update the fee schedule and + //channel policies for all channels globally, or a particular channel. + UpdateChannelPolicy(context.Context, *PolicyUpdateRequest) (*PolicyUpdateResponse, error) + // lncli: `fwdinghistory` + //ForwardingHistory allows the caller to query the htlcswitch for a record of + //all HTLCs forwarded within the target time range, and integer offset + //within that time range. If no time-range is specified, then the first chunk + //of the past 24 hrs of forwarding history are returned. + // + //A list of forwarding events are returned. The size of each forwarding event + //is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB. + //As a result each message can only contain 50k entries. Each response has + //the index offset of the last entry. The index offset can be provided to the + //request to allow the caller to skip a series of records. + ForwardingHistory(context.Context, *ForwardingHistoryRequest) (*ForwardingHistoryResponse, error) + // lncli: `exportchanbackup` + //ExportChannelBackup attempts to return an encrypted static channel backup + //for the target channel identified by it channel point. The backup is + //encrypted with a key generated from the aezeed seed of the user. The + //returned backup can either be restored using the RestoreChannelBackup + //method once lnd is running, or via the InitWallet and UnlockWallet methods + //from the WalletUnlocker service. + ExportChannelBackup(context.Context, *ExportChannelBackupRequest) (*ChannelBackup, error) + // + //ExportAllChannelBackups returns static channel backups for all existing + //channels known to lnd. A set of regular singular static channel backups for + //each channel are returned. Additionally, a multi-channel backup is returned + //as well, which contains a single encrypted blob containing the backups of + //each channel. + ExportAllChannelBackups(context.Context, *ChanBackupExportRequest) (*ChanBackupSnapshot, error) + // + //VerifyChanBackup allows a caller to verify the integrity of a channel backup + //snapshot. This method will accept either a packed Single or a packed Multi. + //Specifying both will result in an error. + VerifyChanBackup(context.Context, *ChanBackupSnapshot) (*VerifyChanBackupResponse, error) + // lncli: `restorechanbackup` + //RestoreChannelBackups accepts a set of singular channel backups, or a + //single encrypted multi-chan backup and attempts to recover any funds + //remaining within the channel. If we are able to unpack the backup, then the + //new channel will be shown under listchannels, as well as pending channels. + RestoreChannelBackups(context.Context, *RestoreChanBackupRequest) (*RestoreBackupResponse, error) + // + //SubscribeChannelBackups allows a client to sub-subscribe to the most up to + //date information concerning the state of all channel backups. Each time a + //new channel is added, we return the new set of channels, along with a + //multi-chan backup containing the backup info for all channels. Each time a + //channel is closed, we send a new update, which contains new new chan back + //ups, but the updated set of encrypted multi-chan backups with the closed + //channel(s) removed. + SubscribeChannelBackups(*ChannelBackupSubscription, Lightning_SubscribeChannelBackupsServer) error + // lncli: `bakemacaroon` + //BakeMacaroon allows the creation of a new macaroon with custom read and + //write permissions. No first-party caveats are added since this can be done + //offline. + BakeMacaroon(context.Context, *BakeMacaroonRequest) (*BakeMacaroonResponse, error) + // lncli: `listmacaroonids` + //ListMacaroonIDs returns all root key IDs that are in use. + ListMacaroonIDs(context.Context, *ListMacaroonIDsRequest) (*ListMacaroonIDsResponse, error) + // lncli: `deletemacaroonid` + //DeleteMacaroonID deletes the specified macaroon ID and invalidates all + //macaroons derived from that ID. + DeleteMacaroonID(context.Context, *DeleteMacaroonIDRequest) (*DeleteMacaroonIDResponse, error) + // lncli: `listpermissions` + //ListPermissions lists all RPC method URIs and their required macaroon + //permissions to access them. + ListPermissions(context.Context, *ListPermissionsRequest) (*ListPermissionsResponse, error) +} + +func RegisterLightningServer(s *grpc.Server, srv LightningServer) { + s.RegisterService(&_Lightning_serviceDesc, srv) +} + +func _Lightning_WalletBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WalletBalanceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).WalletBalance(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/WalletBalance", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).WalletBalance(ctx, req.(*WalletBalanceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ChannelBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChannelBalanceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ChannelBalance(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ChannelBalance", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ChannelBalance(ctx, req.(*ChannelBalanceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTransactionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetTransactions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetTransactions", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetTransactions(ctx, req.(*GetTransactionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_EstimateFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EstimateFeeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).EstimateFee(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/EstimateFee", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).EstimateFee(ctx, req.(*EstimateFeeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SendCoins_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SendCoinsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).SendCoins(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/SendCoins", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).SendCoins(ctx, req.(*SendCoinsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListUnspent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListUnspentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListUnspent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListUnspent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListUnspent(ctx, req.(*ListUnspentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribeTransactions_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GetTransactionsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribeTransactions(m, &lightningSubscribeTransactionsServer{stream}) +} + +type Lightning_SubscribeTransactionsServer interface { + Send(*Transaction) error + grpc.ServerStream +} + +type lightningSubscribeTransactionsServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribeTransactionsServer) Send(m *Transaction) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_SendMany_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SendManyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).SendMany(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/SendMany", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).SendMany(ctx, req.(*SendManyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_NewAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(NewAddressRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).NewAddress(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/NewAddress", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).NewAddress(ctx, req.(*NewAddressRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SignMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SignMessageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).SignMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/SignMessage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).SignMessage(ctx, req.(*SignMessageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_VerifyMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(VerifyMessageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).VerifyMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/VerifyMessage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).VerifyMessage(ctx, req.(*VerifyMessageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ConnectPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ConnectPeerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ConnectPeer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ConnectPeer", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ConnectPeer(ctx, req.(*ConnectPeerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_DisconnectPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DisconnectPeerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DisconnectPeer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DisconnectPeer", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DisconnectPeer(ctx, req.(*DisconnectPeerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListPeersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListPeers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListPeers", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListPeers(ctx, req.(*ListPeersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribePeerEvents_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(PeerEventSubscription) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribePeerEvents(m, &lightningSubscribePeerEventsServer{stream}) +} + +type Lightning_SubscribePeerEventsServer interface { + Send(*PeerEvent) error + grpc.ServerStream +} + +type lightningSubscribePeerEventsServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribePeerEventsServer) Send(m *PeerEvent) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetInfo(ctx, req.(*GetInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetRecoveryInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRecoveryInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetRecoveryInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetRecoveryInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetRecoveryInfo(ctx, req.(*GetRecoveryInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_PendingChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PendingChannelsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).PendingChannels(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/PendingChannels", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).PendingChannels(ctx, req.(*PendingChannelsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListChannelsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListChannels(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListChannels", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListChannels(ctx, req.(*ListChannelsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribeChannelEvents_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ChannelEventSubscription) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribeChannelEvents(m, &lightningSubscribeChannelEventsServer{stream}) +} + +type Lightning_SubscribeChannelEventsServer interface { + Send(*ChannelEventUpdate) error + grpc.ServerStream +} + +type lightningSubscribeChannelEventsServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribeChannelEventsServer) Send(m *ChannelEventUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_ClosedChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ClosedChannelsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ClosedChannels(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ClosedChannels", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ClosedChannels(ctx, req.(*ClosedChannelsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_OpenChannelSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(OpenChannelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).OpenChannelSync(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/OpenChannelSync", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).OpenChannelSync(ctx, req.(*OpenChannelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_OpenChannel_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(OpenChannelRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).OpenChannel(m, &lightningOpenChannelServer{stream}) +} + +type Lightning_OpenChannelServer interface { + Send(*OpenStatusUpdate) error + grpc.ServerStream +} + +type lightningOpenChannelServer struct { + grpc.ServerStream +} + +func (x *lightningOpenChannelServer) Send(m *OpenStatusUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_FundingStateStep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FundingTransitionMsg) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).FundingStateStep(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/FundingStateStep", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).FundingStateStep(ctx, req.(*FundingTransitionMsg)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ChannelAcceptor_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(LightningServer).ChannelAcceptor(&lightningChannelAcceptorServer{stream}) +} + +type Lightning_ChannelAcceptorServer interface { + Send(*ChannelAcceptRequest) error + Recv() (*ChannelAcceptResponse, error) + grpc.ServerStream +} + +type lightningChannelAcceptorServer struct { + grpc.ServerStream +} + +func (x *lightningChannelAcceptorServer) Send(m *ChannelAcceptRequest) error { + return x.ServerStream.SendMsg(m) +} + +func (x *lightningChannelAcceptorServer) Recv() (*ChannelAcceptResponse, error) { + m := new(ChannelAcceptResponse) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _Lightning_CloseChannel_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CloseChannelRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).CloseChannel(m, &lightningCloseChannelServer{stream}) +} + +type Lightning_CloseChannelServer interface { + Send(*CloseStatusUpdate) error + grpc.ServerStream +} + +type lightningCloseChannelServer struct { + grpc.ServerStream +} + +func (x *lightningCloseChannelServer) Send(m *CloseStatusUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_AbandonChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AbandonChannelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).AbandonChannel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/AbandonChannel", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).AbandonChannel(ctx, req.(*AbandonChannelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SendPayment_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(LightningServer).SendPayment(&lightningSendPaymentServer{stream}) +} + +type Lightning_SendPaymentServer interface { + Send(*SendResponse) error + Recv() (*SendRequest, error) + grpc.ServerStream +} + +type lightningSendPaymentServer struct { + grpc.ServerStream +} + +func (x *lightningSendPaymentServer) Send(m *SendResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *lightningSendPaymentServer) Recv() (*SendRequest, error) { + m := new(SendRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _Lightning_SendPaymentSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SendRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).SendPaymentSync(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/SendPaymentSync", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).SendPaymentSync(ctx, req.(*SendRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SendToRoute_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(LightningServer).SendToRoute(&lightningSendToRouteServer{stream}) +} + +type Lightning_SendToRouteServer interface { + Send(*SendResponse) error + Recv() (*SendToRouteRequest, error) + grpc.ServerStream +} + +type lightningSendToRouteServer struct { + grpc.ServerStream +} + +func (x *lightningSendToRouteServer) Send(m *SendResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *lightningSendToRouteServer) Recv() (*SendToRouteRequest, error) { + m := new(SendToRouteRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func _Lightning_SendToRouteSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SendToRouteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).SendToRouteSync(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/SendToRouteSync", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).SendToRouteSync(ctx, req.(*SendToRouteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_AddInvoice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Invoice) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).AddInvoice(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/AddInvoice", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).AddInvoice(ctx, req.(*Invoice)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListInvoices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListInvoiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListInvoices(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListInvoices", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListInvoices(ctx, req.(*ListInvoiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_LookupInvoice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PaymentHash) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).LookupInvoice(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/LookupInvoice", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).LookupInvoice(ctx, req.(*PaymentHash)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribeInvoices_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(InvoiceSubscription) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribeInvoices(m, &lightningSubscribeInvoicesServer{stream}) +} + +type Lightning_SubscribeInvoicesServer interface { + Send(*Invoice) error + grpc.ServerStream +} + +type lightningSubscribeInvoicesServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribeInvoicesServer) Send(m *Invoice) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_DecodePayReq_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PayReqString) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DecodePayReq(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DecodePayReq", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DecodePayReq(ctx, req.(*PayReqString)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListPayments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListPaymentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListPayments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListPayments", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListPayments(ctx, req.(*ListPaymentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_DeleteAllPayments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteAllPaymentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DeleteAllPayments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DeleteAllPayments", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DeleteAllPayments(ctx, req.(*DeleteAllPaymentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_DescribeGraph_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChannelGraphRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DescribeGraph(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DescribeGraph", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DescribeGraph(ctx, req.(*ChannelGraphRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetNodeMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(NodeMetricsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetNodeMetrics(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetNodeMetrics", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetNodeMetrics(ctx, req.(*NodeMetricsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetChanInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChanInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetChanInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetChanInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetChanInfo(ctx, req.(*ChanInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetNodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(NodeInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetNodeInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetNodeInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetNodeInfo(ctx, req.(*NodeInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_QueryRoutes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRoutesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).QueryRoutes(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/QueryRoutes", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).QueryRoutes(ctx, req.(*QueryRoutesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_GetNetworkInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(NetworkInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).GetNetworkInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/GetNetworkInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).GetNetworkInfo(ctx, req.(*NetworkInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_StopDaemon_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).StopDaemon(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/StopDaemon", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).StopDaemon(ctx, req.(*StopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribeChannelGraph_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(GraphTopologySubscription) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribeChannelGraph(m, &lightningSubscribeChannelGraphServer{stream}) +} + +type Lightning_SubscribeChannelGraphServer interface { + Send(*GraphTopologyUpdate) error + grpc.ServerStream +} + +type lightningSubscribeChannelGraphServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribeChannelGraphServer) Send(m *GraphTopologyUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_DebugLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DebugLevelRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DebugLevel(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DebugLevel", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DebugLevel(ctx, req.(*DebugLevelRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_FeeReport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FeeReportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).FeeReport(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/FeeReport", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).FeeReport(ctx, req.(*FeeReportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_UpdateChannelPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PolicyUpdateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).UpdateChannelPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/UpdateChannelPolicy", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).UpdateChannelPolicy(ctx, req.(*PolicyUpdateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ForwardingHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ForwardingHistoryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ForwardingHistory(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ForwardingHistory", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ForwardingHistory(ctx, req.(*ForwardingHistoryRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ExportChannelBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExportChannelBackupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ExportChannelBackup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ExportChannelBackup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ExportChannelBackup(ctx, req.(*ExportChannelBackupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ExportAllChannelBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChanBackupExportRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ExportAllChannelBackups(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ExportAllChannelBackups", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ExportAllChannelBackups(ctx, req.(*ChanBackupExportRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_VerifyChanBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChanBackupSnapshot) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).VerifyChanBackup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/VerifyChanBackup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).VerifyChanBackup(ctx, req.(*ChanBackupSnapshot)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_RestoreChannelBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RestoreChanBackupRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).RestoreChannelBackups(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/RestoreChannelBackups", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).RestoreChannelBackups(ctx, req.(*RestoreChanBackupRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_SubscribeChannelBackups_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ChannelBackupSubscription) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).SubscribeChannelBackups(m, &lightningSubscribeChannelBackupsServer{stream}) +} + +type Lightning_SubscribeChannelBackupsServer interface { + Send(*ChanBackupSnapshot) error + grpc.ServerStream +} + +type lightningSubscribeChannelBackupsServer struct { + grpc.ServerStream +} + +func (x *lightningSubscribeChannelBackupsServer) Send(m *ChanBackupSnapshot) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_BakeMacaroon_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BakeMacaroonRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).BakeMacaroon(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/BakeMacaroon", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).BakeMacaroon(ctx, req.(*BakeMacaroonRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListMacaroonIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListMacaroonIDsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListMacaroonIDs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListMacaroonIDs", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListMacaroonIDs(ctx, req.(*ListMacaroonIDsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_DeleteMacaroonID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteMacaroonIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).DeleteMacaroonID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/DeleteMacaroonID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).DeleteMacaroonID(ctx, req.(*DeleteMacaroonIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Lightning_ListPermissions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListPermissionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LightningServer).ListPermissions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/lnrpc.Lightning/ListPermissions", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LightningServer).ListPermissions(ctx, req.(*ListPermissionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Lightning_serviceDesc = grpc.ServiceDesc{ + ServiceName: "lnrpc.Lightning", + HandlerType: (*LightningServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "WalletBalance", + Handler: _Lightning_WalletBalance_Handler, + }, + { + MethodName: "ChannelBalance", + Handler: _Lightning_ChannelBalance_Handler, + }, + { + MethodName: "GetTransactions", + Handler: _Lightning_GetTransactions_Handler, + }, + { + MethodName: "EstimateFee", + Handler: _Lightning_EstimateFee_Handler, + }, + { + MethodName: "SendCoins", + Handler: _Lightning_SendCoins_Handler, + }, + { + MethodName: "ListUnspent", + Handler: _Lightning_ListUnspent_Handler, + }, + { + MethodName: "SendMany", + Handler: _Lightning_SendMany_Handler, + }, + { + MethodName: "NewAddress", + Handler: _Lightning_NewAddress_Handler, + }, + { + MethodName: "SignMessage", + Handler: _Lightning_SignMessage_Handler, + }, + { + MethodName: "VerifyMessage", + Handler: _Lightning_VerifyMessage_Handler, + }, + { + MethodName: "ConnectPeer", + Handler: _Lightning_ConnectPeer_Handler, + }, + { + MethodName: "DisconnectPeer", + Handler: _Lightning_DisconnectPeer_Handler, + }, + { + MethodName: "ListPeers", + Handler: _Lightning_ListPeers_Handler, + }, + { + MethodName: "GetInfo", + Handler: _Lightning_GetInfo_Handler, + }, + { + MethodName: "GetRecoveryInfo", + Handler: _Lightning_GetRecoveryInfo_Handler, + }, + { + MethodName: "PendingChannels", + Handler: _Lightning_PendingChannels_Handler, + }, + { + MethodName: "ListChannels", + Handler: _Lightning_ListChannels_Handler, + }, + { + MethodName: "ClosedChannels", + Handler: _Lightning_ClosedChannels_Handler, + }, + { + MethodName: "OpenChannelSync", + Handler: _Lightning_OpenChannelSync_Handler, + }, + { + MethodName: "FundingStateStep", + Handler: _Lightning_FundingStateStep_Handler, + }, + { + MethodName: "AbandonChannel", + Handler: _Lightning_AbandonChannel_Handler, + }, + { + MethodName: "SendPaymentSync", + Handler: _Lightning_SendPaymentSync_Handler, + }, + { + MethodName: "SendToRouteSync", + Handler: _Lightning_SendToRouteSync_Handler, + }, + { + MethodName: "AddInvoice", + Handler: _Lightning_AddInvoice_Handler, + }, + { + MethodName: "ListInvoices", + Handler: _Lightning_ListInvoices_Handler, + }, + { + MethodName: "LookupInvoice", + Handler: _Lightning_LookupInvoice_Handler, + }, + { + MethodName: "DecodePayReq", + Handler: _Lightning_DecodePayReq_Handler, + }, + { + MethodName: "ListPayments", + Handler: _Lightning_ListPayments_Handler, + }, + { + MethodName: "DeleteAllPayments", + Handler: _Lightning_DeleteAllPayments_Handler, + }, + { + MethodName: "DescribeGraph", + Handler: _Lightning_DescribeGraph_Handler, + }, + { + MethodName: "GetNodeMetrics", + Handler: _Lightning_GetNodeMetrics_Handler, + }, + { + MethodName: "GetChanInfo", + Handler: _Lightning_GetChanInfo_Handler, + }, + { + MethodName: "GetNodeInfo", + Handler: _Lightning_GetNodeInfo_Handler, + }, + { + MethodName: "QueryRoutes", + Handler: _Lightning_QueryRoutes_Handler, + }, + { + MethodName: "GetNetworkInfo", + Handler: _Lightning_GetNetworkInfo_Handler, + }, + { + MethodName: "StopDaemon", + Handler: _Lightning_StopDaemon_Handler, + }, + { + MethodName: "DebugLevel", + Handler: _Lightning_DebugLevel_Handler, + }, + { + MethodName: "FeeReport", + Handler: _Lightning_FeeReport_Handler, + }, + { + MethodName: "UpdateChannelPolicy", + Handler: _Lightning_UpdateChannelPolicy_Handler, + }, + { + MethodName: "ForwardingHistory", + Handler: _Lightning_ForwardingHistory_Handler, + }, + { + MethodName: "ExportChannelBackup", + Handler: _Lightning_ExportChannelBackup_Handler, + }, + { + MethodName: "ExportAllChannelBackups", + Handler: _Lightning_ExportAllChannelBackups_Handler, + }, + { + MethodName: "VerifyChanBackup", + Handler: _Lightning_VerifyChanBackup_Handler, + }, + { + MethodName: "RestoreChannelBackups", + Handler: _Lightning_RestoreChannelBackups_Handler, + }, + { + MethodName: "BakeMacaroon", + Handler: _Lightning_BakeMacaroon_Handler, + }, + { + MethodName: "ListMacaroonIDs", + Handler: _Lightning_ListMacaroonIDs_Handler, + }, + { + MethodName: "DeleteMacaroonID", + Handler: _Lightning_DeleteMacaroonID_Handler, + }, + { + MethodName: "ListPermissions", + Handler: _Lightning_ListPermissions_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "SubscribeTransactions", + Handler: _Lightning_SubscribeTransactions_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribePeerEvents", + Handler: _Lightning_SubscribePeerEvents_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribeChannelEvents", + Handler: _Lightning_SubscribeChannelEvents_Handler, + ServerStreams: true, + }, + { + StreamName: "OpenChannel", + Handler: _Lightning_OpenChannel_Handler, + ServerStreams: true, + }, + { + StreamName: "ChannelAcceptor", + Handler: _Lightning_ChannelAcceptor_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "CloseChannel", + Handler: _Lightning_CloseChannel_Handler, + ServerStreams: true, + }, + { + StreamName: "SendPayment", + Handler: _Lightning_SendPayment_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "SendToRoute", + Handler: _Lightning_SendToRoute_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "SubscribeInvoices", + Handler: _Lightning_SubscribeInvoices_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribeChannelGraph", + Handler: _Lightning_SubscribeChannelGraph_Handler, + ServerStreams: true, + }, + { + StreamName: "SubscribeChannelBackups", + Handler: _Lightning_SubscribeChannelBackups_Handler, + ServerStreams: true, + }, + }, + Metadata: "rpc.proto", +} diff --git a/service/lnd/proto/rpc.proto b/service/lnd/proto/rpc.proto new file mode 100644 index 0000000..ad79515 --- /dev/null +++ b/service/lnd/proto/rpc.proto @@ -0,0 +1,3599 @@ +syntax = "proto3"; + +package lnrpc; + +option go_package = "service/lnd/lnrpc"; + +/* + * Comments in this file will be directly parsed into the API + * Documentation as descriptions of the associated method, message, or field. + * These descriptions should go right above the definition of the object, and + * can be in either block or // comment format. + * + * An RPC method can be matched to an lncli command by placing a line in the + * beginning of the description in exactly the following format: + * lncli: `methodname` + * + * Failure to specify the exact name of the command will cause documentation + * generation to fail. + * + * More information on how exactly the gRPC documentation is generated from + * this proto file can be found here: + * https://github.com/lightninglabs/lightning-api + */ + +// Lightning is the main RPC server of the daemon. +service Lightning { + /* lncli: `walletbalance` + WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + confirmed unspent outputs and all unconfirmed unspent outputs under control + of the wallet. + */ + rpc WalletBalance (WalletBalanceRequest) returns (WalletBalanceResponse); + + /* lncli: `channelbalance` + ChannelBalance returns the total funds available across all open channels + in satoshis. + */ + rpc ChannelBalance (ChannelBalanceRequest) returns (ChannelBalanceResponse); + + /* lncli: `listchaintxns` + GetTransactions returns a list describing all the known transactions + relevant to the wallet. + */ + rpc GetTransactions (GetTransactionsRequest) returns (TransactionDetails); + + /* lncli: `estimatefee` + EstimateFee asks the chain backend to estimate the fee rate and total fees + for a transaction that pays to multiple specified outputs. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + */ + rpc EstimateFee (EstimateFeeRequest) returns (EstimateFeeResponse); + + /* lncli: `sendcoins` + SendCoins executes a request to send coins to a particular address. Unlike + SendMany, this RPC call only allows creating a single output at a time. If + neither target_conf, or sat_per_byte are set, then the internal wallet will + consult its fee model to determine a fee for the default confirmation + target. + */ + rpc SendCoins (SendCoinsRequest) returns (SendCoinsResponse); + + /* lncli: `listunspent` + Deprecated, use walletrpc.ListUnspent instead. + + ListUnspent returns a list of all utxos spendable by the wallet with a + number of confirmations between the specified minimum and maximum. + */ + rpc ListUnspent (ListUnspentRequest) returns (ListUnspentResponse); + + /* + SubscribeTransactions creates a uni-directional stream from the server to + the client in which any newly discovered transactions relevant to the + wallet are sent over. + */ + rpc SubscribeTransactions (GetTransactionsRequest) + returns (stream Transaction); + + /* lncli: `sendmany` + SendMany handles a request for a transaction that creates multiple specified + outputs in parallel. If neither target_conf, or sat_per_byte are set, then + the internal wallet will consult its fee model to determine a fee for the + default confirmation target. + */ + rpc SendMany (SendManyRequest) returns (SendManyResponse); + + /* lncli: `newaddress` + NewAddress creates a new address under control of the local wallet. + */ + rpc NewAddress (NewAddressRequest) returns (NewAddressResponse); + + /* lncli: `signmessage` + SignMessage signs a message with this node's private key. The returned + signature string is `zbase32` encoded and pubkey recoverable, meaning that + only the message digest and signature are needed for verification. + */ + rpc SignMessage (SignMessageRequest) returns (SignMessageResponse); + + /* lncli: `verifymessage` + VerifyMessage verifies a signature over a msg. The signature must be + zbase32 encoded and signed by an active node in the resident node's + channel database. In addition to returning the validity of the signature, + VerifyMessage also returns the recovered pubkey from the signature. + */ + rpc VerifyMessage (VerifyMessageRequest) returns (VerifyMessageResponse); + + /* lncli: `connect` + ConnectPeer attempts to establish a connection to a remote peer. This is at + the networking level, and is used for communication between nodes. This is + distinct from establishing a channel with a peer. + */ + rpc ConnectPeer (ConnectPeerRequest) returns (ConnectPeerResponse); + + /* lncli: `disconnect` + DisconnectPeer attempts to disconnect one peer from another identified by a + given pubKey. In the case that we currently have a pending or active channel + with the target peer, then this action will be not be allowed. + */ + rpc DisconnectPeer (DisconnectPeerRequest) returns (DisconnectPeerResponse); + + /* lncli: `listpeers` + ListPeers returns a verbose listing of all currently active peers. + */ + rpc ListPeers (ListPeersRequest) returns (ListPeersResponse); + + /* + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + */ + rpc SubscribePeerEvents (PeerEventSubscription) returns (stream PeerEvent); + + /* lncli: `getinfo` + GetInfo returns general information concerning the lightning node including + it's identity pubkey, alias, the chains it is connected to, and information + concerning the number of open+pending channels. + */ + rpc GetInfo (GetInfoRequest) returns (GetInfoResponse); + + /** lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + */ + rpc GetRecoveryInfo (GetRecoveryInfoRequest) + returns (GetRecoveryInfoResponse); + + // TODO(roasbeef): merge with below with bool? + /* lncli: `pendingchannels` + PendingChannels returns a list of all the channels that are currently + considered "pending". A channel is pending if it has finished the funding + workflow and is waiting for confirmations for the funding txn, or is in the + process of closure, either initiated cooperatively or non-cooperatively. + */ + rpc PendingChannels (PendingChannelsRequest) + returns (PendingChannelsResponse); + + /* lncli: `listchannels` + ListChannels returns a description of all the open channels that this node + is a participant in. + */ + rpc ListChannels (ListChannelsRequest) returns (ListChannelsResponse); + + /* + SubscribeChannelEvents creates a uni-directional stream from the server to + the client in which any updates relevant to the state of the channels are + sent over. Events include new active channels, inactive channels, and closed + channels. + */ + rpc SubscribeChannelEvents (ChannelEventSubscription) + returns (stream ChannelEventUpdate); + + /* lncli: `closedchannels` + ClosedChannels returns a description of all the closed channels that + this node was a participant in. + */ + rpc ClosedChannels (ClosedChannelsRequest) returns (ClosedChannelsResponse); + + /* + OpenChannelSync is a synchronous version of the OpenChannel RPC call. This + call is meant to be consumed by clients to the REST proxy. As with all + other sync calls, all byte slices are intended to be populated as hex + encoded strings. + */ + rpc OpenChannelSync (OpenChannelRequest) returns (ChannelPoint); + + /* lncli: `openchannel` + OpenChannel attempts to open a singly funded channel specified in the + request to a remote peer. Users are able to specify a target number of + blocks that the funding transaction should be confirmed in, or a manual fee + rate to us for the funding transaction. If neither are specified, then a + lax block confirmation target is used. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + */ + rpc OpenChannel (OpenChannelRequest) returns (stream OpenStatusUpdate); + + /* + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + */ + rpc FundingStateStep (FundingTransitionMsg) returns (FundingStateStepResp); + + /* + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + */ + rpc ChannelAcceptor (stream ChannelAcceptResponse) + returns (stream ChannelAcceptRequest); + + /* lncli: `closechannel` + CloseChannel attempts to close an active channel identified by its channel + outpoint (ChannelPoint). The actions of this method can additionally be + augmented to attempt a force close after a timeout period in the case of an + inactive peer. If a non-force close (cooperative closure) is requested, + then the user can specify either a target number of blocks until the + closure transaction is confirmed, or a manual fee rate. If neither are + specified, then a default lax, block confirmation target is used. + */ + rpc CloseChannel (CloseChannelRequest) returns (stream CloseStatusUpdate); + + /* lncli: `abandonchannel` + AbandonChannel removes all channel state from the database except for a + close summary. This method can be used to get rid of permanently unusable + channels due to bugs fixed in newer versions of lnd. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + */ + rpc AbandonChannel (AbandonChannelRequest) returns (AbandonChannelResponse); + + /* lncli: `sendpayment` + Deprecated, use routerrpc.SendPaymentV2. SendPayment dispatches a + bi-directional streaming RPC for sending payments through the Lightning + Network. A single RPC invocation creates a persistent bi-directional + stream allowing clients to rapidly send payments through the Lightning + Network with a single persistent connection. + */ + rpc SendPayment (stream SendRequest) returns (stream SendResponse) { + option deprecated = true; + } + + /* + SendPaymentSync is the synchronous non-streaming version of SendPayment. + This RPC is intended to be consumed by clients of the REST proxy. + Additionally, this RPC expects the destination's public key and the payment + hash (if any) to be encoded as hex strings. + */ + rpc SendPaymentSync (SendRequest) returns (SendResponse); + + /* lncli: `sendtoroute` + Deprecated, use routerrpc.SendToRouteV2. SendToRoute is a bi-directional + streaming RPC for sending payment through the Lightning Network. 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. + */ + rpc SendToRoute (stream SendToRouteRequest) returns (stream SendResponse) { + option deprecated = true; + } + + /* + SendToRouteSync is a synchronous version of SendToRoute. It Will block + until the payment either fails or succeeds. + */ + rpc SendToRouteSync (SendToRouteRequest) returns (SendResponse); + + /* lncli: `addinvoice` + AddInvoice attempts to add a new invoice to the invoice database. Any + duplicated invoices are rejected, therefore all invoices *must* have a + unique payment preimage. + */ + rpc AddInvoice (Invoice) returns (AddInvoiceResponse); + + /* lncli: `listinvoices` + ListInvoices returns a list of all the invoices currently stored within the + database. Any active debug invoices are ignored. It has full support for + paginated responses, allowing users to query for specific invoices through + their add_index. This can be done by using either the first_index_offset or + last_index_offset fields included in the response as the index_offset of the + next request. By default, the first 100 invoices created will be returned. + Backwards pagination is also supported through the Reversed flag. + */ + rpc ListInvoices (ListInvoiceRequest) returns (ListInvoiceResponse); + + /* lncli: `lookupinvoice` + LookupInvoice attempts to look up an invoice according to its payment hash. + The passed payment hash *must* be exactly 32 bytes, if not, an error is + returned. + */ + rpc LookupInvoice (PaymentHash) returns (Invoice); + + /* + SubscribeInvoices returns a uni-directional stream (server -> client) for + notifying the client of newly added/settled invoices. The caller can + optionally specify the add_index and/or the settle_index. If the add_index + is specified, then we'll first start by sending add invoice events for all + invoices with an add_index greater than the specified value. If the + settle_index is specified, the next, we'll send out all settle events for + invoices with a settle_index greater than the specified value. One or both + of these fields can be set. If no fields are set, then we'll only send out + the latest add/settle events. + */ + rpc SubscribeInvoices (InvoiceSubscription) returns (stream Invoice); + + /* lncli: `decodepayreq` + DecodePayReq takes an encoded payment request string and attempts to decode + it, returning a full description of the conditions encoded within the + payment request. + */ + rpc DecodePayReq (PayReqString) returns (PayReq); + + /* lncli: `listpayments` + ListPayments returns a list of all outgoing payments. + */ + rpc ListPayments (ListPaymentsRequest) returns (ListPaymentsResponse); + + /* + DeleteAllPayments deletes all outgoing payments from DB. + */ + rpc DeleteAllPayments (DeleteAllPaymentsRequest) + returns (DeleteAllPaymentsResponse); + + /* lncli: `describegraph` + DescribeGraph returns a description of the latest graph state from the + point of view of the node. The graph information is partitioned into two + components: all the nodes/vertexes, and all the edges that connect the + vertexes themselves. As this is a directed graph, the edges also contain + the node directional specific routing policy which includes: the time lock + delta, fee information, etc. + */ + rpc DescribeGraph (ChannelGraphRequest) returns (ChannelGraph); + + /* lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + */ + rpc GetNodeMetrics (NodeMetricsRequest) returns (NodeMetricsResponse); + + /* lncli: `getchaninfo` + GetChanInfo returns the latest authenticated network announcement for the + given channel identified by its channel ID: an 8-byte integer which + uniquely identifies the location of transaction's funding output within the + blockchain. + */ + rpc GetChanInfo (ChanInfoRequest) returns (ChannelEdge); + + /* lncli: `getnodeinfo` + GetNodeInfo returns the latest advertised, aggregated, and authenticated + channel information for the specified node identified by its public key. + */ + rpc GetNodeInfo (NodeInfoRequest) returns (NodeInfo); + + /* lncli: `queryroutes` + QueryRoutes attempts to query the daemon's Channel Router for a possible + route to a target destination capable of carrying a specific amount of + satoshis. The returned route contains the full details required to craft and + send an HTLC, also including the necessary information that should be + present within the Sphinx packet encapsulated within the HTLC. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + */ + rpc QueryRoutes (QueryRoutesRequest) returns (QueryRoutesResponse); + + /* lncli: `getnetworkinfo` + GetNetworkInfo returns some basic stats about the known channel graph from + the point of view of the node. + */ + rpc GetNetworkInfo (NetworkInfoRequest) returns (NetworkInfo); + + /* lncli: `stop` + StopDaemon will send a shutdown request to the interrupt handler, triggering + a graceful shutdown of the daemon. + */ + rpc StopDaemon (StopRequest) returns (StopResponse); + + /* + SubscribeChannelGraph launches a streaming RPC that allows the caller to + receive notifications upon any changes to the channel graph topology from + the point of view of the responding node. Events notified include: new + nodes coming online, nodes updating their authenticated attributes, new + channels being advertised, updates in the routing policy for a directional + channel edge, and when channels are closed on-chain. + */ + rpc SubscribeChannelGraph (GraphTopologySubscription) + returns (stream GraphTopologyUpdate); + + /* lncli: `debuglevel` + DebugLevel allows a caller to programmatically set the logging verbosity of + lnd. The logging can be targeted according to a coarse daemon-wide logging + level, or in a granular fashion to specify the logging for a target + sub-system. + */ + rpc DebugLevel (DebugLevelRequest) returns (DebugLevelResponse); + + /* lncli: `feereport` + FeeReport allows the caller to obtain a report detailing the current fee + schedule enforced by the node globally for each channel. + */ + rpc FeeReport (FeeReportRequest) returns (FeeReportResponse); + + /* lncli: `updatechanpolicy` + UpdateChannelPolicy allows the caller to update the fee schedule and + channel policies for all channels globally, or a particular channel. + */ + rpc UpdateChannelPolicy (PolicyUpdateRequest) + returns (PolicyUpdateResponse); + + /* lncli: `fwdinghistory` + ForwardingHistory allows the caller to query the htlcswitch for a record of + all HTLCs forwarded within the target time range, and integer offset + within that time range. If no time-range is specified, then the first chunk + of the past 24 hrs of forwarding history are returned. + + A list of forwarding events are returned. The size of each forwarding event + is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB. + As a result each message can only contain 50k entries. Each response has + the index offset of the last entry. The index offset can be provided to the + request to allow the caller to skip a series of records. + */ + rpc ForwardingHistory (ForwardingHistoryRequest) + returns (ForwardingHistoryResponse); + + /* lncli: `exportchanbackup` + ExportChannelBackup attempts to return an encrypted static channel backup + for the target channel identified by it channel point. The backup is + encrypted with a key generated from the aezeed seed of the user. The + returned backup can either be restored using the RestoreChannelBackup + method once lnd is running, or via the InitWallet and UnlockWallet methods + from the WalletUnlocker service. + */ + rpc ExportChannelBackup (ExportChannelBackupRequest) + returns (ChannelBackup); + + /* + ExportAllChannelBackups returns static channel backups for all existing + channels known to lnd. A set of regular singular static channel backups for + each channel are returned. Additionally, a multi-channel backup is returned + as well, which contains a single encrypted blob containing the backups of + each channel. + */ + rpc ExportAllChannelBackups (ChanBackupExportRequest) + returns (ChanBackupSnapshot); + + /* + VerifyChanBackup allows a caller to verify the integrity of a channel backup + snapshot. This method will accept either a packed Single or a packed Multi. + Specifying both will result in an error. + */ + rpc VerifyChanBackup (ChanBackupSnapshot) + returns (VerifyChanBackupResponse); + + /* lncli: `restorechanbackup` + RestoreChannelBackups accepts a set of singular channel backups, or a + single encrypted multi-chan backup and attempts to recover any funds + remaining within the channel. If we are able to unpack the backup, then the + new channel will be shown under listchannels, as well as pending channels. + */ + rpc RestoreChannelBackups (RestoreChanBackupRequest) + returns (RestoreBackupResponse); + + /* + SubscribeChannelBackups allows a client to sub-subscribe to the most up to + date information concerning the state of all channel backups. Each time a + new channel is added, we return the new set of channels, along with a + multi-chan backup containing the backup info for all channels. Each time a + channel is closed, we send a new update, which contains new new chan back + ups, but the updated set of encrypted multi-chan backups with the closed + channel(s) removed. + */ + rpc SubscribeChannelBackups (ChannelBackupSubscription) + returns (stream ChanBackupSnapshot); + + /* lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + */ + rpc BakeMacaroon (BakeMacaroonRequest) returns (BakeMacaroonResponse); + + /* lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + */ + rpc ListMacaroonIDs (ListMacaroonIDsRequest) + returns (ListMacaroonIDsResponse); + + /* lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + */ + rpc DeleteMacaroonID (DeleteMacaroonIDRequest) + returns (DeleteMacaroonIDResponse); + + /* lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + */ + rpc ListPermissions (ListPermissionsRequest) + returns (ListPermissionsResponse); +} + +message Utxo { + // The type of address + AddressType address_type = 1; + + // The address + string address = 2; + + // The value of the unspent coin in satoshis + int64 amount_sat = 3; + + // The pkscript in hex + string pk_script = 4; + + // The outpoint in format txid:n + OutPoint outpoint = 5; + + // The number of confirmations for the Utxo + int64 confirmations = 6; +} + +message Transaction { + // The transaction hash + string tx_hash = 1; + + // The transaction amount, denominated in satoshis + int64 amount = 2; + + // The number of confirmations + int32 num_confirmations = 3; + + // The hash of the block this transaction was included in + string block_hash = 4; + + // The height of the block this transaction was included in + int32 block_height = 5; + + // Timestamp of this transaction + int64 time_stamp = 6; + + // Fees paid for this transaction + int64 total_fees = 7; + + // Addresses that received funds for this transaction + repeated string dest_addresses = 8; + + // The raw transaction hex. + string raw_tx_hex = 9; + + // A label that was optionally set on transaction broadcast. + string label = 10; +} +message GetTransactionsRequest { + /* + The height from which to list transactions, inclusive. If this value is + greater than end_height, transactions will be read in reverse. + */ + int32 start_height = 1; + + /* + The height until which to list transactions, inclusive. To include + unconfirmed transactions, this value should be set to -1, which will + return transactions from start_height until the current chain tip and + unconfirmed transactions. If no end_height is provided, the call will + default to this option. + */ + int32 end_height = 2; +} + +message TransactionDetails { + // The list of transactions relevant to the wallet. + repeated Transaction transactions = 1; +} + +message FeeLimit { + oneof limit { + /* + The fee limit expressed as a fixed amount of satoshis. + + The fields fixed and fixed_msat are mutually exclusive. + */ + int64 fixed = 1; + + /* + The fee limit expressed as a fixed amount of millisatoshis. + + The fields fixed and fixed_msat are mutually exclusive. + */ + int64 fixed_msat = 3; + + // The fee limit expressed as a percentage of the payment amount. + int64 percent = 2; + } +} + +message SendRequest { + /* + The identity pubkey of the payment recipient. When using REST, this field + must be encoded as base64. + */ + bytes dest = 1; + + /* + The hex-encoded identity pubkey of the payment recipient. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string dest_string = 2 [deprecated = true]; + + /* + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt = 3; + + /* + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt_msat = 12; + + /* + The hash to use within the payment's HTLC. When using REST, this field + must be encoded as base64. + */ + bytes payment_hash = 4; + + /* + The hex-encoded hash to use within the payment's HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string payment_hash_string = 5 [deprecated = true]; + + /* + 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. + */ + string payment_request = 6; + + /* + The CLTV delta from the current height that should be used to set the + timelock for the final hop. + */ + int32 final_cltv_delta = 7; + + /* + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. + */ + FeeLimit fee_limit = 8; + + /* + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + */ + uint64 outgoing_chan_id = 9 [jstype = JS_STRING]; + + /* + The pubkey of the last hop of the route. If empty, any hop may be used. + */ + bytes last_hop_pubkey = 13; + + /* + 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. + */ + uint32 cltv_limit = 10; + + /* + 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. + */ + map dest_custom_records = 11; + + // If set, circular payments to self are permitted. + bool allow_self_payment = 14; + + /* + 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. + */ + repeated FeatureBit dest_features = 15; +} + +message SendResponse { + string payment_error = 1; + bytes payment_preimage = 2; + Route payment_route = 3; + bytes payment_hash = 4; +} + +message SendToRouteRequest { + /* + The payment hash to use for the HTLC. When using REST, this field must be + encoded as base64. + */ + bytes payment_hash = 1; + + /* + An optional hex-encoded payment hash to be used for the HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string payment_hash_string = 2 [deprecated = true]; + + reserved 3; + + // Route that should be used to attempt to complete the payment. + Route route = 4; +} + +message ChannelAcceptRequest { + // The pubkey of the node that wishes to open an inbound channel. + bytes node_pubkey = 1; + + // The hash of the genesis block that the proposed channel resides in. + bytes chain_hash = 2; + + // The pending channel id. + bytes pending_chan_id = 3; + + // The funding amount in satoshis that initiator wishes to use in the + // channel. + uint64 funding_amt = 4; + + // The push amount of the proposed channel in millisatoshis. + uint64 push_amt = 5; + + // The dust limit of the initiator's commitment tx. + uint64 dust_limit = 6; + + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + uint64 max_value_in_flight = 7; + + // The minimum amount of satoshis the initiator requires us to have at all + // times. + uint64 channel_reserve = 8; + + // The smallest HTLC in millisatoshis that the initiator will accept. + uint64 min_htlc = 9; + + // The initial fee rate that the initiator suggests for both commitment + // transactions. + uint64 fee_per_kw = 10; + + /* + The number of blocks to use for the relative time lock in the pay-to-self + output of both commitment transactions. + */ + uint32 csv_delay = 11; + + // The total number of incoming HTLC's that the initiator will accept. + uint32 max_accepted_htlcs = 12; + + // A bit-field which the initiator uses to specify proposed channel + // behavior. + uint32 channel_flags = 13; +} + +message ChannelAcceptResponse { + // Whether or not the client accepts the channel. + bool accept = 1; + + // The pending channel id to which this response applies. + bytes pending_chan_id = 2; +} + +message ChannelPoint { + oneof funding_txid { + /* + Txid of the funding transaction. When using REST, this field must be + encoded as base64. + */ + bytes funding_txid_bytes = 1; + + /* + Hex-encoded string representing the byte-reversed hash of the funding + transaction. + */ + string funding_txid_str = 2; + } + + // The index of the output of the funding transaction + uint32 output_index = 3; +} + +message OutPoint { + // Raw bytes representing the transaction id. + bytes txid_bytes = 1; + + // Reversed, hex-encoded string representing the transaction id. + string txid_str = 2; + + // The index of the output on the transaction. + uint32 output_index = 3; +} + +message LightningAddress { + // The identity pubkey of the Lightning node + string pubkey = 1; + + // The network location of the lightning node, e.g. `69.69.69.69:1337` or + // `localhost:10011` + string host = 2; +} + +message EstimateFeeRequest { + // The map from addresses to amounts for the transaction. + map AddrToAmount = 1; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 2; +} + +message EstimateFeeResponse { + // The total fee in satoshis. + int64 fee_sat = 1; + + // The fee rate in satoshi/byte. + int64 feerate_sat_per_byte = 2; +} + +message SendManyRequest { + // The map from addresses to amounts + map AddrToAmount = 1; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 3; + + // A manual fee rate set in sat/byte that should be used when crafting the + // transaction. + int64 sat_per_byte = 5; + + // An optional label for the transaction, limited to 500 characters. + string label = 6; +} +message SendManyResponse { + // The id of the transaction + string txid = 1; +} + +message SendCoinsRequest { + // The address to send coins to + string addr = 1; + + // The amount in satoshis to send + int64 amount = 2; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 3; + + // A manual fee rate set in sat/byte that should be used when crafting the + // transaction. + int64 sat_per_byte = 5; + + /* + If set, then the amount field will be ignored, and lnd will attempt to + send all the coins under control of the internal wallet to the specified + address. + */ + bool send_all = 6; + + // An optional label for the transaction, limited to 500 characters. + string label = 7; +} +message SendCoinsResponse { + // The transaction ID of the transaction + string txid = 1; +} + +message ListUnspentRequest { + // The minimum number of confirmations to be included. + int32 min_confs = 1; + + // The maximum number of confirmations to be included. + int32 max_confs = 2; +} +message ListUnspentResponse { + // A list of utxos + repeated Utxo utxos = 1; +} + +/* +`AddressType` has to be one of: + +- `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) +- `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1) +*/ +enum AddressType { + WITNESS_PUBKEY_HASH = 0; + NESTED_PUBKEY_HASH = 1; + UNUSED_WITNESS_PUBKEY_HASH = 2; + UNUSED_NESTED_PUBKEY_HASH = 3; +} + +message NewAddressRequest { + // The address type + AddressType type = 1; +} +message NewAddressResponse { + // The newly generated wallet address + string address = 1; +} + +message SignMessageRequest { + /* + The message to be signed. When using REST, this field must be encoded as + base64. + */ + bytes msg = 1; +} +message SignMessageResponse { + // The signature for the given message + string signature = 1; +} + +message VerifyMessageRequest { + /* + The message over which the signature is to be verified. When using REST, + this field must be encoded as base64. + */ + bytes msg = 1; + + // The signature to be verified over the given message + string signature = 2; +} +message VerifyMessageResponse { + // Whether the signature was valid over the given message + bool valid = 1; + + // The pubkey recovered from the signature + string pubkey = 2; +} + +message ConnectPeerRequest { + // Lightning address of the peer, in the format `@host` + LightningAddress addr = 1; + + /* If set, the daemon will attempt to persistently connect to the target + * peer. Otherwise, the call will be synchronous. */ + bool perm = 2; + + /* + The connection timeout value (in seconds) for this request. It won't affect + other requests. + */ + uint64 timeout = 3; +} +message ConnectPeerResponse { +} + +message DisconnectPeerRequest { + // The pubkey of the node to disconnect from + string pub_key = 1; +} +message DisconnectPeerResponse { +} + +message HTLC { + bool incoming = 1; + int64 amount = 2; + bytes hash_lock = 3; + uint32 expiration_height = 4; +} + +enum CommitmentType { + /* + A channel using the legacy commitment format having tweaked to_remote + keys. + */ + LEGACY = 0; + + /* + A channel that uses the modern commitment format where the key in the + output of the remote party does not change each state. This makes back + up and recovery easier as when the channel is closed, the funds go + directly to that key. + */ + STATIC_REMOTE_KEY = 1; + + /* + A channel that uses a commitment format that has anchor outputs on the + commitments, allowing fee bumping after a force close transaction has + been broadcast. + */ + ANCHORS = 2; + + /* + Returned when the commitment type isn't known or unavailable. + */ + UNKNOWN_COMMITMENT_TYPE = 999; +} + +message ChannelConstraints { + /* + The CSV delay expressed in relative blocks. If the channel is force closed, + we will need to wait for this many blocks before we can regain our funds. + */ + uint32 csv_delay = 1; + + // The minimum satoshis this node is required to reserve in its balance. + uint64 chan_reserve_sat = 2; + + // The dust limit (in satoshis) of the initiator's commitment tx. + uint64 dust_limit_sat = 3; + + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + uint64 max_pending_amt_msat = 4; + + // The smallest HTLC in millisatoshis that the initiator will accept. + uint64 min_htlc_msat = 5; + + // The total number of incoming HTLC's that the initiator will accept. + uint32 max_accepted_htlcs = 6; +} + +message Channel { + // Whether this channel is active or not + bool active = 1; + + // The identity pubkey of the remote node + string remote_pubkey = 2; + + /* + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + */ + string channel_point = 3; + + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 4 [jstype = JS_STRING]; + + // The total amount of funds held in this channel + int64 capacity = 5; + + // This node's current balance in this channel + int64 local_balance = 6; + + // The counterparty's current balance in this channel + int64 remote_balance = 7; + + /* + The amount calculated to be paid in fees for the current set of commitment + transactions. The fee amount is persisted with the channel in order to + allow the fee amount to be removed and recalculated with each channel state + update, including updates that happen after a system restart. + */ + int64 commit_fee = 8; + + // The weight of the commitment transaction + int64 commit_weight = 9; + + /* + The required number of satoshis per kilo-weight that the requester will pay + at all times, for both the funding transaction and commitment transaction. + This value can later be updated once the channel is open. + */ + int64 fee_per_kw = 10; + + // The unsettled balance in this channel + int64 unsettled_balance = 11; + + /* + The total number of satoshis we've sent within this channel. + */ + int64 total_satoshis_sent = 12; + + /* + The total number of satoshis we've received within this channel. + */ + int64 total_satoshis_received = 13; + + /* + The total number of updates conducted within this channel. + */ + uint64 num_updates = 14; + + /* + The list of active, uncleared HTLCs currently pending within the channel. + */ + repeated HTLC pending_htlcs = 15; + + /* + Deprecated. The CSV delay expressed in relative blocks. If the channel is + force closed, we will need to wait for this many blocks before we can regain + our funds. + */ + uint32 csv_delay = 16 [deprecated = true]; + + // Whether this channel is advertised to the network or not. + bool private = 17; + + // True if we were the ones that created the channel. + bool initiator = 18; + + // A set of flags showing the current state of the channel. + string chan_status_flags = 19; + + // Deprecated. The minimum satoshis this node is required to reserve in its + // balance. + int64 local_chan_reserve_sat = 20 [deprecated = true]; + + /* + Deprecated. The minimum satoshis the other node is required to reserve in + its balance. + */ + int64 remote_chan_reserve_sat = 21 [deprecated = true]; + + // Deprecated. Use commitment_type. + bool static_remote_key = 22 [deprecated = true]; + + // The commitment type used by this channel. + CommitmentType commitment_type = 26; + + /* + The number of seconds that the channel has been monitored by the channel + scoring system. Scores are currently not persisted, so this value may be + less than the lifetime of the channel [EXPERIMENTAL]. + */ + int64 lifetime = 23; + + /* + The number of seconds that the remote peer has been observed as being online + by the channel scoring system over the lifetime of the channel + [EXPERIMENTAL]. + */ + int64 uptime = 24; + + /* + Close address is the address that we will enforce payout to on cooperative + close if the channel was opened utilizing option upfront shutdown. This + value can be set on channel open by setting close_address in an open channel + request. If this value is not set, you can still choose a payout address by + cooperatively closing with the delivery_address field set. + */ + string close_address = 25; + + /* + The amount that the initiator of the channel optionally pushed to the remote + party on channel open. This amount will be zero if the channel initiator did + not push any funds to the remote peer. If the initiator field is true, we + pushed this amount to our peer, if it is false, the remote peer pushed this + amount to us. + */ + uint64 push_amount_sat = 27; + + /* + This uint32 indicates if this channel is to be considered 'frozen'. A + frozen channel doest not allow a cooperative channel close by the + initiator. The thaw_height is the height that this restriction stops + applying to the channel. This field is optional, not setting it or using a + value of zero will mean the channel has no additional restrictions. The + height can be interpreted in two ways: as a relative height if the value is + less than 500,000, or as an absolute height otherwise. + */ + uint32 thaw_height = 28; + + // List constraints for the local node. + ChannelConstraints local_constraints = 29; + + // List constraints for the remote node. + ChannelConstraints remote_constraints = 30; +} + +message ListChannelsRequest { + bool active_only = 1; + bool inactive_only = 2; + bool public_only = 3; + bool private_only = 4; + + /* + Filters the response for channels with a target peer's pubkey. If peer is + empty, all channels will be returned. + */ + bytes peer = 5; +} +message ListChannelsResponse { + // The list of active channels + repeated Channel channels = 11; +} + +enum Initiator { + INITIATOR_UNKNOWN = 0; + INITIATOR_LOCAL = 1; + INITIATOR_REMOTE = 2; + INITIATOR_BOTH = 3; +} + +message ChannelCloseSummary { + // The outpoint (txid:index) of the funding transaction. + string channel_point = 1; + + // The unique channel ID for the channel. + uint64 chan_id = 2 [jstype = JS_STRING]; + + // The hash of the genesis block that this channel resides within. + string chain_hash = 3; + + // The txid of the transaction which ultimately closed this channel. + string closing_tx_hash = 4; + + // Public key of the remote peer that we formerly had a channel with. + string remote_pubkey = 5; + + // Total capacity of the channel. + int64 capacity = 6; + + // Height at which the funding transaction was spent. + uint32 close_height = 7; + + // Settled balance at the time of channel closure + int64 settled_balance = 8; + + // The sum of all the time-locked outputs at the time of channel closure + int64 time_locked_balance = 9; + + enum ClosureType { + COOPERATIVE_CLOSE = 0; + LOCAL_FORCE_CLOSE = 1; + REMOTE_FORCE_CLOSE = 2; + BREACH_CLOSE = 3; + FUNDING_CANCELED = 4; + ABANDONED = 5; + } + + // Details on how the channel was closed. + ClosureType close_type = 10; + + /* + Open initiator is the party that initiated opening the channel. Note that + this value may be unknown if the channel was closed before we migrated to + store open channel information after close. + */ + Initiator open_initiator = 11; + + /* + Close initiator indicates which party initiated the close. This value will + be unknown for channels that were cooperatively closed before we started + tracking cooperative close initiators. Note that this indicates which party + initiated a close, and it is possible for both to initiate cooperative or + force closes, although only one party's close will be confirmed on chain. + */ + Initiator close_initiator = 12; + + repeated Resolution resolutions = 13; +} + +enum ResolutionType { + TYPE_UNKNOWN = 0; + + // We resolved an anchor output. + ANCHOR = 1; + + /* + We are resolving an incoming htlc on chain. This if this htlc is + claimed, we swept the incoming htlc with the preimage. If it is timed + out, our peer swept the timeout path. + */ + INCOMING_HTLC = 2; + + /* + We are resolving an outgoing htlc on chain. If this htlc is claimed, + the remote party swept the htlc with the preimage. If it is timed out, + we swept it with the timeout path. + */ + OUTGOING_HTLC = 3; + + // We force closed and need to sweep our time locked commitment output. + COMMIT = 4; +} + +enum ResolutionOutcome { + // Outcome unknown. + OUTCOME_UNKNOWN = 0; + + // An output was claimed on chain. + CLAIMED = 1; + + // An output was left unclaimed on chain. + UNCLAIMED = 2; + + /* + ResolverOutcomeAbandoned indicates that an output that we did not + claim on chain, for example an anchor that we did not sweep and a + third party claimed on chain, or a htlc that we could not decode + so left unclaimed. + */ + ABANDONED = 3; + + /* + If we force closed our channel, our htlcs need to be claimed in two + stages. This outcome represents the broadcast of a timeout or success + transaction for this two stage htlc claim. + */ + FIRST_STAGE = 4; + + // A htlc was timed out on chain. + TIMEOUT = 5; +} + +message Resolution { + // The type of output we are resolving. + ResolutionType resolution_type = 1; + + // The outcome of our on chain action that resolved the outpoint. + ResolutionOutcome outcome = 2; + + // The outpoint that was spent by the resolution. + OutPoint outpoint = 3; + + // The amount that was claimed by the resolution. + uint64 amount_sat = 4; + + // The hex-encoded transaction ID of the sweep transaction that spent the + // output. + string sweep_txid = 5; +} + +message ClosedChannelsRequest { + bool cooperative = 1; + bool local_force = 2; + bool remote_force = 3; + bool breach = 4; + bool funding_canceled = 5; + bool abandoned = 6; +} + +message ClosedChannelsResponse { + repeated ChannelCloseSummary channels = 1; +} + +message Peer { + // The identity pubkey of the peer + string pub_key = 1; + + // Network address of the peer; eg `127.0.0.1:10011` + string address = 3; + + // Bytes of data transmitted to this peer + uint64 bytes_sent = 4; + + // Bytes of data transmitted from this peer + uint64 bytes_recv = 5; + + // Satoshis sent to this peer + int64 sat_sent = 6; + + // Satoshis received from this peer + int64 sat_recv = 7; + + // A channel is inbound if the counterparty initiated the channel + bool inbound = 8; + + // Ping time to this peer + int64 ping_time = 9; + + enum SyncType { + /* + Denotes that we cannot determine the peer's current sync type. + */ + UNKNOWN_SYNC = 0; + + /* + Denotes that we are actively receiving new graph updates from the peer. + */ + ACTIVE_SYNC = 1; + + /* + Denotes that we are not receiving new graph updates from the peer. + */ + PASSIVE_SYNC = 2; + } + + // The type of sync we are currently performing with this peer. + SyncType sync_type = 10; + + // Features advertised by the remote peer in their init message. + map features = 11; + + /* + The latest errors received from our peer with timestamps, limited to the 10 + most recent errors. These errors are tracked across peer connections, but + are not persisted across lnd restarts. Note that these errors are only + stored for peers that we have channels open with, to prevent peers from + spamming us with errors at no cost. + */ + repeated TimestampedError errors = 12; + + /* + The number of times we have recorded this peer going offline or coming + online, recorded across restarts. Note that this value is decreased over + time if the peer has not recently flapped, so that we can forgive peers + with historically high flap counts. + */ + int32 flap_count = 13; + + /* + The timestamp of the last flap we observed for this peer. If this value is + zero, we have not observed any flaps for this peer. + */ + int64 last_flap_ns = 14; +} + +message TimestampedError { + // The unix timestamp in seconds when the error occurred. + uint64 timestamp = 1; + + // The string representation of the error sent by our peer. + string error = 2; +} + +message ListPeersRequest { + /* + If true, only the last error that our peer sent us will be returned with + the peer's information, rather than the full set of historic errors we have + stored. + */ + bool latest_error = 1; +} +message ListPeersResponse { + // The list of currently connected peers + repeated Peer peers = 1; +} + +message PeerEventSubscription { +} + +message PeerEvent { + // The identity pubkey of the peer. + string pub_key = 1; + + enum EventType { + PEER_ONLINE = 0; + PEER_OFFLINE = 1; + } + + EventType type = 2; +} + +message GetInfoRequest { +} +message GetInfoResponse { + // The version of the LND software that the node is running. + string version = 14; + + // The SHA1 commit hash that the daemon is compiled with. + string commit_hash = 20; + + // The identity pubkey of the current node. + string identity_pubkey = 1; + + // If applicable, the alias of the current node, e.g. "bob" + string alias = 2; + + // The color of the current node in hex code format + string color = 17; + + // Number of pending channels + uint32 num_pending_channels = 3; + + // Number of active channels + uint32 num_active_channels = 4; + + // Number of inactive channels + uint32 num_inactive_channels = 15; + + // Number of peers + uint32 num_peers = 5; + + // The node's current view of the height of the best block + uint32 block_height = 6; + + // The node's current view of the hash of the best block + string block_hash = 8; + + // Timestamp of the block best known to the wallet + int64 best_header_timestamp = 13; + + // Whether the wallet's view is synced to the main chain + bool synced_to_chain = 9; + + // Whether we consider ourselves synced with the public channel graph. + bool synced_to_graph = 18; + + /* + Whether the current node is connected to testnet. This field is + deprecated and the network field should be used instead + **/ + bool testnet = 10 [deprecated = true]; + + reserved 11; + + // A list of active chains the node is connected to + repeated Chain chains = 16; + + // The URIs of the current node. + repeated string uris = 12; + + /* + Features that our node has advertised in our init message, node + announcements and invoices. + */ + map features = 19; +} + +message GetRecoveryInfoRequest { +} +message GetRecoveryInfoResponse { + // Whether the wallet is in recovery mode + bool recovery_mode = 1; + + // Whether the wallet recovery progress is finished + bool recovery_finished = 2; + + // The recovery progress, ranging from 0 to 1. + double progress = 3; +} + +message Chain { + // The blockchain the node is on (eg bitcoin, litecoin) + string chain = 1; + + // The network the node is on (eg regtest, testnet, mainnet) + string network = 2; +} + +message ConfirmationUpdate { + bytes block_sha = 1; + int32 block_height = 2; + + uint32 num_confs_left = 3; +} + +message ChannelOpenUpdate { + ChannelPoint channel_point = 1; +} + +message ChannelCloseUpdate { + bytes closing_txid = 1; + + bool success = 2; +} + +message CloseChannelRequest { + /* + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + */ + ChannelPoint channel_point = 1; + + // If true, then the channel will be closed forcibly. This means the + // current commitment transaction will be signed and broadcast. + bool force = 2; + + // The target number of blocks that the closure transaction should be + // confirmed by. + int32 target_conf = 3; + + // A manual fee rate set in sat/byte that should be used when crafting the + // closure transaction. + int64 sat_per_byte = 4; + + /* + An optional address to send funds to in the case of a cooperative close. + If the channel was opened with an upfront shutdown script and this field + is set, the request to close will fail because the channel must pay out + to the upfront shutdown addresss. + */ + string delivery_address = 5; +} + +message CloseStatusUpdate { + oneof update { + PendingUpdate close_pending = 1; + ChannelCloseUpdate chan_close = 3; + } +} + +message PendingUpdate { + bytes txid = 1; + uint32 output_index = 2; +} + +message ReadyForPsbtFunding { + /* + The P2WSH address of the channel funding multisig address that the below + specified amount in satoshis needs to be sent to. + */ + string funding_address = 1; + + /* + The exact amount in satoshis that needs to be sent to the above address to + fund the pending channel. + */ + int64 funding_amount = 2; + + /* + A raw PSBT that contains the pending channel output. If a base PSBT was + provided in the PsbtShim, this is the base PSBT with one additional output. + If no base PSBT was specified, this is an otherwise empty PSBT with exactly + one output. + */ + bytes psbt = 3; +} + +message OpenChannelRequest { + /* + The pubkey of the node to open a channel with. When using REST, this field + must be encoded as base64. + */ + bytes node_pubkey = 2; + + /* + The hex encoded pubkey of the node to open a channel with. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string node_pubkey_string = 3 [deprecated = true]; + + // The number of satoshis the wallet should commit to the channel + int64 local_funding_amount = 4; + + // The number of satoshis to push to the remote side as part of the initial + // commitment state + int64 push_sat = 5; + + // The target number of blocks that the funding transaction should be + // confirmed by. + int32 target_conf = 6; + + // A manual fee rate set in sat/byte that should be used when crafting the + // funding transaction. + int64 sat_per_byte = 7; + + // Whether this channel should be private, not announced to the greater + // network. + bool private = 8; + + // The minimum value in millisatoshi we will require for incoming HTLCs on + // the channel. + int64 min_htlc_msat = 9; + + // The delay we require on the remote's commitment transaction. If this is + // not set, it will be scaled automatically with the channel size. + uint32 remote_csv_delay = 10; + + // The minimum number of confirmations each one of your outputs used for + // the funding transaction must satisfy. + int32 min_confs = 11; + + // Whether unconfirmed outputs should be used as inputs for the funding + // transaction. + bool spend_unconfirmed = 12; + + /* + Close address is an optional address which specifies the address to which + funds should be paid out to upon cooperative close. This field may only be + set if the peer supports the option upfront feature bit (call listpeers + to check). The remote peer will only accept cooperative closes to this + address if it is set. + + Note: If this value is set on channel creation, you will *not* be able to + cooperatively close out to a different address. + */ + string close_address = 13; + + /* + Funding shims are an optional argument that allow the caller to intercept + certain funding functionality. For example, a shim can be provided to use a + particular key for the commitment key (ideally cold) rather than use one + that is generated by the wallet as normal, or signal that signing will be + carried out in an interactive manner (PSBT based). + */ + FundingShim funding_shim = 14; + + /* + The maximum amount of coins in millisatoshi that can be pending within + the channel. It only applies to the remote party. + */ + uint64 remote_max_value_in_flight_msat = 15; + + /* + The maximum number of concurrent HTLCs we will allow the remote party to add + to the commitment transaction. + */ + uint32 remote_max_htlcs = 16; +} +message OpenStatusUpdate { + oneof update { + /* + Signals that the channel is now fully negotiated and the funding + transaction published. + */ + PendingUpdate chan_pending = 1; + + /* + Signals that the channel's funding transaction has now reached the + required number of confirmations on chain and can be used. + */ + ChannelOpenUpdate chan_open = 3; + + /* + Signals that the funding process has been suspended and the construction + of a PSBT that funds the channel PK script is now required. + */ + ReadyForPsbtFunding psbt_fund = 5; + } + + /* + The pending channel ID of the created channel. This value may be used to + further the funding flow manually via the FundingStateStep method. + */ + bytes pending_chan_id = 4; +} + +message KeyLocator { + // The family of key being identified. + int32 key_family = 1; + + // The precise index of the key being identified. + int32 key_index = 2; +} + +message KeyDescriptor { + /* + The raw bytes of the key being identified. + */ + bytes raw_key_bytes = 1; + + /* + The key locator that identifies which key to use for signing. + */ + KeyLocator key_loc = 2; +} + +message ChanPointShim { + /* + The size of the pre-crafted output to be used as the channel point for this + channel funding. + */ + int64 amt = 1; + + // The target channel point to refrence in created commitment transactions. + ChannelPoint chan_point = 2; + + // Our local key to use when creating the multi-sig output. + KeyDescriptor local_key = 3; + + // The key of the remote party to use when creating the multi-sig output. + bytes remote_key = 4; + + /* + If non-zero, then this will be used as the pending channel ID on the wire + protocol to initate the funding request. This is an optional field, and + should only be set if the responder is already expecting a specific pending + channel ID. + */ + bytes pending_chan_id = 5; + + /* + This uint32 indicates if this channel is to be considered 'frozen'. A frozen + channel does not allow a cooperative channel close by the initiator. The + thaw_height is the height that this restriction stops applying to the + channel. The height can be interpreted in two ways: as a relative height if + the value is less than 500,000, or as an absolute height otherwise. + */ + uint32 thaw_height = 6; +} + +message PsbtShim { + /* + A unique identifier of 32 random bytes that will be used as the pending + channel ID to identify the PSBT state machine when interacting with it and + on the wire protocol to initiate the funding request. + */ + bytes pending_chan_id = 1; + + /* + An optional base PSBT the new channel output will be added to. If this is + non-empty, it must be a binary serialized PSBT. + */ + bytes base_psbt = 2; + + /* + If a channel should be part of a batch (multiple channel openings in one + transaction), it can be dangerous if the whole batch transaction is + published too early before all channel opening negotiations are completed. + This flag prevents this particular channel from broadcasting the transaction + after the negotiation with the remote peer. In a batch of channel openings + this flag should be set to true for every channel but the very last. + */ + bool no_publish = 3; +} + +message FundingShim { + oneof shim { + /* + A channel shim where the channel point was fully constructed outside + of lnd's wallet and the transaction might already be published. + */ + ChanPointShim chan_point_shim = 1; + + /* + A channel shim that uses a PSBT to fund and sign the channel funding + transaction. + */ + PsbtShim psbt_shim = 2; + } +} + +message FundingShimCancel { + // The pending channel ID of the channel to cancel the funding shim for. + bytes pending_chan_id = 1; +} + +message FundingPsbtVerify { + /* + The funded but not yet signed PSBT that sends the exact channel capacity + amount to the PK script returned in the open channel message in a previous + step. + */ + bytes funded_psbt = 1; + + // The pending channel ID of the channel to get the PSBT for. + bytes pending_chan_id = 2; +} + +message FundingPsbtFinalize { + /* + The funded PSBT that contains all witness data to send the exact channel + capacity amount to the PK script returned in the open channel message in a + previous step. Cannot be set at the same time as final_raw_tx. + */ + bytes signed_psbt = 1; + + // The pending channel ID of the channel to get the PSBT for. + bytes pending_chan_id = 2; + + /* + As an alternative to the signed PSBT with all witness data, the final raw + wire format transaction can also be specified directly. Cannot be set at the + same time as signed_psbt. + */ + bytes final_raw_tx = 3; +} + +message FundingTransitionMsg { + oneof trigger { + /* + The funding shim to register. This should be used before any + channel funding has began by the remote party, as it is intended as a + preparatory step for the full channel funding. + */ + FundingShim shim_register = 1; + + // Used to cancel an existing registered funding shim. + FundingShimCancel shim_cancel = 2; + + /* + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step verifies that the PSBT contains the correct + outputs to fund the channel. + */ + FundingPsbtVerify psbt_verify = 3; + + /* + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step finalizes the funded and signed PSBT, finishes + negotiation with the peer and finally publishes the resulting funding + transaction. + */ + FundingPsbtFinalize psbt_finalize = 4; + } +} + +message FundingStateStepResp { +} + +message PendingHTLC { + // The direction within the channel that the htlc was sent + bool incoming = 1; + + // The total value of the htlc + int64 amount = 2; + + // The final output to be swept back to the user's wallet + string outpoint = 3; + + // The next block height at which we can spend the current stage + uint32 maturity_height = 4; + + /* + The number of blocks remaining until the current stage can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + */ + int32 blocks_til_maturity = 5; + + // Indicates whether the htlc is in its first or second stage of recovery + uint32 stage = 6; +} + +message PendingChannelsRequest { +} +message PendingChannelsResponse { + message PendingChannel { + string remote_node_pub = 1; + string channel_point = 2; + + int64 capacity = 3; + + int64 local_balance = 4; + int64 remote_balance = 5; + + // The minimum satoshis this node is required to reserve in its + // balance. + int64 local_chan_reserve_sat = 6; + + /* + The minimum satoshis the other node is required to reserve in its + balance. + */ + int64 remote_chan_reserve_sat = 7; + + // The party that initiated opening the channel. + Initiator initiator = 8; + + // The commitment type used by this channel. + CommitmentType commitment_type = 9; + } + + message PendingOpenChannel { + // The pending channel + PendingChannel channel = 1; + + // The height at which this channel will be confirmed + uint32 confirmation_height = 2; + + /* + The amount calculated to be paid in fees for the current set of + commitment transactions. The fee amount is persisted with the channel + in order to allow the fee amount to be removed and recalculated with + each channel state update, including updates that happen after a system + restart. + */ + int64 commit_fee = 4; + + // The weight of the commitment transaction + int64 commit_weight = 5; + + /* + The required number of satoshis per kilo-weight that the requester will + pay at all times, for both the funding transaction and commitment + transaction. This value can later be updated once the channel is open. + */ + int64 fee_per_kw = 6; + } + + message WaitingCloseChannel { + // The pending channel waiting for closing tx to confirm + PendingChannel channel = 1; + + // The balance in satoshis encumbered in this channel + int64 limbo_balance = 2; + + /* + A list of valid commitment transactions. Any of these can confirm at + this point. + */ + Commitments commitments = 3; + } + + message Commitments { + // Hash of the local version of the commitment tx. + string local_txid = 1; + + // Hash of the remote version of the commitment tx. + string remote_txid = 2; + + // Hash of the remote pending version of the commitment tx. + string remote_pending_txid = 3; + + /* + The amount in satoshis calculated to be paid in fees for the local + commitment. + */ + uint64 local_commit_fee_sat = 4; + + /* + The amount in satoshis calculated to be paid in fees for the remote + commitment. + */ + uint64 remote_commit_fee_sat = 5; + + /* + The amount in satoshis calculated to be paid in fees for the remote + pending commitment. + */ + uint64 remote_pending_commit_fee_sat = 6; + } + + message ClosedChannel { + // The pending channel to be closed + PendingChannel channel = 1; + + // The transaction id of the closing transaction + string closing_txid = 2; + } + + message ForceClosedChannel { + // The pending channel to be force closed + PendingChannel channel = 1; + + // The transaction id of the closing transaction + string closing_txid = 2; + + // The balance in satoshis encumbered in this pending channel + int64 limbo_balance = 3; + + // The height at which funds can be swept into the wallet + uint32 maturity_height = 4; + + /* + Remaining # of blocks until the commitment output can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + */ + int32 blocks_til_maturity = 5; + + // The total value of funds successfully recovered from this channel + int64 recovered_balance = 6; + + repeated PendingHTLC pending_htlcs = 8; + + enum AnchorState { + LIMBO = 0; + RECOVERED = 1; + LOST = 2; + } + + AnchorState anchor = 9; + } + + // The balance in satoshis encumbered in pending channels + int64 total_limbo_balance = 1; + + // Channels pending opening + repeated PendingOpenChannel pending_open_channels = 2; + + /* + Deprecated: Channels pending closing previously contained cooperatively + closed channels with a single confirmation. These channels are now + considered closed from the time we see them on chain. + */ + repeated ClosedChannel pending_closing_channels = 3 [deprecated = true]; + + // Channels pending force closing + repeated ForceClosedChannel pending_force_closing_channels = 4; + + // Channels waiting for closing tx to confirm + repeated WaitingCloseChannel waiting_close_channels = 5; +} + +message ChannelEventSubscription { +} + +message ChannelEventUpdate { + oneof channel { + Channel open_channel = 1; + ChannelCloseSummary closed_channel = 2; + ChannelPoint active_channel = 3; + ChannelPoint inactive_channel = 4; + PendingUpdate pending_open_channel = 6; + } + + enum UpdateType { + OPEN_CHANNEL = 0; + CLOSED_CHANNEL = 1; + ACTIVE_CHANNEL = 2; + INACTIVE_CHANNEL = 3; + PENDING_OPEN_CHANNEL = 4; + } + + UpdateType type = 5; +} + +message WalletBalanceRequest { +} +message WalletBalanceResponse { + // The balance of the wallet + int64 total_balance = 1; + + // The confirmed balance of a wallet(with >= 1 confirmations) + int64 confirmed_balance = 2; + + // The unconfirmed balance of a wallet(with 0 confirmations) + int64 unconfirmed_balance = 3; +} + +message ChannelBalanceRequest { +} +message ChannelBalanceResponse { + // Sum of channels balances denominated in satoshis + int64 balance = 1; + + // Sum of channels pending balances denominated in satoshis + int64 pending_open_balance = 2; +} + +message QueryRoutesRequest { + // The 33-byte hex-encoded public key for the payment destination + string pub_key = 1; + + /* + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt = 2; + + /* + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt_msat = 12; + + reserved 3; + + /* + An optional CLTV delta from the current height that should be used for the + timelock of the final hop. Note that unlike SendPayment, QueryRoutes does + not add any additional block padding on top of final_ctlv_delta. This + padding of a few blocks needs to be added manually or otherwise failures may + happen when a block comes in while the payment is in flight. + */ + int32 final_cltv_delta = 4; + + /* + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. + */ + FeeLimit fee_limit = 5; + + /* + A list of nodes to ignore during path finding. When using REST, these fields + must be encoded as base64. + */ + repeated bytes ignored_nodes = 6; + + /* + Deprecated. A list of edges to ignore during path finding. + */ + repeated EdgeLocator ignored_edges = 7 [deprecated = true]; + + /* + The source node where the request route should originated from. If empty, + self is assumed. + */ + string source_pub_key = 8; + + /* + If set to true, edge probabilities from mission control will be used to get + the optimal route. + */ + bool use_mission_control = 9; + + /* + A list of directed node pairs that will be ignored during path finding. + */ + repeated NodePair ignored_pairs = 10; + + /* + An optional maximum total time lock for the route. If the source is empty or + ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If + zero, then the value of `--max-cltv-expiry` is used as the limit. + */ + uint32 cltv_limit = 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. If the destination + does not support the specified recrods, and error will be returned. + Record types are required to be in the custom range >= 65536. When using + REST, the values must be encoded as base64. + */ + map dest_custom_records = 13; + + /* + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + */ + uint64 outgoing_chan_id = 14 [jstype = JS_STRING]; + + /* + The pubkey of the last hop of the route. If empty, any hop may be used. + */ + bytes last_hop_pubkey = 15; + + /* + Optional route hints to reach the destination through private channels. + */ + repeated lnrpc.RouteHint route_hints = 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. + */ + repeated lnrpc.FeatureBit dest_features = 17; +} + +message NodePair { + /* + The sending node of the pair. When using REST, this field must be encoded as + base64. + */ + bytes from = 1; + + /* + The receiving node of the pair. When using REST, this field must be encoded + as base64. + */ + bytes to = 2; +} + +message EdgeLocator { + // The short channel id of this edge. + uint64 channel_id = 1 [jstype = JS_STRING]; + + /* + The direction of this edge. If direction_reverse is false, the direction + of this edge is from the channel endpoint with the lexicographically smaller + pub key to the endpoint with the larger pub key. If direction_reverse is + is true, the edge goes the other way. + */ + bool direction_reverse = 2; +} + +message QueryRoutesResponse { + /* + The route that results from the path finding operation. This is still a + repeated field to retain backwards compatibility. + */ + repeated Route routes = 1; + + /* + The success probability of the returned route based on the current mission + control state. [EXPERIMENTAL] + */ + double success_prob = 2; +} + +message Hop { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + int64 chan_capacity = 2; + int64 amt_to_forward = 3 [deprecated = true]; + int64 fee = 4 [deprecated = true]; + uint32 expiry = 5; + int64 amt_to_forward_msat = 6; + int64 fee_msat = 7; + + /* + An optional public key of the hop. If the public key is given, the payment + can be executed without relying on a copy of the channel graph. + */ + string pub_key = 8; + + /* + If set to true, then this hop will be encoded using the new variable length + TLV format. Note that if any custom tlv_records below are specified, then + this field MUST be set to true for them to be encoded properly. + */ + bool tlv_payload = 9; + + /* + An optional TLV record that signals the use of an MPP payment. If present, + the receiver will enforce that that the same mpp_record is included in the + final hop payload of all non-zero payments in the HTLC set. If empty, a + regular single-shot payment is or was attempted. + */ + MPPRecord mpp_record = 10; + + /* + An optional set of key-value TLV records. This is useful within the context + of the SendToRoute call as it allows callers to specify arbitrary K-V pairs + to drop off at each hop within the onion. + */ + map custom_records = 11; +} + +message MPPRecord { + /* + A unique, random identifier used to authenticate the sender as the intended + payer of a multi-path payment. The payment_addr must be the same for all + subpayments, and match the payment_addr provided in the receiver's invoice. + The same payment_addr must be used on all subpayments. + */ + bytes payment_addr = 11; + + /* + The total amount in milli-satoshis being sent as part of a larger multi-path + payment. The caller is responsible for ensuring subpayments to the same node + and payment_hash sum exactly to total_amt_msat. The same + total_amt_msat must be used on all subpayments. + */ + int64 total_amt_msat = 10; +} + +/* +A path through the channel graph which runs over one or more channels in +succession. This struct carries all the information required to craft the +Sphinx onion packet, and send the payment along the first hop in the path. A +route is only selected as valid if all the channels have sufficient capacity to +carry the initial payment amount after fees are accounted for. +*/ +message Route { + /* + The cumulative (final) time lock across the entire route. This is the CLTV + value that should be extended to the first hop in the route. All other hops + will decrement the time-lock as advertised, leaving enough time for all + hops to wait for or present the payment preimage to complete the payment. + */ + uint32 total_time_lock = 1; + + /* + The sum of the fees paid at each hop within the final route. In the case + of a one-hop payment, this value will be zero as we don't need to pay a fee + to ourselves. + */ + int64 total_fees = 2 [deprecated = true]; + + /* + The total amount of funds required to complete a payment over this route. + This value includes the cumulative fees at each hop. As a result, the HTLC + extended to the first-hop in the route will need to have at least this many + satoshis, otherwise the route will fail at an intermediate node due to an + insufficient amount of fees. + */ + int64 total_amt = 3 [deprecated = true]; + + /* + Contains details concerning the specific forwarding details at each hop. + */ + repeated Hop hops = 4; + + /* + The total fees in millisatoshis. + */ + int64 total_fees_msat = 5; + + /* + The total amount in millisatoshis. + */ + int64 total_amt_msat = 6; +} + +message NodeInfoRequest { + // The 33-byte hex-encoded compressed public of the target node + string pub_key = 1; + + // If true, will include all known channels associated with the node. + bool include_channels = 2; +} + +message NodeInfo { + /* + An individual vertex/node within the channel graph. A node is + connected to other nodes by one or more channel edges emanating from it. As + the graph is directed, a node will also have an incoming edge attached to + it for each outgoing edge. + */ + LightningNode node = 1; + + // The total number of channels for the node. + uint32 num_channels = 2; + + // The sum of all channels capacity for the node, denominated in satoshis. + int64 total_capacity = 3; + + // A list of all public channels for the node. + repeated ChannelEdge channels = 4; +} + +/* +An individual vertex/node within the channel graph. A node is +connected to other nodes by one or more channel edges emanating from it. As the +graph is directed, a node will also have an incoming edge attached to it for +each outgoing edge. +*/ +message LightningNode { + uint32 last_update = 1; + string pub_key = 2; + string alias = 3; + repeated NodeAddress addresses = 4; + string color = 5; + map features = 6; +} + +message NodeAddress { + string network = 1; + string addr = 2; +} + +message RoutingPolicy { + uint32 time_lock_delta = 1; + int64 min_htlc = 2; + int64 fee_base_msat = 3; + int64 fee_rate_milli_msat = 4; + bool disabled = 5; + uint64 max_htlc_msat = 6; + uint32 last_update = 7; +} + +/* +A fully authenticated channel along with all its unique attributes. +Once an authenticated channel announcement has been processed on the network, +then an instance of ChannelEdgeInfo encapsulating the channels attributes is +stored. The other portions relevant to routing policy of a channel are stored +within a ChannelEdgePolicy for each direction of the channel. +*/ +message ChannelEdge { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 channel_id = 1 [jstype = JS_STRING]; + string chan_point = 2; + + uint32 last_update = 3 [deprecated = true]; + + string node1_pub = 4; + string node2_pub = 5; + + int64 capacity = 6; + + RoutingPolicy node1_policy = 7; + RoutingPolicy node2_policy = 8; +} + +message ChannelGraphRequest { + /* + Whether unannounced channels are included in the response or not. If set, + unannounced channels are included. Unannounced channels are both private + channels, and public channels that are not yet announced to the network. + */ + bool include_unannounced = 1; +} + +// Returns a new instance of the directed channel graph. +message ChannelGraph { + // The list of `LightningNode`s in this channel graph + repeated LightningNode nodes = 1; + + // The list of `ChannelEdge`s in this channel graph + repeated ChannelEdge edges = 2; +} + +enum NodeMetricType { + UNKNOWN = 0; + BETWEENNESS_CENTRALITY = 1; +} + +message NodeMetricsRequest { + // The requested node metrics. + repeated NodeMetricType types = 1; +} + +message NodeMetricsResponse { + /* + Betweenness centrality is the sum of the ratio of shortest paths that pass + through the node for each pair of nodes in the graph (not counting paths + starting or ending at this node). + Map of node pubkey to betweenness centrality of the node. Normalized + values are in the [0,1] closed interval. + */ + map betweenness_centrality = 1; +} + +message FloatMetric { + // Arbitrary float value. + double value = 1; + + // The value normalized to [0,1] or [-1,1]. + double normalized_value = 2; +} + +message ChanInfoRequest { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; +} + +message NetworkInfoRequest { +} +message NetworkInfo { + uint32 graph_diameter = 1; + double avg_out_degree = 2; + uint32 max_out_degree = 3; + + uint32 num_nodes = 4; + uint32 num_channels = 5; + + int64 total_network_capacity = 6; + + double avg_channel_size = 7; + int64 min_channel_size = 8; + int64 max_channel_size = 9; + int64 median_channel_size_sat = 10; + + // The number of edges marked as zombies. + uint64 num_zombie_chans = 11; + + // TODO(roasbeef): fee rate info, expiry + // * also additional RPC for tracking fee info once in +} + +message StopRequest { +} +message StopResponse { +} + +message GraphTopologySubscription { +} +message GraphTopologyUpdate { + repeated NodeUpdate node_updates = 1; + repeated ChannelEdgeUpdate channel_updates = 2; + repeated ClosedChannelUpdate closed_chans = 3; +} +message NodeUpdate { + repeated string addresses = 1; + string identity_key = 2; + bytes global_features = 3; + string alias = 4; + string color = 5; +} +message ChannelEdgeUpdate { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + + ChannelPoint chan_point = 2; + + int64 capacity = 3; + + RoutingPolicy routing_policy = 4; + + string advertising_node = 5; + string connecting_node = 6; +} +message ClosedChannelUpdate { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + int64 capacity = 2; + uint32 closed_height = 3; + ChannelPoint chan_point = 4; +} + +message HopHint { + // The public key of the node at the start of the channel. + string node_id = 1; + + // The unique identifier of the channel. + uint64 chan_id = 2 [jstype = JS_STRING]; + + // The base fee of the channel denominated in millisatoshis. + uint32 fee_base_msat = 3; + + /* + The fee rate of the channel for sending one satoshi across it denominated in + millionths of a satoshi. + */ + uint32 fee_proportional_millionths = 4; + + // The time-lock delta of the channel. + uint32 cltv_expiry_delta = 5; +} + +message RouteHint { + /* + A list of hop hints that when chained together can assist in reaching a + specific destination. + */ + repeated HopHint hop_hints = 1; +} + +message Invoice { + /* + An optional memo to attach along with the invoice. Used for record keeping + purposes for the invoice's creator, and will also be set in the description + field of the encoded payment request if the description_hash field is not + being used. + */ + string memo = 1; + + reserved 2; + + /* + The hex-encoded preimage (32 byte) which will allow settling an incoming + HTLC payable to this preimage. When using REST, this field must be encoded + as base64. + */ + bytes r_preimage = 3; + + /* + The hash of the preimage. When using REST, this field must be encoded as + base64. + */ + bytes r_hash = 4; + + /* + The value of this invoice in satoshis + + The fields value and value_msat are mutually exclusive. + */ + int64 value = 5; + + /* + The value of this invoice in millisatoshis + + The fields value and value_msat are mutually exclusive. + */ + int64 value_msat = 23; + + // Whether this invoice has been fulfilled + bool settled = 6 [deprecated = true]; + + // When this invoice was created + int64 creation_date = 7; + + // When this invoice was settled + int64 settle_date = 8; + + /* + 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. + */ + string payment_request = 9; + + /* + Hash (SHA-256) of a description of the payment. Used if the description of + payment (memo) is too long to naturally fit within the description field + of an encoded payment request. When using REST, this field must be encoded + as base64. + */ + bytes description_hash = 10; + + // Payment request expiry time in seconds. Default is 3600 (1 hour). + int64 expiry = 11; + + // Fallback on-chain address. + string fallback_addr = 12; + + // Delta to use for the time-lock of the CLTV extended to the final hop. + uint64 cltv_expiry = 13; + + /* + Route hints that can each be individually used to assist in reaching the + invoice's destination. + */ + repeated RouteHint route_hints = 14; + + // Whether this invoice should include routing hints for private channels. + bool private = 15; + + /* + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + */ + uint64 add_index = 16; + + /* + The "settle" index of this invoice. Each newly settled invoice will + increment this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all + settled invoices with an settle_index greater than this one. + */ + uint64 settle_index = 17; + + // Deprecated, use amt_paid_sat or amt_paid_msat. + int64 amt_paid = 18 [deprecated = true]; + + /* + The amount that was accepted for this invoice, in satoshis. This will ONLY + be set if this invoice has been settled. We provide this field as if the + invoice was created with a zero value, then we need to record what amount + was ultimately accepted. Additionally, it's possible that the sender paid + MORE that was specified in the original invoice. So we'll record that here + as well. + */ + int64 amt_paid_sat = 19; + + /* + The amount that was accepted for this invoice, in millisatoshis. This will + ONLY be set if this invoice has been settled. We provide this field as if + the invoice was created with a zero value, then we need to record what + amount was ultimately accepted. Additionally, it's possible that the sender + paid MORE that was specified in the original invoice. So we'll record that + here as well. + */ + int64 amt_paid_msat = 20; + + enum InvoiceState { + OPEN = 0; + SETTLED = 1; + CANCELED = 2; + ACCEPTED = 3; + } + + /* + The state the invoice is in. + */ + InvoiceState state = 21; + + // List of HTLCs paying to this invoice [EXPERIMENTAL]. + repeated InvoiceHTLC htlcs = 22; + + // List of features advertised on the invoice. + map features = 24; + + /* + Indicates if this invoice was a spontaneous payment that arrived via keysend + [EXPERIMENTAL]. + */ + bool is_keysend = 25; +} + +enum InvoiceHTLCState { + ACCEPTED = 0; + SETTLED = 1; + CANCELED = 2; +} + +// Details of an HTLC that paid to an invoice +message InvoiceHTLC { + // Short channel id over which the htlc was received. + uint64 chan_id = 1 [jstype = JS_STRING]; + + // Index identifying the htlc on the channel. + uint64 htlc_index = 2; + + // The amount of the htlc in msat. + uint64 amt_msat = 3; + + // Block height at which this htlc was accepted. + int32 accept_height = 4; + + // Time at which this htlc was accepted. + int64 accept_time = 5; + + // Time at which this htlc was settled or canceled. + int64 resolve_time = 6; + + // Block height at which this htlc expires. + int32 expiry_height = 7; + + // Current state the htlc is in. + InvoiceHTLCState state = 8; + + // Custom tlv records. + map custom_records = 9; + + // The total amount of the mpp payment in msat. + uint64 mpp_total_amt_msat = 10; +} + +message AddInvoiceResponse { + bytes r_hash = 1; + + /* + 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. + */ + string payment_request = 2; + + /* + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + */ + uint64 add_index = 16; +} +message PaymentHash { + /* + The hex-encoded payment hash of the invoice to be looked up. The passed + payment hash must be exactly 32 bytes, otherwise an error is returned. + Deprecated now that the REST gateway supports base64 encoding of bytes + fields. + */ + string r_hash_str = 1 [deprecated = true]; + + /* + The payment hash of the invoice to be looked up. When using REST, this field + must be encoded as base64. + */ + bytes r_hash = 2; +} + +message ListInvoiceRequest { + /* + If set, only invoices that are not settled and not canceled will be returned + in the response. + */ + bool pending_only = 1; + + /* + The index of an invoice that will be used as either the start or end of a + query to determine which invoices should be returned in the response. + */ + uint64 index_offset = 4; + + // The max number of invoices to return in the response to this query. + uint64 num_max_invoices = 5; + + /* + If set, the invoices returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. + */ + bool reversed = 6; +} +message ListInvoiceResponse { + /* + A list of invoices from the time slice of the time series specified in the + request. + */ + repeated Invoice invoices = 1; + + /* + The index of the last item in the set of returned invoices. This can be used + to seek further, pagination style. + */ + uint64 last_index_offset = 2; + + /* + The index of the last item in the set of returned invoices. This can be used + to seek backwards, pagination style. + */ + uint64 first_index_offset = 3; +} + +message InvoiceSubscription { + /* + If specified (non-zero), then we'll first start by sending out + notifications for all added indexes with an add_index greater than this + value. This allows callers to catch up on any events they missed while they + weren't connected to the streaming RPC. + */ + uint64 add_index = 1; + + /* + If specified (non-zero), then we'll first start by sending out + notifications for all settled indexes with an settle_index greater than + this value. This allows callers to catch up on any events they missed while + they weren't connected to the streaming RPC. + */ + uint64 settle_index = 2; +} + +enum PaymentFailureReason { + /* + Payment isn't failed (yet). + */ + FAILURE_REASON_NONE = 0; + + /* + There are more routes to try, but the payment timeout was exceeded. + */ + FAILURE_REASON_TIMEOUT = 1; + + /* + All possible routes were tried and failed permanently. Or were no + routes to the destination at all. + */ + FAILURE_REASON_NO_ROUTE = 2; + + /* + A non-recoverable error has occured. + */ + FAILURE_REASON_ERROR = 3; + + /* + Payment details incorrect (unknown hash, invalid amt or + invalid final cltv delta) + */ + FAILURE_REASON_INCORRECT_PAYMENT_DETAILS = 4; + + /* + Insufficient local balance. + */ + FAILURE_REASON_INSUFFICIENT_BALANCE = 5; +} + +message Payment { + // The payment hash + string payment_hash = 1; + + // Deprecated, use value_sat or value_msat. + int64 value = 2 [deprecated = true]; + + // Deprecated, use creation_time_ns + int64 creation_date = 3 [deprecated = true]; + + reserved 4; + + // Deprecated, use fee_sat or fee_msat. + int64 fee = 5 [deprecated = true]; + + // The payment preimage + string payment_preimage = 6; + + // The value of the payment in satoshis + int64 value_sat = 7; + + // The value of the payment in milli-satoshis + int64 value_msat = 8; + + // The optional payment request being fulfilled. + string payment_request = 9; + + enum PaymentStatus { + UNKNOWN = 0; + IN_FLIGHT = 1; + SUCCEEDED = 2; + FAILED = 3; + } + + // The status of the payment. + PaymentStatus status = 10; + + // The fee paid for this payment in satoshis + int64 fee_sat = 11; + + // The fee paid for this payment in milli-satoshis + int64 fee_msat = 12; + + // The time in UNIX nanoseconds at which the payment was created. + int64 creation_time_ns = 13; + + // The HTLCs made in attempt to settle the payment. + repeated HTLCAttempt htlcs = 14; + + /* + The creation index of this payment. Each payment can be uniquely identified + by this index, which may not strictly increment by 1 for payments made in + older versions of lnd. + */ + uint64 payment_index = 15; + + PaymentFailureReason failure_reason = 16; +} + +message HTLCAttempt { + enum HTLCStatus { + IN_FLIGHT = 0; + SUCCEEDED = 1; + FAILED = 2; + } + + // The status of the HTLC. + HTLCStatus status = 1; + + // The route taken by this HTLC. + Route route = 2; + + // The time in UNIX nanoseconds at which this HTLC was sent. + int64 attempt_time_ns = 3; + + /* + The time in UNIX nanoseconds at which this HTLC was settled or failed. + This value will not be set if the HTLC is still IN_FLIGHT. + */ + int64 resolve_time_ns = 4; + + // Detailed htlc failure info. + Failure failure = 5; + + // The preimage that was used to settle the HTLC. + bytes preimage = 6; +} + +message ListPaymentsRequest { + /* + If true, then return payments that have not yet fully completed. This means + that pending payments, as well as failed payments will show up if this + field is set to true. This flag doesn't change the meaning of the indices, + which are tied to individual payments. + */ + bool include_incomplete = 1; + + /* + The index of a payment that will be used as either the start or end of a + query to determine which payments should be returned in the response. The + index_offset is exclusive. In the case of a zero index_offset, the query + will start with the oldest payment when paginating forwards, or will end + with the most recent payment when paginating backwards. + */ + uint64 index_offset = 2; + + // The maximal number of payments returned in the response to this query. + uint64 max_payments = 3; + + /* + If set, the payments returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. The order + of the returned payments is always oldest first (ascending index order). + */ + bool reversed = 4; +} + +message ListPaymentsResponse { + // The list of payments + repeated Payment payments = 1; + + /* + The index of the first item in the set of returned payments. This can be + used as the index_offset to continue seeking backwards in the next request. + */ + uint64 first_index_offset = 2; + + /* + The index of the last item in the set of returned payments. This can be used + as the index_offset to continue seeking forwards in the next request. + */ + uint64 last_index_offset = 3; +} + +message DeleteAllPaymentsRequest { +} + +message DeleteAllPaymentsResponse { +} + +message AbandonChannelRequest { + ChannelPoint channel_point = 1; + + bool pending_funding_shim_only = 2; +} + +message AbandonChannelResponse { +} + +message DebugLevelRequest { + bool show = 1; + string level_spec = 2; +} +message DebugLevelResponse { + string sub_systems = 1; +} + +message PayReqString { + // The payment request string to be decoded + string pay_req = 1; +} +message PayReq { + string destination = 1; + string payment_hash = 2; + int64 num_satoshis = 3; + int64 timestamp = 4; + int64 expiry = 5; + string description = 6; + string description_hash = 7; + string fallback_addr = 8; + int64 cltv_expiry = 9; + repeated RouteHint route_hints = 10; + bytes payment_addr = 11; + int64 num_msat = 12; + map features = 13; +} + +enum FeatureBit { + DATALOSS_PROTECT_REQ = 0; + DATALOSS_PROTECT_OPT = 1; + INITIAL_ROUING_SYNC = 3; + UPFRONT_SHUTDOWN_SCRIPT_REQ = 4; + UPFRONT_SHUTDOWN_SCRIPT_OPT = 5; + GOSSIP_QUERIES_REQ = 6; + GOSSIP_QUERIES_OPT = 7; + TLV_ONION_REQ = 8; + TLV_ONION_OPT = 9; + EXT_GOSSIP_QUERIES_REQ = 10; + EXT_GOSSIP_QUERIES_OPT = 11; + STATIC_REMOTE_KEY_REQ = 12; + STATIC_REMOTE_KEY_OPT = 13; + PAYMENT_ADDR_REQ = 14; + PAYMENT_ADDR_OPT = 15; + MPP_REQ = 16; + MPP_OPT = 17; +} + +message Feature { + string name = 2; + bool is_required = 3; + bool is_known = 4; +} + +message FeeReportRequest { +} +message ChannelFeeReport { + // The short channel id that this fee report belongs to. + uint64 chan_id = 5 [jstype = JS_STRING]; + + // The channel that this fee report belongs to. + string channel_point = 1; + + // The base fee charged regardless of the number of milli-satoshis sent. + int64 base_fee_msat = 2; + + // The amount charged per milli-satoshis transferred expressed in + // millionths of a satoshi. + int64 fee_per_mil = 3; + + // The effective fee rate in milli-satoshis. Computed by dividing the + // fee_per_mil value by 1 million. + double fee_rate = 4; +} +message FeeReportResponse { + // An array of channel fee reports which describes the current fee schedule + // for each channel. + repeated ChannelFeeReport channel_fees = 1; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 24 hrs. + uint64 day_fee_sum = 2; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 week. + uint64 week_fee_sum = 3; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 month. + uint64 month_fee_sum = 4; +} + +message PolicyUpdateRequest { + oneof scope { + // If set, then this update applies to all currently active channels. + bool global = 1; + + // If set, this update will target a specific channel. + ChannelPoint chan_point = 2; + } + + // The base fee charged regardless of the number of milli-satoshis sent. + int64 base_fee_msat = 3; + + // The effective fee rate in milli-satoshis. The precision of this value + // goes up to 6 decimal places, so 1e-6. + double fee_rate = 4; + + // The required timelock delta for HTLCs forwarded over the channel. + uint32 time_lock_delta = 5; + + // If set, the maximum HTLC size in milli-satoshis. If unset, the maximum + // HTLC will be unchanged. + uint64 max_htlc_msat = 6; + + // The minimum HTLC size in milli-satoshis. Only applied if + // min_htlc_msat_specified is true. + uint64 min_htlc_msat = 7; + + // If true, min_htlc_msat is applied. + bool min_htlc_msat_specified = 8; +} +message PolicyUpdateResponse { +} + +message ForwardingHistoryRequest { + // Start time is the starting point of the forwarding history request. All + // records beyond this point will be included, respecting the end time, and + // the index offset. + uint64 start_time = 1; + + // End time is the end point of the forwarding history request. The + // response will carry at most 50k records between the start time and the + // end time. The index offset can be used to implement pagination. + uint64 end_time = 2; + + // Index offset is the offset in the time series to start at. As each + // response can only contain 50k records, callers can use this to skip + // around within a packed time series. + uint32 index_offset = 3; + + // The max number of events to return in the response to this query. + uint32 num_max_events = 4; +} +message ForwardingEvent { + // Timestamp is the time (unix epoch offset) that this circuit was + // completed. + uint64 timestamp = 1; + + // The incoming channel ID that carried the HTLC that created the circuit. + uint64 chan_id_in = 2 [jstype = JS_STRING]; + + // The outgoing channel ID that carried the preimage that completed the + // circuit. + uint64 chan_id_out = 4 [jstype = JS_STRING]; + + // The total amount (in satoshis) of the incoming HTLC that created half + // the circuit. + uint64 amt_in = 5; + + // The total amount (in satoshis) of the outgoing HTLC that created the + // second half of the circuit. + uint64 amt_out = 6; + + // The total fee (in satoshis) that this payment circuit carried. + uint64 fee = 7; + + // The total fee (in milli-satoshis) that this payment circuit carried. + uint64 fee_msat = 8; + + // The total amount (in milli-satoshis) of the incoming HTLC that created + // half the circuit. + uint64 amt_in_msat = 9; + + // The total amount (in milli-satoshis) of the outgoing HTLC that created + // the second half of the circuit. + uint64 amt_out_msat = 10; + + // TODO(roasbeef): add settlement latency? + // * use FPE on the chan id? + // * also list failures? +} +message ForwardingHistoryResponse { + // A list of forwarding events from the time slice of the time series + // specified in the request. + repeated ForwardingEvent forwarding_events = 1; + + // The index of the last time in the set of returned forwarding events. Can + // be used to seek further, pagination style. + uint32 last_offset_index = 2; +} + +message ExportChannelBackupRequest { + // The target channel point to obtain a back up for. + ChannelPoint chan_point = 1; +} + +message ChannelBackup { + /* + Identifies the channel that this backup belongs to. + */ + ChannelPoint chan_point = 1; + + /* + Is an encrypted single-chan backup. this can be passed to + RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in + order to trigger the recovery protocol. When using REST, this field must be + encoded as base64. + */ + bytes chan_backup = 2; +} + +message MultiChanBackup { + /* + Is the set of all channels that are included in this multi-channel backup. + */ + repeated ChannelPoint chan_points = 1; + + /* + A single encrypted blob containing all the static channel backups of the + channel listed above. This can be stored as a single file or blob, and + safely be replaced with any prior/future versions. When using REST, this + field must be encoded as base64. + */ + bytes multi_chan_backup = 2; +} + +message ChanBackupExportRequest { +} +message ChanBackupSnapshot { + /* + The set of new channels that have been added since the last channel backup + snapshot was requested. + */ + ChannelBackups single_chan_backups = 1; + + /* + A multi-channel backup that covers all open channels currently known to + lnd. + */ + MultiChanBackup multi_chan_backup = 2; +} + +message ChannelBackups { + /* + A set of single-chan static channel backups. + */ + repeated ChannelBackup chan_backups = 1; +} + +message RestoreChanBackupRequest { + oneof backup { + /* + The channels to restore as a list of channel/backup pairs. + */ + ChannelBackups chan_backups = 1; + + /* + The channels to restore in the packed multi backup format. When using + REST, this field must be encoded as base64. + */ + bytes multi_chan_backup = 2; + } +} +message RestoreBackupResponse { +} + +message ChannelBackupSubscription { +} + +message VerifyChanBackupResponse { +} + +message MacaroonPermission { + // The entity a permission grants access to. + string entity = 1; + + // The action that is granted. + string action = 2; +} +message BakeMacaroonRequest { + // The list of permissions the new macaroon should grant. + repeated MacaroonPermission permissions = 1; + + // The root key ID used to create the macaroon, must be a positive integer. + uint64 root_key_id = 2; +} +message BakeMacaroonResponse { + // The hex encoded macaroon, serialized in binary format. + string macaroon = 1; +} + +message ListMacaroonIDsRequest { +} +message ListMacaroonIDsResponse { + // The list of root key IDs that are in use. + repeated uint64 root_key_ids = 1; +} + +message DeleteMacaroonIDRequest { + // The root key ID to be removed. + uint64 root_key_id = 1; +} +message DeleteMacaroonIDResponse { + // A boolean indicates that the deletion is successful. + bool deleted = 1; +} + +message MacaroonPermissionList { + // A list of macaroon permissions. + repeated MacaroonPermission permissions = 1; +} + +message ListPermissionsRequest { +} +message ListPermissionsResponse { + /* + A map between all RPC method URIs and their required macaroon permissions to + access them. + */ + map method_permissions = 1; +} + +message Failure { + enum FailureCode { + /* + The numbers assigned in this enumeration match the failure codes as + defined in BOLT #4. Because protobuf 3 requires enums to start with 0, + a RESERVED value is added. + */ + RESERVED = 0; + + INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS = 1; + INCORRECT_PAYMENT_AMOUNT = 2; + FINAL_INCORRECT_CLTV_EXPIRY = 3; + FINAL_INCORRECT_HTLC_AMOUNT = 4; + FINAL_EXPIRY_TOO_SOON = 5; + INVALID_REALM = 6; + EXPIRY_TOO_SOON = 7; + INVALID_ONION_VERSION = 8; + INVALID_ONION_HMAC = 9; + INVALID_ONION_KEY = 10; + AMOUNT_BELOW_MINIMUM = 11; + FEE_INSUFFICIENT = 12; + INCORRECT_CLTV_EXPIRY = 13; + CHANNEL_DISABLED = 14; + TEMPORARY_CHANNEL_FAILURE = 15; + REQUIRED_NODE_FEATURE_MISSING = 16; + REQUIRED_CHANNEL_FEATURE_MISSING = 17; + UNKNOWN_NEXT_PEER = 18; + TEMPORARY_NODE_FAILURE = 19; + PERMANENT_NODE_FAILURE = 20; + PERMANENT_CHANNEL_FAILURE = 21; + EXPIRY_TOO_FAR = 22; + MPP_TIMEOUT = 23; + + /* + An internal error occurred. + */ + INTERNAL_FAILURE = 997; + + /* + The error source is known, but the failure itself couldn't be decoded. + */ + UNKNOWN_FAILURE = 998; + + /* + An unreadable failure result is returned if the received failure message + cannot be decrypted. In that case the error source is unknown. + */ + UNREADABLE_FAILURE = 999; + } + + // Failure code as defined in the Lightning spec + FailureCode code = 1; + + reserved 2; + + // An optional channel update message. + ChannelUpdate channel_update = 3; + + // A failure type-dependent htlc value. + uint64 htlc_msat = 4; + + // The sha256 sum of the onion payload. + bytes onion_sha_256 = 5; + + // A failure type-dependent cltv expiry value. + uint32 cltv_expiry = 6; + + // A failure type-dependent flags value. + uint32 flags = 7; + + /* + The position in the path of the intermediate or final node that generated + the failure message. Position zero is the sender node. + **/ + uint32 failure_source_index = 8; + + // A failure type-dependent block height. + uint32 height = 9; +} + +message ChannelUpdate { + /* + The signature that validates the announced data and proves the ownership + of node id. + */ + bytes signature = 1; + + /* + The target chain that this channel was opened within. This value + should be the genesis hash of the target chain. Along with the short + channel ID, this uniquely identifies the channel globally in a + blockchain. + */ + bytes chain_hash = 2; + + /* + The unique description of the funding transaction. + */ + uint64 chan_id = 3 [jstype = JS_STRING]; + + /* + A timestamp that allows ordering in the case of multiple announcements. + We should ignore the message if timestamp is not greater than the + last-received. + */ + uint32 timestamp = 4; + + /* + The bitfield that describes whether optional fields are present in this + update. Currently, the least-significant bit must be set to 1 if the + optional field MaxHtlc is present. + */ + uint32 message_flags = 10; + + /* + The bitfield that describes additional meta-data concerning how the + update is to be interpreted. Currently, the least-significant bit must be + set to 0 if the creating node corresponds to the first node in the + previously sent channel announcement and 1 otherwise. If the second bit + is set, then the channel is set to be disabled. + */ + uint32 channel_flags = 5; + + /* + The minimum number of blocks this node requires to be added to the expiry + of HTLCs. This is a security parameter determined by the node operator. + This value represents the required gap between the time locks of the + incoming and outgoing HTLC's set to this node. + */ + uint32 time_lock_delta = 6; + + /* + The minimum HTLC value which will be accepted. + */ + uint64 htlc_minimum_msat = 7; + + /* + The base fee that must be used for incoming HTLC's to this particular + channel. This value will be tacked onto the required for a payment + independent of the size of the payment. + */ + uint32 base_fee = 8; + + /* + The fee rate that will be charged per millionth of a satoshi. + */ + uint32 fee_rate = 9; + + /* + The maximum HTLC value which will be accepted. + */ + uint64 htlc_maximum_msat = 11; + + /* + The set of data that was appended to this message, some of which we may + not actually know how to iterate or parse. By holding onto this data, we + ensure that we're able to properly validate the set of signatures that + cover these new fields, and ensure we're able to make upgrades to the + network in a forwards compatible manner. + */ + bytes extra_opaque_data = 12; +} + +message MacaroonId { + bytes nonce = 1; + bytes storageId = 2; + repeated Op ops = 3; +} + +message Op { + string entity = 1; + repeated string actions = 2; +} diff --git a/service/rpc.go b/service/rpc.go new file mode 100644 index 0000000..cb0b913 --- /dev/null +++ b/service/rpc.go @@ -0,0 +1,47 @@ +package service + +import ( + "context" + "encoding/hex" + "io/ioutil" +) + +type RpcOptions struct { + Host string + Port int16 + TlsCert string + Credential interface{} +} + +type UsernamePasswordCredential struct { + Username string + Password string +} + +// MacaroonCredential implements the credentials.PerRPCCredentials interface. +type MacaroonCredential struct { + Readonly string +} + +// GetRequestMetadata implements the PerRPCCredentials interface. This method +// is required in order to pass the wrapped macaroon into the gRPC context. +// With this, the macaroon will be available within the request handling scope +// of the ultimate gRPC server implementation. +func (t MacaroonCredential) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) { + data, err := ioutil.ReadFile(t.Readonly) + if err != nil { + return nil, err + } + md := make(map[string]string) + md["macaroon"] = hex.EncodeToString(data) + return md, nil +} + +// RequireTransportSecurity implements the PerRPCCredentials interface. +func (t MacaroonCredential) RequireTransportSecurity() bool { + return true +} + +type RpcProvider interface { + ConfigureRpc(options *RpcOptions) +} diff --git a/service/single_container_service.go b/service/single_container_service.go new file mode 100644 index 0000000..bb4e50d --- /dev/null +++ b/service/single_container_service.go @@ -0,0 +1,115 @@ +package service + +import ( + "context" + "fmt" + "io" + "os" + "strings" +) + +type SingleContainerService struct { + *AbstractService + containerName string + dockerClientFactory DockerClientFactory +} + +func NewSingleContainerService( + name string, + containerName string, +) *SingleContainerService { + return &SingleContainerService{ + AbstractService: NewAbstractService(name), + containerName: containerName, + } +} + +func (t *SingleContainerService) SetDockerClientFactory(factory DockerClientFactory) { + t.dockerClientFactory = factory +} + +func (t *SingleContainerService) GetDockerClientFactory() DockerClientFactory { + return t.dockerClientFactory +} + +func (t *SingleContainerService) GetContainer() (*Container, error) { + ctx := context.Background() + cli := t.dockerClientFactory.GetSharedInstance() + c, err := cli.ContainerInspect(ctx, t.containerName) + if err != nil { + return nil, err + } + return &Container{ + c: &c, + client: cli, + logger: t.GetLogger(), + }, nil +} + +func (t *SingleContainerService) IsDisabled() bool { + key := fmt.Sprintf("XUD_DOCKER_SERVICE_%s_DISABLED", strings.ToUpper(t.GetName())) + value := os.Getenv(key) + if value == "true" { + return true + } + return false +} + +// GetStatus implements Service interface +func (t *SingleContainerService) GetStatus() (string, error) { + status, err := t.GetContainerStatus() + if err != nil { + if strings.Contains(err.Error(), "No such container") { + if t.IsDisabled() { + return "Disabled", nil + } + return "Container missing", nil + } + return "", err + } + return fmt.Sprintf("Container %s", status), nil +} + +// GetContainerStatus is a shortcut function +func (t *SingleContainerService) GetContainerStatus() (string, error) { + c, err := t.GetContainer() + if err != nil { + return "", err + } + return c.GetStatus(), nil +} + +// GetContainerLog is a shortcut function +func (t *SingleContainerService) GetLogs(since string, tail string) (<-chan string, error) { + c, err := t.GetContainer() + if err != nil { + return nil, err + } + return c.GetLogs(since, tail) +} + +// GetContainerEnvironmentVariable is a shortcut function +func (t *SingleContainerService) Getenv(key string) (string, error) { + c, err := t.GetContainer() + if err != nil { + return "", err + } + return c.Getenv(key), nil +} + +// ContainerExec is a shortcut function +func (t *SingleContainerService) Exec1(command []string) (string, error) { + c, err := t.GetContainer() + if err != nil { + return "", err + } + return c.Exec(command) +} + +func (t *SingleContainerService) ExecInteractive(command []string) (string, io.Reader, io.Writer, error) { + c, err := t.GetContainer() + if err != nil { + return "", nil, nil, err + } + return c.ExecInteractive(command) +} diff --git a/service/webui/webui.go b/service/webui/webui.go new file mode 100644 index 0000000..4801215 --- /dev/null +++ b/service/webui/webui.go @@ -0,0 +1,32 @@ +package webui + +import "github.com/ExchangeUnion/xud-docker-api-poc/service" + +type WebuiService struct { + *service.SingleContainerService +} + +func (t *WebuiService) GetName() string { + return "webui" +} + +func New( + name string, + containerName string, +) *WebuiService { + return &WebuiService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + } +} + +func (t *WebuiService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + return "Ready", nil + } else { + return status, nil + } +} diff --git a/proto/annotations.proto b/service/xud/proto/annotations.proto similarity index 100% rename from proto/annotations.proto rename to service/xud/proto/annotations.proto diff --git a/proto/google/api/http.proto b/service/xud/proto/google/api/http.proto similarity index 100% rename from proto/google/api/http.proto rename to service/xud/proto/google/api/http.proto diff --git a/proto/google/protobuf/descriptor.proto b/service/xud/proto/google/protobuf/descriptor.proto similarity index 100% rename from proto/google/protobuf/descriptor.proto rename to service/xud/proto/google/protobuf/descriptor.proto diff --git a/proto/xudrpc.proto b/service/xud/proto/xudrpc.proto similarity index 100% rename from proto/xudrpc.proto rename to service/xud/proto/xudrpc.proto diff --git a/service/xud/xud.go b/service/xud/xud.go new file mode 100644 index 0000000..c53046e --- /dev/null +++ b/service/xud/xud.go @@ -0,0 +1,267 @@ +package xud + +import ( + "context" + "fmt" + "github.com/ExchangeUnion/xud-docker-api-poc/service" + pb "github.com/ExchangeUnion/xud-docker-api-poc/service/xud/xudrpc" + "github.com/ExchangeUnion/xud-docker-api-poc/utils" + "github.com/gin-gonic/gin" + "github.com/golang/protobuf/jsonpb" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials" + "log" + "net/http" + "strconv" + "strings" +) + +type XudService struct { + *service.SingleContainerService + rpcOptions *service.RpcOptions + rpcClient pb.XudClient + conn *grpc.ClientConn +} + +type XudRpc struct { + Host string + Port int + Cert string +} + +func New(name string, containerName string) *XudService { + + return &XudService{ + SingleContainerService: service.NewSingleContainerService(name, containerName), + } +} + +func (t *XudService) GetInfo() (*pb.GetInfoResponse, error) { + client, err := t.getRpcClient() + if err != nil { + return nil, err + } + + req := pb.GetInfoRequest{} + return client.GetInfo(context.Background(), &req) +} + +func (t *XudService) GetBalance(currency string) (*pb.GetBalanceResponse, error) { + client, err := t.getRpcClient() + if err != nil { + return nil, err + } + + req := pb.GetBalanceRequest{} + if currency != "" { + req.Currency = currency + } + return client.GetBalance(context.Background(), &req) +} + +func (t *XudService) GetTradeHistory(limit uint32) (*pb.TradeHistoryResponse, error) { + client, err := t.getRpcClient() + if err != nil { + return nil, err + } + + req := pb.TradeHistoryRequest{} + if limit != 0 { + req.Limit = limit + } + return client.TradeHistory(context.Background(), &req) +} + +func (t *XudService) GetTradingLimits(currency string) (*pb.TradingLimitsResponse, error) { + client, err := t.getRpcClient() + if err != nil { + return nil, err + } + + req := pb.TradingLimitsRequest{} + if currency != "" { + req.Currency = currency + } + return client.TradingLimits(context.Background(), &req) +} + +func (t *XudService) ConfigureRpc(options *service.RpcOptions) { + t.rpcOptions = options +} + +func (t *XudService) getRpcClient() (pb.XudClient, error) { + if t.rpcClient == nil { + creds, err := credentials.NewClientTLSFromFile(t.rpcOptions.TlsCert, "localhost") + if err != nil { + return nil, err + } + + addr := fmt.Sprintf("%s:%d", t.rpcOptions.Host, t.rpcOptions.Port) + var opts []grpc.DialOption + opts = append(opts, grpc.WithTransportCredentials(creds)) + opts = append(opts, grpc.WithBlock()) + //opts = append(opts, grpc.WithTimeout(time.Duration(10000))) + + conn, err := grpc.Dial(addr, opts...) + if err != nil { + return nil, err + } + + t.rpcClient = pb.NewXudClient(conn) + } + return t.rpcClient, nil +} + +func (t *XudService) ConfigureRouter(r *gin.Engine) { + r.GET("/api/v1/xud/getinfo", func(c *gin.Context) { + resp, err := t.GetInfo() + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) + r.GET("/api/v1/xud/getbalance", func(c *gin.Context) { + resp, err := t.GetBalance("") + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) + r.GET("/api/v1/xud/getbalance/:currency", func(c *gin.Context) { + resp, err := t.GetBalance(c.Param("currency")) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) + r.GET("/api/v1/xud/tradehistory", func(c *gin.Context) { + limitStr := c.DefaultQuery("limit", "0") + limit, err := strconv.ParseUint(limitStr, 10, 32) + if err != nil { + msg := fmt.Sprintf("invalid limit: %s", err.Error()) + utils.JsonError(c, msg, http.StatusBadRequest) + return + } + if limit < 0 { + msg := fmt.Sprintf("invalid limit: %d", limit) + utils.JsonError(c, msg, http.StatusBadRequest) + return + } + resp, err := t.GetTradeHistory(uint32(limit)) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) + r.GET("/api/v1/xud/tradinglimits", func(c *gin.Context) { + resp, err := t.GetTradingLimits("") + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) + r.GET("/api/v1/xud/tradinglimits/:currency", func(c *gin.Context) { + resp, err := t.GetTradingLimits(c.Param("currency")) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + m := jsonpb.Marshaler{EmitDefaults: true} + err = m.Marshal(c.Writer, resp) + if err != nil { + utils.JsonError(c, err.Error(), http.StatusInternalServerError) + return + } + c.Header("Content-Type", "application/json; charset=utf-8") + }) +} + +func (t *XudService) Close() { + err := t.conn.Close() + if err != nil { + log.Fatal(err) + } +} + +func (t *XudService) GetStatus() (string, error) { + status, err := t.SingleContainerService.GetStatus() + if err != nil { + return "", err + } + if status == "Container running" { + resp, err := t.GetInfo() + if err != nil { + if strings.Contains(err.Error(), "xud is locked") { + return "Wallet locked. Unlock with xucli unlock.", nil + } else if strings.Contains(err.Error(), "no such file or directory, open '/root/.xud/tls.cert'") { + return "Starting...", nil + } else if strings.Contains(err.Error(), "xud is starting") { + return "Starting...", nil + } + return "", err + } + lndbtcStatus := resp.Lnd["BTC"].Status + lndltcStatus := resp.Lnd["LTC"].Status + connextStatus := resp.Connext.Status + + if lndbtcStatus == "Ready" && lndltcStatus == "Ready" && connextStatus == "Ready" { + return "Ready", nil + } + + if strings.Contains(lndbtcStatus, "has no active channels") || + strings.Contains(lndltcStatus, "has no active channels") || + strings.Contains(connextStatus, "has no active channels") { + return "Waiting for channels", nil + } + + var notReady []string + if lndbtcStatus != "Ready" { + notReady = append(notReady, "lndbtc") + } + if lndltcStatus != "Ready" { + notReady = append(notReady, "lndltc") + } + if connextStatus != "Ready" { + notReady = append(notReady, "connext") + } + + return "Waiting for " + strings.Join(notReady, ", "), nil + } else { + return status, nil + } +} diff --git a/xudrpc/xudrpc.pb.go b/service/xud/xudrpc/xudrpc.pb.go similarity index 100% rename from xudrpc/xudrpc.pb.go rename to service/xud/xudrpc/xudrpc.pb.go diff --git a/utils/utils.go b/utils/utils.go new file mode 100644 index 0000000..78e24bf --- /dev/null +++ b/utils/utils.go @@ -0,0 +1,13 @@ +package utils + +import ( + "github.com/gin-gonic/gin" +) + +func JsonError(c *gin.Context, message string, code int) { + c.Header("Content-Type", "application/json; charset=utf-8") + c.Header("X-Content-Type-Options", "nosniff") + c.JSON(code, gin.H{ + "message": message, + }) +} diff --git a/xud.go b/xud.go deleted file mode 100644 index edb10dd..0000000 --- a/xud.go +++ /dev/null @@ -1,94 +0,0 @@ -package main - -import ( - "context" - "encoding/json" - "fmt" - pb "github.com/ExchangeUnion/xud-docker-api-poc/xudrpc" - "github.com/golang/protobuf/jsonpb" - "github.com/gorilla/mux" - "net/http" - "strconv" -) - -type XudService struct { - client pb.XudClient - ctx context.Context -} - -func NewXudService(client pb.XudClient) *XudService { - return &XudService{ - client: client, - ctx: context.Background(), - } -} - -func JsonError(w http.ResponseWriter, message string, code int) { - w.Header().Set("Content-Type", "application/json; charset=utf-8") - w.Header().Set("X-Content-Type-Options", "nosniff") - w.WriteHeader(code) - err := json.NewEncoder(w).Encode(map[string]string{"message": message}) - if err != nil { - http.Error(w, err.Error(), http.StatusInternalServerError) - } -} - -func (t *XudService) GetInfo(w http.ResponseWriter, r *http.Request) { - req := pb.GetInfoRequest{} - resp, err := t.client.GetInfo(t.ctx, &req) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - m := jsonpb.Marshaler{EmitDefaults: true} - err = m.Marshal(w, resp) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - w.Header().Set("Content-Type", "application/json; charset=utf-8") -} - -func (t *XudService) GetBalance(w http.ResponseWriter, r *http.Request) { - req := pb.GetBalanceRequest{} - if currency, ok := mux.Vars(r)["currency"]; ok { - req.Currency = currency - } - resp, err := t.client.GetBalance(t.ctx, &req) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - m := jsonpb.Marshaler{EmitDefaults: true} - err = m.Marshal(w, resp) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - w.Header().Set("Content-Type", "application/json; charset=utf-8") -} - -func (t *XudService) GetTradeHistory(w http.ResponseWriter, r *http.Request) { - req := pb.TradeHistoryRequest{} - if limit, ok := mux.Vars(r)["limit"]; ok { - i, err := strconv.ParseUint(limit, 10, 32) - if err != nil { - msg := fmt.Sprintf("invalid limit: %s", err.Error()) - JsonError(w, msg, http.StatusBadRequest) - return - } - req.Limit = uint32(i) - } - resp, err := t.client.TradeHistory(t.ctx, &req) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - m := jsonpb.Marshaler{EmitDefaults: true} - err = m.Marshal(w, resp) - if err != nil { - JsonError(w, err.Error(), http.StatusInternalServerError) - return - } - w.Header().Set("Content-Type", "application/json; charset=utf-8") -}