server+funding: allow scid-alias, zero-conf chantypes, scid-alias

feature-bit channels

This allows opening zero-conf chan-type, scid-alias chan-type, and
scid-alias feature-bit channels. scid-alias chan-type channels are
required to be private. Two paths are available for opening a zero-conf
channel:

* explicit chan-type negotiation
* LDK carve-out where chan-types are not used, LND is on the
  receiving end, and a ChannelAcceptor is used to enable zero-conf

When a zero-conf channel is negotiated, the funding manager:
* sends a FundingLocked with an alias
* waits for a FundingLocked from the remote peer
* calls addToRouterGraph to persist the channel using our alias in
  the graph. The peer's alias is used to send them a ChannelUpdate.
* wait for six confirmations. If public, the alias edge in the
  graph is deleted and replaced (not atomically) with the confirmed
  edge. Our policy is also read-and-replaced, but the counterparty's
  policy won't exist until they send it to us.

When a scid-alias-feature channel is negotiated, the funding manager:
* sends a FundingLocked with an alias:
* calls addToRouterGraph, sends ChannelUpdate with the confirmed SCID
  since it exists.
* when six confirmations occurs, the edge is deleted and re-inserted
  since the peer may have sent us an alias ChannelUpdate that we are
  storing in the graph.

Since it is possible for a user to toggle the scid-alias-feature-bit
to on while channels exist in the funding manager, care has been taken
to ensure that an alias is ALWAYS sent in the funding_locked message
if this happens.

Author: Crypt-iQ

chanacceptor/acceptor_test.go

@@ -184,13 +184,15 @@ func TestMultipleAcceptClients(t *testing.T) {
 		queries = map[*lnwire.OpenChannel]*ChannelAcceptResponse{
 			chan1: NewChannelAcceptResponse(
 				true, nil, testUpfront, 1, 2, 3, 4, 5, 6,
+				false,
 			),
 			chan2: NewChannelAcceptResponse(
 				false, errChannelRejected, nil, 0, 0, 0,
-				0, 0, 0,
+				0, 0, 0, false,
 			),
 			chan3: NewChannelAcceptResponse(
 				false, customError, nil, 0, 0, 0, 0, 0, 0,
+				false,
 			),
 		}
 
@@ -245,7 +247,7 @@ func TestInvalidResponse(t *testing.T) {
 				PendingChannelID: chan1,
 			}: NewChannelAcceptResponse(
 				false, errChannelRejected, nil, 0, 0,
-				0, 0, 0, 0,
+				0, 0, 0, 0, false,
 			),
 		}
 
@@ -288,7 +290,7 @@ func TestInvalidReserve(t *testing.T) {
 				DustLimit:        dustLimit,
 			}: NewChannelAcceptResponse(
 				false, errChannelRejected, nil, 0, 0,
-				0, reserve, 0, 0,
+				0, reserve, 0, 0, false,
 			),
 		}
 

chanacceptor/chainedacceptor.go

@@ -80,7 +80,7 @@ func (c *ChainedAcceptor) Accept(req *ChannelAcceptRequest) *ChannelAcceptRespon
 
 			return NewChannelAcceptResponse(
 				false, errChannelRejected, nil, 0, 0,
-				0, 0, 0, 0,
+				0, 0, 0, 0, false,
 			)
 		}
 	}

chanacceptor/interface.go

@@ -62,6 +62,10 @@ type ChannelAcceptResponse struct {
 	// MinAcceptDepth is the minimum depth that the initiator of the
 	// channel should wait before considering the channel open.
 	MinAcceptDepth uint16
+
+	// ZeroConf indicates that the fundee wishes to send min_depth = 0 and
+	// request a zero-conf channel with the counter-party.
+	ZeroConf bool
 }
 
 // NewChannelAcceptResponse is a constructor for a channel accept response,
