test(reservations): M2 test-coverage backfill (7 of 8 items)

pkg/chain/ethereum/tbtc.go

@@ -2525,6 +2525,10 @@ func (tc *TbtcChain) ReservationParameters() (
 	return convertReservationParametersFromAbiType(abiParameters), nil
 }
 
+// TODO(test-coverage): ValidateReservationAnchorProposal has no direct unit
+// test coverage. It requires go-ethereum simulated-backend infrastructure
+// that does not exist anywhere in pkg/chain/ethereum today; blocked on that
+// infra landing. See PR #4280 and its linked gap-analysis doc.
 // ValidateReservationAnchorProposal asks the WalletProposalValidator
 // whether the given anchor proposal is valid for the given wallet and
 // reserved deposit. The validator is a separate contract reached at its

pkg/chain/ethereum/tbtc_test.go

@@ -556,8 +556,8 @@ func TestConvertReservationFromAbiType(t *testing.T) {
 		RetryCredit:           true,
 		DissolutionEligibleAt: 1700200000,
 		// CumulativeReanchorFee is intentionally dropped on the Go
-		// boundary (see the function doc comment); set it to a nonzero
-		// value to prove it never leaks into tbtc.Reservation.
+		// boundary (see the Field omissions note on
+		// convertReservationFromAbiType).
 		CumulativeReanchorFee: 12345,
 	}
 
@@ -602,6 +602,66 @@ func TestConvertReservationFromAbiType(t *testing.T) {
 			t.Fatal("expected error, got nil")
 		}
 	})
+
+	// t.Run below documents the intentional CumulativeReanchorFee drop
+	// performed by convertReservationFromAbiType: the field is written
+	// on-chain by every re-anchor hop but is not exposed on
+	// tbtc.Reservation (see the Field omissions note on
+	// convertReservationFromAbiType). It also pins that every other
+	// field maps correctly - each field below is a distinct value so a
+	// future accidental restoration of CumulativeReanchorFee, or a
+	// swapped adjacent field, does not go unnoticed.
+	t.Run("drops cumulative reanchor fee and maps every other field", func(t *testing.T) {
+		abiReservation := tbtcabi.ReservationReservationRequest{
+			Owner:                 common.HexToAddress("0x111111111111111111111111111111111111111B"),
+			MintedAmount:          111,
+			AcceptedAt:            222,
+			WalletPubKeyHash:      [20]byte{0x01, 0x02, 0x03},
+			AnchorAmount:          333,
+			ExpiresAt:             444,
+			AnchorTxHash:          [32]byte{0x04, 0x05, 0x06},
+			AnchorTxOutputIndex:   555,
+			State:                 1, // ReservationStateActive
+			RequestNonce:          666,
+			RetryCredit:           true,
+			DissolutionEligibleAt: 777,
+			CumulativeReanchorFee: 888, // must not appear anywhere in the output
+		}
+
+		expected := &tbtc.Reservation{
+			Owner:        chain.Address("0x111111111111111111111111111111111111111B"),
+			MintedAmount: 111,
+			AcceptedAt:   222,
+			WalletPublicKeyHash: [20]byte{
+				0x01, 0x02, 0x03,
+			},
+			AnchorUtxo: &bitcoin.UnspentTransactionOutput{
+				Outpoint: &bitcoin.TransactionOutpoint{
+					TransactionHash: bitcoin.Hash{0x04, 0x05, 0x06},
+					OutputIndex:     555,
+				},
+				Value: 333,
+			},
+			ExpiresAt:             444,
+			State:                 tbtc.ReservationStateActive,
+			RequestNonce:          666,
+			RetryCredit:           true,
+			DissolutionEligibleAt: 777,
+		}
+
+		actual, err := convertReservationFromAbiType(abiReservation)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !reflect.DeepEqual(expected, actual) {
+			t.Errorf(
+				"unexpected reservation\nexpected: [%+v]\nactual:   [%+v]",
+				expected,
+				actual,
+			)
+		}
+	})
 }
 
 func TestConvertReservationActionFromAbiType(t *testing.T) {
@@ -748,9 +808,15 @@ func TestConvertReservationActionFromAbiType(t *testing.T) {
 	})
 }
 
