htlcswitch+lnwallet: update existing tests for updated func signatures

We update existing test base to use the new function signatures. This is
also important in order to verify that old behavior is maintained.

Author: GeorgeTsagk

htlcswitch/failure_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/btcsuite/btcd/btcec/v2"
 	sphinx "github.com/lightningnetwork/lightning-onion"
+	"github.com/lightningnetwork/lnd/htlcswitch/hop"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/tlv"
 	"github.com/stretchr/testify/require"
@@ -52,11 +53,13 @@ func TestLongFailureMessage(t *testing.T) {
 	}
 
 	errorDecryptor := &SphinxErrorDecrypter{
-		OnionErrorDecrypter: sphinx.NewOnionErrorDecrypter(circuit),
+		decrypter: sphinx.NewOnionErrorDecrypter(
+			circuit, hop.AttrErrorStruct,
+		),
 	}
 
 	// Assert that the failure message can still be extracted.
-	failure, err := errorDecryptor.DecryptError(reason)
+	failure, err := errorDecryptor.DecryptError(reason, nil)
 	require.NoError(t, err)
 
 	incorrectDetails, ok := failure.msg.(*lnwire.FailIncorrectDetails)

htlcswitch/link_isolated_test.go

@@ -254,7 +254,7 @@ func (l *linkTestContext) receiveFailAliceToBob() {
 		l.t.Fatalf("expected UpdateFailHTLC, got %T", msg)
 	}
 
-	err := l.bobChannel.ReceiveFailHTLC(failMsg.ID, failMsg.Reason)
+	err := l.bobChannel.ReceiveFailHTLC(failMsg.ID, failMsg.Reason, nil)
 	if err != nil {
 		l.t.Fatalf("unable to apply received fail htlc: %v", err)
 	}

htlcswitch/link_test.go

