Merge pull request #574 from sputn1ck/musig2_default

protocol: set musig2 to be the stable version

client_test.go

@@ -69,7 +69,7 @@ func TestLoopOutSuccess(t *testing.T) {
 
 	testLoopOutSuccess(ctx, testRequest.Amount, info.SwapHash,
 		signalPrepaymentResult, signalSwapPaymentResult, false,
-		confIntent, swap.HtlcV2,
+		confIntent, swap.HtlcV3,
 	)
 }
 
@@ -154,6 +154,7 @@ func TestLoopOutResume(t *testing.T) {
 		loopdb.ProtocolVersionUnrecorded,
 		loopdb.ProtocolVersionHtlcV2,
 		loopdb.ProtocolVersionHtlcV3,
+		loopdb.ProtocolVersionMuSig2,
 	}
 
 	for _, version := range storedVersion {
@@ -339,13 +340,13 @@ func testLoopOutSuccess(ctx *testContext, amt btcutil.Amount, hash lntypes.Hash,
 	// preimage before sweeping in order for the server to trust us with
 	// our MuSig2 signing attempts.
 	if scriptVersion == swap.HtlcV3 {
-		ctx.assertPreimagePush(testPreimage)
+		ctx.assertPreimagePush(ctx.store.loopOutSwaps[hash].Preimage)
 
 		// Try MuSig2 signing first and fail it so that we go for a
 		// normal sweep.
 		for i := 0; i < maxMusigSweepRetries; i++ {
 			ctx.expiryChan <- testTime
-			ctx.assertPreimagePush(testPreimage)
+			ctx.assertPreimagePush(ctx.store.loopOutSwaps[hash].Preimage)
 		}
 		<-ctx.Context.Lnd.SignOutputRawChannel
 	}
@@ -380,10 +381,11 @@ func testLoopOutSuccess(ctx *testContext, amt btcutil.Amount, hash lntypes.Hash,
 
 	if scriptVersion != swap.HtlcV3 {
 		ctx.assertPreimagePush(preimage)
-		// Simulate server pulling payment.
-		signalSwapPaymentResult(nil)
 	}
 
+	// Simulate server pulling payment.
+	signalSwapPaymentResult(nil)
+
 	ctx.NotifySpend(sweepTx, 0)
 
 	ctx.assertStatus(loopdb.StateSuccess)

loopdb/protocol_version.go

@@ -64,11 +64,11 @@ const (
 
 	// stableRPCProtocolVersion defines the current stable RPC protocol
 	// version.
-	stableRPCProtocolVersion = looprpc.ProtocolVersion_ROUTING_PLUGIN
+	stableRPCProtocolVersion = looprpc.ProtocolVersion_MUSIG2
 
 	// experimentalRPCProtocolVersion defines the RPC protocol version that
 	// includes all currently experimentally released features.
-	experimentalRPCProtocolVersion = looprpc.ProtocolVersion_MUSIG2
+	experimentalRPCProtocolVersion = stableRPCProtocolVersion
 )
 
 var (

loopdb/protocol_version_test.go

@@ -25,6 +25,7 @@ func TestProtocolVersionSanity(t *testing.T) {
 		ProtocolVersionProbe,
 		ProtocolVersionRoutingPlugin,
 		ProtocolVersionHtlcV3,
+		ProtocolVersionMuSig2,
 	}
 
 	rpcVersions := [...]looprpc.ProtocolVersion{
@@ -39,6 +40,7 @@ func TestProtocolVersionSanity(t *testing.T) {
 		looprpc.ProtocolVersion_PROBE,
 		looprpc.ProtocolVersion_ROUTING_PLUGIN,
 		looprpc.ProtocolVersion_HTLC_V3,
+		looprpc.ProtocolVersion_MUSIG2,
 	}
 
 	require.Equal(t, len(versions), len(rpcVersions))
@@ -49,7 +51,7 @@ func TestProtocolVersionSanity(t *testing.T) {
 	// Finally test that the current version contants are up to date
 	require.Equal(t,
 		CurrentProtocolVersion(),
-		versions[len(versions)-2],
+		versions[len(versions)-1],
 	)
 
 	require.Equal(t,

loopout_test.go

@@ -694,140 +694,6 @@ func testPreimagePush(t *testing.T) {
 	require.NoError(t, <-errChan)
 }
 
-// TestExpiryBeforeReveal tests the case where the on-chain HTLC expires before
-// we have revealed our preimage, demonstrating that we do not reveal our
-// preimage once we've reached our expiry height.
-func TestExpiryBeforeReveal(t *testing.T) {
-	t.Run("stable protocol", func(t *testing.T) {
-		testExpiryBeforeReveal(t)
-	})
-
-	// Note that there's no point of testing this case with the new
-	// protocol where we use taproot htlc and attempt MuSig2 sweep. The
-	// reason is that the preimage is revealed to the server once the
-	// htlc is confirmed in order to facilitate the cooperative signing of
-	// the sweep transaction.
-}
-
-func testExpiryBeforeReveal(t *testing.T) {
-	defer test.Guard(t)()
-
-	lnd := test.NewMockLnd()
-	ctx := test.NewContext(t, lnd)
-	server := newServerMock(lnd)
-
-	testReq := *testRequest
-
-	// Set on-chain HTLC CLTV.
-	testReq.Expiry = ctx.Lnd.Height + testLoopOutMinOnChainCltvDelta
-
-	// Set our fee estimate to higher than our max miner fee will allow.
-	lnd.SetFeeEstimate(testReq.SweepConfTarget, chainfee.SatPerKWeight(
-		testReq.MaxMinerFee*2,
-	))
-
-	// Setup the cfg using mock server and init a loop out request.
-	cfg := newSwapConfig(
-		&lnd.LndServices, newStoreMock(t), server,
-	)
-	initResult, err := newLoopOutSwap(
-		context.Background(), cfg, ctx.Lnd.Height, &testReq,
-	)
-	require.NoError(t, err)
-	swap := initResult.swap
-
-	// Set up the required dependencies to execute the swap.
-	sweeper := &sweep.Sweeper{Lnd: &lnd.LndServices}
-	blockEpochChan := make(chan interface{})
-	statusChan := make(chan SwapInfo)
-	expiryChan := make(chan time.Time)
-	timerFactory := func(_ time.Duration) <-chan time.Time {
-		return expiryChan
-	}
-
-	errChan := make(chan error)
-	go func() {
-		err := swap.execute(context.Background(), &executeConfig{
-			statusChan:       statusChan,
-			blockEpochChan:   blockEpochChan,
-			timerFactory:     timerFactory,
-			sweeper:          sweeper,
-			verifySchnorrSig: mockVerifySchnorrSigFail,
-		}, ctx.Lnd.Height)
-		if err != nil {
-			log.Error(err)
-		}
-		errChan <- err
-	}()
-
-	// The swap should be found in its initial state.
-	cfg.store.(*storeMock).assertLoopOutStored()
-	state := <-statusChan
-	require.Equal(t, loopdb.StateInitiated, state.State)
-
-	// We'll then pay both the swap and prepay invoice, which should trigger
-	// the server to publish the on-chain HTLC.
-	signalSwapPaymentResult := ctx.AssertPaid(swapInvoiceDesc)
-	signalPrepaymentResult := ctx.AssertPaid(prepayInvoiceDesc)
-
-	signalSwapPaymentResult(nil)
-	signalPrepaymentResult(nil)
-
-	// Notify the confirmation notification for the HTLC.
-	ctx.AssertRegisterConf(false, defaultConfirmations)
-
-	// Advance the block height to get the HTLC confirmed.
-	height := ctx.Lnd.Height + 1
-	blockEpochChan <- height
-
-	htlcTx := wire.NewMsgTx(2)
-	htlcTx.AddTxOut(&wire.TxOut{
-		Value:    int64(swap.AmountRequested),
-		PkScript: swap.htlc.PkScript,
-	})
-	ctx.NotifyConf(htlcTx)
-
-	// The client should then register for a spend of the HTLC and attempt
-	// to sweep it using the custom confirmation target.
-	ctx.AssertRegisterSpendNtfn(swap.htlc.PkScript)
-
-	// Assert that we made a query to track our payment, as required for
-	// preimage push tracking.
-	ctx.AssertTrackPayment()
-
-	// Tick the expiry channel. Because our max miner fee is too high, we
-	// won't attempt a sweep at this point.
-	expiryChan <- testTime
-
-	// Since we don't have a reliable mechanism to non-intrusively avoid
-	// races by setting the fee estimate too soon, let's sleep here a bit
-	// to ensure the first sweep fails.
-	time.Sleep(500 * time.Millisecond)
-
-	// Now we decrease our conf target to less than our max miner fee.
-	lnd.SetFeeEstimate(testReq.SweepConfTarget, chainfee.SatPerKWeight(
-		testReq.MaxMinerFee/2,
-	))
-
-	// Advance the block height to the point where we would do timeout
-	// instead of pushing the preimage.
-	blockEpochChan <- testReq.Expiry + height
-
-	// Tick our expiry channel again to trigger another sweep attempt.
-	expiryChan <- testTime
-
-	// We should see our swap marked as failed.
-	cfg.store.(*storeMock).assertLoopOutState(
-		loopdb.StateFailTimeout,
-	)
-	status := <-statusChan
-	require.Equal(
-		t, status.State, loopdb.StateFailTimeout,
-	)
-
-	require.Nil(t, <-errChan)
-}
-
 // TestFailedOffChainCancelation tests sending of a cancelation message to
 // the server when a swap fails due to off-chain routing.
 func TestFailedOffChainCancelation(t *testing.T) {

release_notes.md

@@ -13,6 +13,7 @@ This file tracks release notes for the loop client.
 * Once the version bump PR is merged and tagged, add the release notes to the tag on GitHub.
 
 ## Next release
+* Set musig2 to be the default swap protocol.
 
 #### New Features