+// TestConvertReservationParametersFromAbiType verifies the full 10-tuple
+// field mapping performed by convertReservationParametersFromAbiType.
+// Field count/order had not previously been cross-checked against the
+// live Solidity struct; every field below is set to a distinct non-zero
+// value so a swapped or dropped field is caught, not masked by a shared
+// zero-value default.
 func TestConvertReservationParametersFromAbiType(t *testing.T) {
 	vaultAddress := common.HexToAddress(
-		"0x9876543210FeDcBa9876543210fEdCbA98765432",
+		"0x111111111111111111111111111111111111111A",
 	)
 
 	abiParameters := struct {
@@ -777,10 +843,8 @@ func TestConvertReservationParametersFromAbiType(t *testing.T) {
 		ReservationRenewalWindowSeconds: 604800,
 	}
 
-	parameters := convertReservationParametersFromAbiType(abiParameters)
-
 	expected := &tbtc.ReservationParameters{
-		ReservationVault:                chain.Address(vaultAddress.String()),
+		ReservationVault:                chain.Address("0x111111111111111111111111111111111111111A"),
 		ReservationMinAmount:            1000,
 		ReservationTxMaxFee:             5000,
 		ReservationTermSeconds:          1209600,
@@ -792,11 +856,13 @@ func TestConvertReservationParametersFromAbiType(t *testing.T) {
 		ReservationRenewalWindowSeconds: 604800,
 	}
 
-	if !reflect.DeepEqual(expected, parameters) {
+	actual := convertReservationParametersFromAbiType(abiParameters)
+
+	if !reflect.DeepEqual(expected, actual) {
 		t.Errorf(
-			"unexpected parameters\nexpected: [%+v]\nactual:   [%+v]\n",
+			"unexpected reservation parameters\nexpected: [%+v]\nactual:   [%+v]",
 			expected,
-			parameters,
+			actual,
 		)
 	}
 }

pkg/tbtc/reservation_test.go

@@ -14,7 +14,9 @@ import (
 	"go.uber.org/zap"
 	"google.golang.org/protobuf/proto"
 
+	"github.com/keep-network/keep-core/internal/testutils"
 	"github.com/keep-network/keep-core/pkg/bitcoin"
+	"github.com/keep-network/keep-core/pkg/chain"
 	"github.com/keep-network/keep-core/pkg/tbtc/gen/pb"
 )
 
@@ -174,7 +176,7 @@ func TestReservationProposals_UnmarshalRejectsInvalidPayloads(t *testing.T) {
 			}),
 			expectedError: "cannot unmarshal proposal payload: [invalid deposit funding tx hash length: [0]]",
 		},
-		"re-anchor empty payload": {
+		"re-anchor null payload": {
 			actionType:    ActionReservationReanchor,
 			payload:       nil,
 			expectedError: "cannot unmarshal proposal payload: [reservation key is required]",
@@ -1026,3 +1028,207 @@ func TestReservationReanchorAction_Execute(t *testing.T) {
 		}
 	})
 }
