wip

aperture.go

@@ -169,7 +169,6 @@ type Aperture struct {
 
 	etcdClient    *clientv3.Client
 	db            *sql.DB
-	lncNodeConn   *lnc.NodeConn
 	challenger    challenger.Challenger
 	httpsServer   *http.Server
 	torHTTPServer *http.Server
@@ -338,31 +337,15 @@ func (a *Aperture) Start(errChan chan error) error {
 					"session: %w", err)
 			}
 
-			nodeConn, err := lnc.NewNodeConn(session, lncStore)
-			if err != nil {
-				return fmt.Errorf("unable to connect to lnd "+
-					"using lnc: %w", err)
-			}
-
-			client, err := nodeConn.Client()
-			if err != nil {
-				return err
-			}
-
-			a.challenger, err = challenger.NewLndChallenger(
-				client, genInvoiceReq, nodeConn.CtxFunc,
-				errChan,
+			challenger, err := challenger.NewLNCChallenger(
+				session, lncStore, genInvoiceReq, errChan,
 			)
 			if err != nil {
-				return err
-			}
-
-			err = a.challenger.Start()
-			if err != nil {
-				return err
+				return fmt.Errorf("unable to create lnc "+
+					"challenger: %w", err)
 			}
 
-			a.lncNodeConn = nodeConn
+			a.challenger = challenger
 
 		case !a.cfg.Authenticator.Disable:
 			log.Infof("Using lnd's authenticator config")
@@ -378,18 +361,16 @@ func (a *Aperture) Start(errChan chan error) error {
 			if err != nil {
 				return err
 			}
-			a.challenger, err = challenger.NewLndChallenger(
+
+			challenger, err := challenger.NewLndChallenger(
 				client, genInvoiceReq, context.Background,
 				errChan,
 			)
 			if err != nil {
 				return err
 			}
 
-			err = a.challenger.Start()
-			if err != nil {
-				return err
-			}
+			a.challenger = challenger
 		}
 	}
 
@@ -497,13 +478,6 @@ func (a *Aperture) Stop() error {
 		a.challenger.Stop()
 	}
 
-	if a.lncNodeConn != nil {
-		if err := a.lncNodeConn.Stop(); err != nil {
-			log.Errorf("Error closing LNC connection: %v", err)
-			returnErr = err
-		}
-	}
-
 	// Stop everything that was started alongside the proxy, for example the
 	// gRPC and REST servers.
 	if a.proxyCleanup != nil {

challenger/lnc.go

@@ -0,0 +1,84 @@
+package challenger
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/lightninglabs/aperture/lnc"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lntypes"
+)
+
+// LndChallenger is a challenger that uses an lnd backend to create new LSAT
+// payment challenges.
+type LNCChallenger struct {
+	lndChallenger *LndChallenger
+	nodeConn      *lnc.NodeConn
+}
+
+// NewLndChallenger creates a new challenger that uses the given connection to
+// an lnd backend to create payment challenges.
+func NewLNCChallenger(session *lnc.Session, lncStore lnc.Store,
+	genInvoiceReq InvoiceRequestGenerator,
+	errChan chan<- error) (*LNCChallenger, error) {
+
+	nodeConn, err := lnc.NewNodeConn(session, lncStore)
+	if err != nil {
+		return nil, fmt.Errorf("unable to connect to lnd using lnc: %w",
+			err)
+	}
+
+	client, err := nodeConn.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	lndChallenger, err := NewLndChallenger(
+		client, genInvoiceReq, nodeConn.CtxFunc, errChan,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	err = lndChallenger.Start()
+	if err != nil {
+		return nil, err
+	}
+
+	return &LNCChallenger{
+		lndChallenger: lndChallenger,
+		nodeConn:      nodeConn,
+	}, nil
+}
+
+// Stop stops the challenger.
+func (l *LNCChallenger) Stop() {
+	err := l.nodeConn.Stop()
+	if err != nil {
+		log.Errorf("unable to stop lnc node conn: %v", err)
+	}
+
+	l.lndChallenger.Stop()
+}
+
+// NewChallenge creates a new LSAT payment challenge, returning a payment
+// request (invoice) and the corresponding payment hash.
+//
+// NOTE: This is part of the mint.Challenger interface.
+func (l *LNCChallenger) NewChallenge(price int64) (string, lntypes.Hash,
+	error) {
+
+	return l.lndChallenger.NewChallenge(price)
+}
+
+// VerifyInvoiceStatus checks that an invoice identified by a payment
+// hash has the desired status. To make sure we don't fail while the
+// invoice update is still on its way, we try several times until either
+// the desired status is set or the given timeout is reached.
+//
+// NOTE: This is part of the auth.InvoiceChecker interface.
+func (l *LNCChallenger) VerifyInvoiceStatus(hash lntypes.Hash,
+	state lnrpc.Invoice_InvoiceState, timeout time.Duration) error {
+
+	return l.lndChallenger.VerifyInvoiceStatus(hash, state, timeout)
+}

challenger/lnd.go

@@ -53,7 +53,7 @@ func NewLndChallenger(client InvoiceClient,
 	}
 
 	invoicesMtx := &sync.Mutex{}
-	return &LndChallenger{
+	challenger := &LndChallenger{
 		client:        client,
 		clientCtx:     ctxFunc,
 		genInvoiceReq: genInvoiceReq,
@@ -62,7 +62,14 @@ func NewLndChallenger(client InvoiceClient,
 		invoicesCond:  sync.NewCond(invoicesMtx),
 		quit:          make(chan struct{}),
 		errChan:       errChan,
-	}, nil
+	}
+
+	err := challenger.Start()
+	if err != nil {
+		return nil, err
+	}
+
+	return challenger, nil
 }
 
 // Start starts the challenger's main work which is to keep track of all

mint/mint.go

@@ -24,20 +24,14 @@ var (
 // challenge that must be satisfied before an LSAT can be validated. This
 // challenge takes the form of a Lightning payment request.
 type Challenger interface {
-	// Start starts the challenger's main work which is to keep track of all
-	// invoices and their states. For that the backing lnd node is queried
-	// for all invoices on startup and the a subscription to all subsequent
-	// invoice updates is created.
-	Start() error
-
-	// Stop shuts down the challenger.
-	Stop()
-
 	// NewChallenge returns a new challenge in the form of a Lightning
 	// payment request. The payment hash is also returned as a convenience
 	// to avoid having to decode the payment request in order to retrieve
 	// its payment hash.
 	NewChallenge(price int64) (string, lntypes.Hash, error)
+
+	// Stop shuts down the challenger.
+	Stop()
 }
 
 // SecretStore is the store responsible for storing LSAT secrets. These secrets