@@ -2678,7 +2678,7 @@ func TestChannelLinkBandwidthConsistency(t *testing.T) {
 	reason := make([]byte, 292)
 	copy(reason, []byte("nop"))
 
-	err = harness.bobChannel.FailHTLC(bobIndex, reason, nil, nil, nil)
+	err = harness.bobChannel.FailHTLC(bobIndex, reason, nil, nil, nil, nil)
 	require.NoError(t, err, "unable to fail htlc")
 	failMsg := &lnwire.UpdateFailHTLC{
 		ID:     1,
@@ -2925,7 +2925,9 @@ func TestChannelLinkBandwidthConsistency(t *testing.T) {
 	if !ok {
 		t.Fatalf("expected UpdateFailHTLC, got %T", msg)
 	}
-	err = harness.bobChannel.ReceiveFailHTLC(failMsg.ID, []byte("fail"))
+	err = harness.bobChannel.ReceiveFailHTLC(
+		failMsg.ID, []byte("fail"), nil,
+	)
 	require.NoError(t, err, "failed receiving fail htlc")
 
 	// After failing an HTLC, the link will automatically trigger
@@ -7310,7 +7312,7 @@ func TestChannelLinkShortFailureRelay(t *testing.T) {
 	// Return a short htlc failure from Bob to Alice and lock in.
 	shortReason := make([]byte, 260)
 
-	err = harness.bobChannel.FailHTLC(0, shortReason, nil, nil, nil)
+	err = harness.bobChannel.FailHTLC(0, shortReason, nil, nil, nil, nil)
 	require.NoError(t, err)
 
 	harness.aliceLink.HandleChannelUpdate(&lnwire.UpdateFailHTLC{

htlcswitch/switch_test.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/davecgh/go-spew/spew"
+	sphinx "github.com/lightningnetwork/lightning-onion"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/contractcourt"
@@ -2744,7 +2745,7 @@ func TestSwitchSendPayment(t *testing.T) {
 	// back. This request should be forwarded back to alice channel link.
 	obfuscator := NewMockObfuscator()
 	failure := lnwire.NewFailIncorrectDetails(update.Amount, 100)
-	reason, err := obfuscator.EncryptFirstHop(failure)
+	reason, _, err := obfuscator.EncryptFirstHop(failure)
 	require.NoError(t, err, "unable obfuscate failure")
 
 	if s.IsForwardedHTLC(aliceChannelLink.ShortChanID(), update.ID) {
@@ -3235,9 +3236,9 @@ func TestInvalidFailure(t *testing.T) {
 	// Get payment result from switch. We expect an unreadable failure
 	// message error.
 	deobfuscator := SphinxErrorDecrypter{
-		OnionErrorDecrypter: &mockOnionErrorDecryptor{
-			err: ErrUnreadableFailureMessage,
-		},
+		decrypter: sphinx.NewOnionErrorDecrypter(
+			nil, hop.AttrErrorStruct,
+		),
 	}
 
 	resultChan, err := s.GetAttemptResult(
@@ -3260,10 +3261,9 @@ func TestInvalidFailure(t *testing.T) {
 	// Modify the decryption to simulate that decryption went alright, but
 	// the failure cannot be decoded.
 	deobfuscator = SphinxErrorDecrypter{
-		OnionErrorDecrypter: &mockOnionErrorDecryptor{
-			sourceIdx: 2,
-			message:   []byte{200},
-		},
+		decrypter: sphinx.NewOnionErrorDecrypter(
+			nil, hop.AttrErrorStruct,
+		),
 	}
 
 	resultChan, err = s.GetAttemptResult(
@@ -4070,7 +4070,9 @@ func TestSwitchHoldForward(t *testing.T) {
 		OnionSHA256: shaOnionBlob,
 	}
 
-	fwdErr, err := newMockDeobfuscator().DecryptError(failPacket.Reason)
+	fwdErr, err := newMockDeobfuscator().DecryptError(
+		failPacket.Reason, nil,
+	)
 	require.NoError(t, err)
 	require.Equal(t, expectedFailure, fwdErr.WireMessage())
 
@@ -5536,7 +5538,7 @@ func testSwitchAliasInterceptFail(t *testing.T, zeroConf bool) {
 		require.True(t, ok)
 
 		fwdErr, err := newMockDeobfuscator().DecryptError(
-			failHtlc.Reason,
+			failHtlc.Reason, nil,
 		)
 		require.NoError(t, err)
 

lnwallet/channel_test.go

@@ -466,9 +466,9 @@ func TestChannelZeroAddLocalHeight(t *testing.T) {
 
 	// Now Bob should fail the htlc back to Alice.
 	// <----fail-----
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err)
-	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"), nil)
 	require.NoError(t, err)
 
 	// Bob should send a commitment signature to Alice.
@@ -2222,9 +2222,11 @@ func TestCancelHTLC(t *testing.T) {
 
 	// Now, with the HTLC committed on both sides, trigger a cancellation
 	// from Bob to Alice, removing the HTLC.
-	err = bobChannel.FailHTLC(bobHtlcIndex, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(
+		bobHtlcIndex, []byte("failreason"), nil, nil, nil, nil,
+	)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(aliceHtlcIndex, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(aliceHtlcIndex, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// Now trigger another state transition, the HTLC should now be removed
@@ -5481,9 +5483,9 @@ func TestChanAvailableBandwidth(t *testing.T) {
 	}
 
 	htlcIndex := uint64((numHtlcs * 2) - 1)
-	err = bobChannel.FailHTLC(htlcIndex, []byte("f"), nil, nil, nil)
+	err = bobChannel.FailHTLC(htlcIndex, []byte("f"), nil, nil, nil, nil)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(htlcIndex, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(htlcIndex, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// We must do a state transition before the balance is available
@@ -5937,9 +5939,11 @@ func TestLockedInHtlcForwardingSkipAfterRestart(t *testing.T) {
 
 	// With both nodes restarted, Bob will now attempt to cancel one of
 	// Alice's HTLC's.
-	err = bobChannel.FailHTLC(htlc.ID, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(
+		htlc.ID, []byte("failreason"), nil, nil, nil, nil,
+	)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(htlc.ID, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(htlc.ID, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// We'll now initiate another state transition, but this time Bob will
@@ -5990,9 +5994,11 @@ func TestLockedInHtlcForwardingSkipAfterRestart(t *testing.T) {
 
 	// Failing the HTLC here will cause the update to be included in Alice's
 	// remote log, but it should not be committed by this transition.
-	err = bobChannel.FailHTLC(htlc2.ID, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(
+		htlc2.ID, []byte("failreason"), nil, nil, nil, nil,
+	)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(htlc2.ID, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(htlc2.ID, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	bobRevocation, _, finalHtlcs, err := bobChannel.
@@ -6045,9 +6051,11 @@ func TestLockedInHtlcForwardingSkipAfterRestart(t *testing.T) {
 
 	// Re-add the Fail to both Alice and Bob's channels, as the non-committed
 	// update will not have survived the restart.
-	err = bobChannel.FailHTLC(htlc2.ID, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(
+		htlc2.ID, []byte("failreason"), nil, nil, nil, nil,
+	)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(htlc2.ID, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(htlc2.ID, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// Have Alice initiate a state transition, which does not include the
@@ -6492,9 +6500,13 @@ func TestDesyncHTLCs(t *testing.T) {
 	}
 
 	// Now let Bob fail this HTLC.
-	err = bobChannel.FailHTLC(bobIndex, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(
+		bobIndex, []byte("failreason"), nil, nil, nil, nil,
+	)
 	require.NoError(t, err, "unable to cancel HTLC")
-	if err := aliceChannel.ReceiveFailHTLC(aliceIndex, []byte("bad")); err != nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		aliceIndex, []byte("bad"), nil,
+	); err != nil {
 		t.Fatalf("unable to recv htlc cancel: %v", err)
 	}
 
@@ -6584,10 +6596,12 @@ func TestMaxAcceptedHTLCs(t *testing.T) {
 
 	// Bob will fail the htlc specified by htlcID and then force a state
 	// transition.
-	err = bobChannel.FailHTLC(htlcID, []byte{}, nil, nil, nil)
+	err = bobChannel.FailHTLC(htlcID, []byte{}, nil, nil, nil, nil)
 	require.NoError(t, err, "unable to fail htlc")
 
-	if err := aliceChannel.ReceiveFailHTLC(htlcID, []byte{}); err != nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		htlcID, []byte{}, nil,
+	); err != nil {
 		t.Fatalf("unable to receive fail htlc: %v", err)
 	}
 
@@ -6690,10 +6704,12 @@ func TestMaxAsynchronousHtlcs(t *testing.T) {
 	addAndReceiveHTLC(t, aliceChannel, bobChannel, htlc, nil)
 
 	// Fail back an HTLC and sign a commitment as in steps 1 & 2.
-	err = bobChannel.FailHTLC(htlcID, []byte{}, nil, nil, nil)
+	err = bobChannel.FailHTLC(htlcID, []byte{}, nil, nil, nil, nil)
 	require.NoError(t, err, "unable to fail htlc")
 
-	if err := aliceChannel.ReceiveFailHTLC(htlcID, []byte{}); err != nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		htlcID, []byte{}, nil,
+	); err != nil {
 		t.Fatalf("unable to receive fail htlc: %v", err)
 	}
 
@@ -7518,10 +7534,10 @@ func TestChannelRestoreUpdateLogsFailedHTLC(t *testing.T) {
 	restoreAndAssert(t, aliceChannel, 1, 0, 0, 0)
 
 	// Now we make Bob fail this HTLC.
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err, "unable to cancel HTLC")
 
-	err = aliceChannel.ReceiveFailHTLC(0, []byte("failreason"))
+	err = aliceChannel.ReceiveFailHTLC(0, []byte("failreason"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// This Fail update should have been added to Alice's remote update log.
@@ -7604,19 +7620,23 @@ func TestDuplicateFailRejection(t *testing.T) {
 
 	// With the HTLC locked in, we'll now have Bob fail the HTLC back to
 	// Alice.
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err, "unable to cancel HTLC")
-	if err := aliceChannel.ReceiveFailHTLC(0, []byte("bad")); err != nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		0, []byte("bad"), nil,
+	); err != nil {
 		t.Fatalf("unable to recv htlc cancel: %v", err)
 	}
 
 	// If we attempt to fail it AGAIN, then both sides should reject this
 	// second failure attempt.
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	if err == nil {
 		t.Fatalf("duplicate HTLC failure attempt should have failed")
 	}
-	if err := aliceChannel.ReceiveFailHTLC(0, []byte("bad")); err == nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		0, []byte("bad"), nil,
+	); err == nil {
 		t.Fatalf("duplicate HTLC failure attempt should have failed")
 	}
 
@@ -7633,14 +7653,16 @@ func TestDuplicateFailRejection(t *testing.T) {
 	require.NoError(t, err, "unable to restart channel")
 
 	// If we try to fail the same HTLC again, then we should get an error.
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	if err == nil {
 		t.Fatalf("duplicate HTLC failure attempt should have failed")
 	}
 
 	// Alice on the other hand should accept the failure again, as she
 	// dropped all items in the logs which weren't committed.
-	if err := aliceChannel.ReceiveFailHTLC(0, []byte("bad")); err != nil {
+	if err := aliceChannel.ReceiveFailHTLC(
+		0, []byte("bad"), nil,
+	); err != nil {
 		t.Fatalf("unable to recv htlc cancel: %v", err)
 	}
 }
@@ -7901,9 +7923,9 @@ func TestChannelRestoreCommitHeight(t *testing.T) {
 	bobChannel = restoreAndAssertCommitHeights(t, bobChannel, true, 1, 2, 2)
 
 	// Bob now fails back the htlc that was just locked in.
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err, "unable to cancel HTLC")
-	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"), nil)
 	require.NoError(t, err, "unable to recv htlc cancel")
 
 	// Now Bob signs for the fail update.
@@ -9224,9 +9246,9 @@ func TestChannelUnsignedAckedFailure(t *testing.T) {
 
 	// Now Bob should fail the htlc back to Alice.
 	// <----fail-----
-	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = bobChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err)
-	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"))
+	err = aliceChannel.ReceiveFailHTLC(0, []byte("bad"), nil)
 	require.NoError(t, err)
 
 	// Bob should send a commitment signature to Alice.
@@ -9328,9 +9350,9 @@ func TestChannelLocalUnsignedUpdatesFailure(t *testing.T) {
 
 	// Now Alice should fail the htlc back to Bob.
 	// -----fail--->
-	err = aliceChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil)
+	err = aliceChannel.FailHTLC(0, []byte("failreason"), nil, nil, nil, nil)
 	require.NoError(t, err)
-	err = bobChannel.ReceiveFailHTLC(0, []byte("bad"))
+	err = bobChannel.ReceiveFailHTLC(0, []byte("bad"), nil)
 	require.NoError(t, err)
 
 	// Alice should send a commitment signature to Bob.
@@ -10773,10 +10795,10 @@ func TestAsynchronousSendingWithFeeBuffer(t *testing.T) {
 	//	<----rev-------	|---------------
 	//	<----sig-------	|---------------
 	//	---------------	|-----rev------>
-	err = aliceChannel.FailHTLC(0, []byte{}, nil, nil, nil)
+	err = aliceChannel.FailHTLC(0, []byte{}, nil, nil, nil, nil)
 	require.NoError(t, err)
 
-	err = bobChannel.ReceiveFailHTLC(0, []byte{})
+	err = bobChannel.ReceiveFailHTLC(0, []byte{}, nil)
 	require.NoError(t, err)
 
 	err = ForceStateTransition(aliceChannel, bobChannel)