+
+// TestAssembleReservationAnchorTransaction verifies the happy-path output
+// shape of AssembleReservationAnchorTransaction: a 1-input-1-output
+// transaction spending the reserved deposit's P2WSH UTXO into a single
+// P2WPKH output controlled by the target wallet, valued at the deposit
+// amount less the transaction fee. Prior to this test, existing coverage
+// (TestAssembleReservationTransactions_InputValidation,
+// TestAssembleReservationTransactions_FeeBoundaries) exercised only
+// validation-error and fee-boundary-error paths; no test asserted the
+// happy-path output shape.
+func TestAssembleReservationAnchorTransaction(t *testing.T) {
+	bitcoinChain := newLocalBitcoinChain()
+
+	privateKeyValue := big.NewInt(100)
+	testWallet := generateWallet(privateKeyValue)
+	walletPublicKeyHash := bitcoin.PublicKeyHash(testWallet.publicKey)
+
+	targetPrivateKeyValue := big.NewInt(200)
+	targetWallet := generateWallet(targetPrivateKeyValue)
+	targetWalletPublicKeyHash := bitcoin.PublicKeyHash(targetWallet.publicKey)
+	targetWalletScript, err := bitcoin.PayToWitnessPublicKeyHash(targetWalletPublicKeyHash)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	deposit := &Deposit{
+		Depositor:           chain.Address("0x1111111111111111111111111111111111111111"),
+		BlindingFactor:      [8]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08},
+		WalletPublicKeyHash: walletPublicKeyHash,
+		RefundPublicKeyHash: [20]byte{0x02},
+		RefundLocktime:      [4]byte{0x03, 0x04, 0x05, 0x06},
+	}
+
+	depositScript, err := deposit.Script()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	depositScriptHash := sha256.Sum256(depositScript)
+	depositLockingScript, err := bitcoin.PayToWitnessScriptHash(depositScriptHash)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fundingTransaction := &bitcoin.Transaction{
+		Version: 1,
+		Inputs: []*bitcoin.TransactionInput{
+			{
+				Outpoint: &bitcoin.TransactionOutpoint{
+					TransactionHash: bitcoin.Hash{0x09},
+					OutputIndex:     0,
+				},
+				Sequence: 0xffffffff,
+			},
+		},
+		Outputs: []*bitcoin.TransactionOutput{
+			{
+				Value:           100000,
+				PublicKeyScript: depositLockingScript,
+			},
+		},
+	}
+	if err := bitcoinChain.BroadcastTransaction(fundingTransaction); err != nil {
+		t.Fatal(err)
+	}
+
+	deposit.Utxo = &bitcoin.UnspentTransactionOutput{
+		Outpoint: &bitcoin.TransactionOutpoint{
+			TransactionHash: fundingTransaction.Hash(),
+			OutputIndex:     0,
+		},
+		Value: 100000,
+	}
+
+	builder, err := AssembleReservationAnchorTransaction(
+		bitcoinChain,
+		deposit,
+		targetWalletPublicKeyHash,
+		&ReservationAction{TxMaxFee: 1500},
+		1500,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	transaction := signReservationTransaction(
+		t,
+		builder,
+		testWallet.publicKey,
+		privateKeyValue,
+	)
+
+	expectedOutputs := []*bitcoin.TransactionOutput{
+		{
+			Value:           98500,
+			PublicKeyScript: targetWalletScript,
+		},
+	}
+
+	if !reflect.DeepEqual(expectedOutputs, transaction.Outputs) {
+		t.Errorf(
+			"unexpected outputs\nexpected: [%+v]\nactual:   [%+v]",
+			expectedOutputs,
+			transaction.Outputs,
+		)
+	}
+
+	testutils.AssertIntsEqual(t, "inputs count", 1, len(transaction.Inputs))
+}
+
+// TestAssembleReservationReanchorTransaction verifies the happy-path output
+// shape of AssembleReservationReanchorTransaction: a 1-input-1-output
+// transaction spending the reservation's anchor UTXO into a single P2WPKH
+// output controlled by the target wallet, valued at the anchor amount less
+// the transaction fee. Prior to this test, existing coverage
+// (TestAssembleReservationTransactions_InputValidation,
+// TestAssembleReservationTransactions_FeeBoundaries) exercised only
+// validation-error and fee-boundary-error paths; no test asserted the
+// happy-path output shape. Note that pkg/tbtcpg does not yet exercise the
+// reanchor assembly path via this function.
+func TestAssembleReservationReanchorTransaction(t *testing.T) {
+	bitcoinChain := newLocalBitcoinChain()
+
+	privateKeyValue := big.NewInt(100)
+	testWallet := generateWallet(privateKeyValue)
+	sourceWalletPublicKeyHash := bitcoin.PublicKeyHash(testWallet.publicKey)
+	sourceWalletScript, err := bitcoin.PayToWitnessPublicKeyHash(sourceWalletPublicKeyHash)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	targetPrivateKeyValue := big.NewInt(200)
+	targetWallet := generateWallet(targetPrivateKeyValue)
+	targetWalletPublicKeyHash := bitcoin.PublicKeyHash(targetWallet.publicKey)
+	targetWalletScript, err := bitcoin.PayToWitnessPublicKeyHash(targetWalletPublicKeyHash)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fundingTransaction := &bitcoin.Transaction{
+		Version: 1,
+		Inputs: []*bitcoin.TransactionInput{
+			{
+				Outpoint: &bitcoin.TransactionOutpoint{
+					TransactionHash: bitcoin.Hash{0x0a},
+					OutputIndex:     0,
+				},
+				Sequence: 0xffffffff,
+			},
+		},
+		Outputs: []*bitcoin.TransactionOutput{
+			{
+				Value:           100000,
+				PublicKeyScript: sourceWalletScript,
+			},
+		},
+	}
+	if err := bitcoinChain.BroadcastTransaction(fundingTransaction); err != nil {
+		t.Fatal(err)
+	}
+
+	anchorUtxo := &bitcoin.UnspentTransactionOutput{
+		Outpoint: &bitcoin.TransactionOutpoint{
+			TransactionHash: fundingTransaction.Hash(),
+			OutputIndex:     0,
+		},
+		Value: 100000,
+	}
+
+	builder, err := AssembleReservationReanchorTransaction(
+		bitcoinChain,
+		anchorUtxo,
+		targetWalletPublicKeyHash,
+		&ReservationAction{TxMaxFee: 1500},
+		1500,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	transaction := signReservationTransaction(
+		t,
+		builder,
+		testWallet.publicKey,
+		privateKeyValue,
+	)
+
+	expectedOutputs := []*bitcoin.TransactionOutput{
+		{
+			Value:           98500,
+			PublicKeyScript: targetWalletScript,
+		},
+	}
+
+	if !reflect.DeepEqual(expectedOutputs, transaction.Outputs) {
+		t.Errorf(
+			"unexpected outputs\nexpected: [%+v]\nactual:   [%+v]",
+			expectedOutputs,
+			transaction.Outputs,
+		)
+	}
+
+	testutils.AssertIntsEqual(t, "inputs count", 1, len(transaction.Inputs))
+}