@@ -72,7 +76,7 @@ type ChannelAcceptResponse struct {
 func NewChannelAcceptResponse(accept bool, acceptErr error,
 	upfrontShutdown lnwire.DeliveryAddress, csvDelay, htlcLimit,
 	minDepth uint16, reserve btcutil.Amount, inFlight,
-	minHtlcIn lnwire.MilliSatoshi) *ChannelAcceptResponse {
+	minHtlcIn lnwire.MilliSatoshi, zeroConf bool) *ChannelAcceptResponse {
 
 	resp := &ChannelAcceptResponse{
 		UpfrontShutdown: upfrontShutdown,
@@ -82,6 +86,7 @@ func NewChannelAcceptResponse(accept bool, acceptErr error,
 		HtlcLimit:       htlcLimit,
 		MinHtlcIn:       minHtlcIn,
 		MinAcceptDepth:  minDepth,
+		ZeroConf:        zeroConf,
 	}
 
 	// If we want to accept the channel, we return a response with a nil

chanacceptor/merge.go

@@ -20,13 +20,24 @@ const (
 	fieldUpfrontShutdown = "upfront shutdown"
 )
 
+var (
+	errZeroConf = fmt.Errorf("zero-conf set with non-zero min-depth")
+)
+
 // fieldMismatchError returns a merge error for a named field when we get two
 // channel acceptor responses which have different values set.
 func fieldMismatchError(name string, current, newValue interface{}) error {
 	return fmt.Errorf("multiple values set for: %v, %v and %v",
 		name, current, newValue)
 }
 
+// mergeBool merges two boolean values.
+func mergeBool(current, newValue bool) bool {
+	// If either is true, return true. It is not possible to have different
+	// "non-zero" values like the other cases.
+	return current || newValue
+}
+
 // mergeInt64 merges two int64 values, failing if they have different non-zero
 // values.
 func mergeInt64(name string, current, newValue int64) (int64, error) {
@@ -117,6 +128,13 @@ func mergeResponse(current,
 	}
 	current.MinAcceptDepth = uint16(minDepth)
 
+	current.ZeroConf = mergeBool(current.ZeroConf, newValue.ZeroConf)
+
+	// Assert that if zero-conf is set, min-depth is zero.
+	if current.ZeroConf && current.MinAcceptDepth != 0 {
+		return current, errZeroConf
+	}
+
 	reserve, err := mergeInt64(
 		fieldReserve, int64(current.Reserve), int64(newValue.Reserve),
 	)

chanacceptor/merge_test.go

@@ -167,6 +167,18 @@ func TestMergeResponse(t *testing.T) {
 			},
 			err: nil,
 		},
+		{
+			// Test the case where one response has ZeroConf set
+			// and another has a non-zero min depth set.
+			name: "zero conf conflict",
+			current: ChannelAcceptResponse{
+				ZeroConf: true,
+			},
+			new: ChannelAcceptResponse{
+				MinAcceptDepth: 5,
+			},
+			err: errZeroConf,
+		},
 	}
 
 	for _, test := range tests {

chanacceptor/rpcacceptor.go

@@ -107,7 +107,7 @@ func (r *RPCAcceptor) Accept(req *ChannelAcceptRequest) *ChannelAcceptResponse {
 	// Create a rejection response which we can use for the cases where we
 	// reject the channel.
 	rejectChannel := NewChannelAcceptResponse(
-		false, errChannelRejected, nil, 0, 0, 0, 0, 0, 0,
+		false, errChannelRejected, nil, 0, 0, 0, 0, 0, 0, false,
 	)
 
 	// Send the request to the newRequests channel.
@@ -216,6 +216,7 @@ func (r *RPCAcceptor) receiveResponses(errChan chan error,
 			MaxHtlcCount:    resp.MaxHtlcCount,
 			MinHtlcIn:       resp.MinHtlcIn,
 			MinAcceptDepth:  resp.MinAcceptDepth,
+			ZeroConf:        resp.ZeroConf,
 		}
 
 		// We have received a decision for one of our channel
@@ -348,6 +349,7 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 				btcutil.Amount(resp.ReserveSat),
 				lnwire.MilliSatoshi(resp.InFlightMaxMsat),
 				lnwire.MilliSatoshi(resp.MinHtlcIn),
+				resp.ZeroConf,
 			)
 
 			// Delete the channel from the acceptRequests map.

channeldb/graph.go

@@ -1692,8 +1692,9 @@ func (c *ChannelGraph) PruneTip() (*chainhash.Hash, uint32, error) {
 // database, then ErrEdgeNotFound will be returned. If strictZombiePruning is
 // true, then when we mark these edges as zombies, we'll set up the keys such
 // that we require the node that failed to send the fresh update to be the one
-// that resurrects the channel from its zombie state.
-func (c *ChannelGraph) DeleteChannelEdges(strictZombiePruning bool,
+// that resurrects the channel from its zombie state. The markZombie bool
+// denotes whether or not to mark the channel as a zombie.
+func (c *ChannelGraph) DeleteChannelEdges(strictZombiePruning, markZombie bool,
 	chanIDs ...uint64) error {
 
 	// TODO(roasbeef): possibly delete from node bucket if node has no more
@@ -1730,7 +1731,7 @@ func (c *ChannelGraph) DeleteChannelEdges(strictZombiePruning bool,
 			byteOrder.PutUint64(rawChanID[:], chanID)
 			err := c.delChannelEdge(
 				edges, edgeIndex, chanIndex, zombieIndex, nodes,
-				rawChanID[:], true, strictZombiePruning,
+				rawChanID[:], markZombie, strictZombiePruning,
 			)
 			if err != nil {
 				return err

channeldb/graph_test.go

@@ -378,7 +378,7 @@ func TestEdgeInsertionDeletion(t *testing.T) {
 
 	// Next, attempt to delete the edge from the database, again this
 	// should proceed without any issues.
-	if err := graph.DeleteChannelEdges(false, chanID); err != nil {
+	if err := graph.DeleteChannelEdges(false, true, chanID); err != nil {
 		t.Fatalf("unable to delete edge: %v", err)
 	}
 	assertNoEdge(t, graph, chanID)
@@ -398,7 +398,7 @@ func TestEdgeInsertionDeletion(t *testing.T) {
 
 	// Finally, attempt to delete a (now) non-existent edge within the
 	// database, this should result in an error.
-	err = graph.DeleteChannelEdges(false, chanID)
+	err = graph.DeleteChannelEdges(false, true, chanID)
 	if err != ErrEdgeNotFound {
 		t.Fatalf("deleting a non-existent edge should fail!")
 	}
@@ -1993,7 +1993,7 @@ func TestFilterKnownChanIDs(t *testing.T) {
 		if err := graph.AddChannelEdge(&channel); err != nil {
 			t.Fatalf("unable to create channel edge: %v", err)
 		}
-		err := graph.DeleteChannelEdges(false, channel.ChannelID)
+		err := graph.DeleteChannelEdges(false, true, channel.ChannelID)
 		if err != nil {
 			t.Fatalf("unable to mark edge zombie: %v", err)
 		}
@@ -2251,7 +2251,7 @@ func TestFetchChanInfos(t *testing.T) {
 	if err := graph.AddChannelEdge(&zombieChan); err != nil {
 		t.Fatalf("unable to create channel edge: %v", err)
 	}
-	err = graph.DeleteChannelEdges(false, zombieChan.ChannelID)
+	err = graph.DeleteChannelEdges(false, true, zombieChan.ChannelID)
 	require.NoError(t, err, "unable to delete and mark edge zombie")
 	edgeQuery = append(edgeQuery, zombieChanID.ToUint64())
 
@@ -2789,7 +2789,9 @@ func TestNodeIsPublic(t *testing.T) {
 	// graph. This will make Alice be seen as a private node as it no longer
 	// has any advertised edges.
 	for _, graph := range graphs {
-		err := graph.DeleteChannelEdges(false, aliceBobEdge.ChannelID)
+		err := graph.DeleteChannelEdges(
+			false, true, aliceBobEdge.ChannelID,
+		)
 		if err != nil {
 			t.Fatalf("unable to remove edge: %v", err)
 		}
@@ -2806,7 +2808,9 @@ func TestNodeIsPublic(t *testing.T) {
 	// completely remove the edge as it is not possible for her to know of
 	// it without it being advertised.
 	for i, graph := range graphs {
-		err := graph.DeleteChannelEdges(false, bobCarolEdge.ChannelID)
+		err := graph.DeleteChannelEdges(
+			false, true, bobCarolEdge.ChannelID,
+		)
 		if err != nil {
 			t.Fatalf("unable to remove edge: %v", err)
 		}
@@ -2900,7 +2904,9 @@ func TestDisabledChannelIDs(t *testing.T) {
 	}
 
 	// Delete the channel edge and ensure it is removed from the disabled list.
-	if err = graph.DeleteChannelEdges(false, edgeInfo.ChannelID); err != nil {
+	if err = graph.DeleteChannelEdges(
+		false, true, edgeInfo.ChannelID,
+	); err != nil {
 		t.Fatalf("unable to delete channel edge: %v", err)
 	}
 	disabledChanIds, err = graph.DisabledChannelIDs()
@@ -3111,7 +3117,7 @@ func TestGraphZombieIndex(t *testing.T) {
 
 	// If we delete the edge and mark it as a zombie, then we should expect
 	// to see it within the index.
-	err = graph.DeleteChannelEdges(false, edge.ChannelID)
+	err = graph.DeleteChannelEdges(false, true, edge.ChannelID)
 	require.NoError(t, err, "unable to mark edge as zombie")
 	isZombie, pubKey1, pubKey2 := graph.IsZombieEdge(edge.ChannelID)
 	if !isZombie {