fix(types): keep AppSignResponse wire keys backward-compatible

Earlier in this PR I added explicit json: tags on AppSignResponse —
"operator_address" / "partial_signature" — alongside the type change to
common.Address. That broke wire compat with operators on pre-PR builds:
the old serialization used the unexported defaults ("OperatorAddress",
"PartialSignature"), so a node from master couldn't decode responses
from a node on this branch and vice versa.

The security fix is the type itself (common.Address canonicalises the
20-byte form on both sides of the wire and rules out hex-encoding
aliasing). The key rename is incidental. Drop the json: tags so the
wire keys revert to "OperatorAddress" / "PartialSignature", keeping
the type-level Sybil defense without a coordinated rollout.

Added Test_AppSignResponse_WireKeysAreStable that pins the wire keys
("OperatorAddress" / "PartialSignature" present, snake_case absent)
so a future maintainer can't silently reintroduce the rename.
Existing canonicalization test updated to use the stable wire keys.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mpjunior92

pkg/types/appsign_response_test.go

@@ -12,12 +12,16 @@ import (
 // regression where AppSignResponse.OperatorAddress was a string. Two payloads
 // that differ only in hex casing must decode to the same common.Address so a
 // collector can't be tricked into counting a single responder twice.
+//
+// The wire keys are the unexported default ("OperatorAddress",
+// "PartialSignature") — see the AppSignResponse type doc for why we keep them
+// rather than switching to snake_case json tags.
 func Test_AppSignResponse_OperatorAddressIsCanonical(t *testing.T) {
 	// Same address, three encodings: lower-case, upper-case (EIP-55-ish), no 0x prefix on inner hex.
 	encodings := []string{
-		`{"operator_address":"0xabcdef1234567890abcdef1234567890abcdef12","partial_signature":{"compressed_bytes":null}}`,
-		`{"operator_address":"0xABCDEF1234567890ABCDEF1234567890ABCDEF12","partial_signature":{"compressed_bytes":null}}`,
-		`{"operator_address":"0xAbCdEf1234567890aBcDeF1234567890AbCdEf12","partial_signature":{"compressed_bytes":null}}`,
+		`{"OperatorAddress":"0xabcdef1234567890abcdef1234567890abcdef12","PartialSignature":{"compressed_bytes":null}}`,
+		`{"OperatorAddress":"0xABCDEF1234567890ABCDEF1234567890ABCDEF12","PartialSignature":{"compressed_bytes":null}}`,
+		`{"OperatorAddress":"0xAbCdEf1234567890aBcDeF1234567890AbCdEf12","PartialSignature":{"compressed_bytes":null}}`,
 	}
 
 	expected := common.HexToAddress("0xabcdef1234567890abcdef1234567890abcdef12")
@@ -29,6 +33,29 @@ func Test_AppSignResponse_OperatorAddressIsCanonical(t *testing.T) {
 	}
 }
 
+// Test_AppSignResponse_WireKeysAreStable pins the wire format so that the
+// type-safety change to common.Address does not accidentally rename the
+// JSON keys and break operators running pre-PR builds.
+func Test_AppSignResponse_WireKeysAreStable(t *testing.T) {
+	addr := common.HexToAddress("0x9095535f04796d223A83c0e1346e7C1D9C6EE6f3")
+
+	enc, err := json.Marshal(AppSignResponse{OperatorAddress: addr})
+	require.NoError(t, err)
+
+	var wireFields map[string]json.RawMessage
+	require.NoError(t, json.Unmarshal(enc, &wireFields))
+
+	_, hasOperatorAddress := wireFields["OperatorAddress"]
+	_, hasPartialSignature := wireFields["PartialSignature"]
+	require.True(t, hasOperatorAddress, "wire key must remain 'OperatorAddress' (no json tag rename)")
+	require.True(t, hasPartialSignature, "wire key must remain 'PartialSignature' (no json tag rename)")
+
+	_, hasSnakeOperator := wireFields["operator_address"]
+	_, hasSnakePartial := wireFields["partial_signature"]
+	require.False(t, hasSnakeOperator, "must not regress to snake_case 'operator_address' wire key")
+	require.False(t, hasSnakePartial, "must not regress to snake_case 'partial_signature' wire key")
+}
+
 // Test_AppSignResponse_RoundTrip checks that the OperatorAddress survives a
 // marshal/unmarshal cycle and remains comparable with ==.
 func Test_AppSignResponse_RoundTrip(t *testing.T) {

pkg/types/types.go

@@ -117,15 +117,18 @@ type AppSignRequest struct {
 
 // AppSignResponse contains a partial signature from a node.
 //
-// OperatorAddress is sent and received as a typed common.Address so that
-// JSON encode/decode round-trips through the canonical 20-byte form. This
-// rules out aliasing attacks where a malicious responder submits two
-// partial signatures under different string encodings of the same address
-// (lower-case vs EIP-55, with-or-without 0x prefix) and the collector
-// counts both toward the ⌈2n/3⌉ threshold.
+// OperatorAddress is a typed common.Address so JSON encode/decode round-trips
+// through the canonical 20-byte form. This rules out aliasing attacks where a
+// malicious responder submits two partial signatures under different string
+// encodings of the same address (lower-case vs EIP-55, with-or-without 0x
+// prefix) and the collector counts both toward the ⌈2n/3⌉ threshold.
+//
+// Wire keys ("OperatorAddress", "PartialSignature") are intentionally derived
+// from the unexported default rather than `json:` tags so that the type
+// change stays wire-compatible with operators still running pre-PR builds.
 type AppSignResponse struct {
-	OperatorAddress  common.Address `json:"operator_address"`
-	PartialSignature G1Point        `json:"partial_signature"`
+	OperatorAddress  common.Address
+	PartialSignature G1Point
 }
 
 // SecretsRequestV1 represents a request for application secrets