contractcourt/[incoming|outgoing]_contest_resolver: make inner resolver pointer

To make the linter happy, make a pointer to the inner resolver.
Otherwise the linter would complain with

copylocks: literal copies lock value

since we'll add a mutex to the resolver in following commits.

contractcourt/briefcase_test.go

@@ -271,13 +271,13 @@ func assertResolversEqual(t *testing.T, originalResolver ContractResolver,
 	case *htlcOutgoingContestResolver:
 		diskRes := diskResolver.(*htlcOutgoingContestResolver)
 		assertTimeoutResEqual(
-			&ogRes.htlcTimeoutResolver, &diskRes.htlcTimeoutResolver,
+			ogRes.htlcTimeoutResolver, diskRes.htlcTimeoutResolver,
 		)
 
 	case *htlcIncomingContestResolver:
 		diskRes := diskResolver.(*htlcIncomingContestResolver)
 		assertSuccessResEqual(
-			&ogRes.htlcSuccessResolver, &diskRes.htlcSuccessResolver,
+			ogRes.htlcSuccessResolver, diskRes.htlcSuccessResolver,
 		)
 
 		if ogRes.htlcExpiry != diskRes.htlcExpiry {
@@ -375,13 +375,13 @@ func TestContractInsertionRetrieval(t *testing.T) {
 	contestTimeout := timeoutResolver
 	contestTimeout.htlcResolution.ClaimOutpoint = randOutPoint()
 	resolvers = append(resolvers, &htlcOutgoingContestResolver{
-		htlcTimeoutResolver: contestTimeout,
+		htlcTimeoutResolver: &contestTimeout,
 	})
 	contestSuccess := successResolver
 	contestSuccess.htlcResolution.ClaimOutpoint = randOutPoint()
 	resolvers = append(resolvers, &htlcIncomingContestResolver{
 		htlcExpiry:          100,
-		htlcSuccessResolver: contestSuccess,
+		htlcSuccessResolver: &contestSuccess,
 	})
 
 	// For quick lookup during the test, we'll create this map which allow
@@ -521,7 +521,7 @@ func TestContractSwapping(t *testing.T) {
 
 	// We'll create two resolvers, a regular timeout resolver, and the
 	// contest resolver that eventually turns into the timeout resolver.
-	timeoutResolver := htlcTimeoutResolver{
+	timeoutResolver := &htlcTimeoutResolver{
 		htlcResolution: lnwallet.OutgoingHtlcResolution{
 			Expiry:          99,
 			SignedTimeoutTx: nil,
@@ -549,7 +549,7 @@ func TestContractSwapping(t *testing.T) {
 
 	// With the resolver inserted, we'll now attempt to atomically swap it
 	// for its underlying timeout resolver.
-	err = testLog.SwapContract(contestResolver, &timeoutResolver)
+	err = testLog.SwapContract(contestResolver, timeoutResolver)
 	if err != nil {
 		t.Fatalf("unable to swap contracts: %v", err)
 	}
@@ -566,7 +566,7 @@ func TestContractSwapping(t *testing.T) {
 	}
 
 	// That single contract should be the underlying timeout resolver.
-	assertResolversEqual(t, &timeoutResolver, dbContracts[0])
+	assertResolversEqual(t, timeoutResolver, dbContracts[0])
 }
 
 // TestContractResolutionsStorage tests that we're able to properly store and