Use BuildResult for init proof signing

operator.go

@@ -28,47 +28,18 @@ func (op *Operator) Init(
 	*/
 
 	// sign deposit data
-	depositDataRoot, err := crypto.DepositDataRootForFork(
-		init.Fork,
+	return BuildResult(
+		op.ID,
+		requestID,
+		share,
+		sk,
 		validatorPK,
+		init.Owner,
 		init.WithdrawalCredentials,
+		init.Fork,
+		init.Nonce,
 		phase0.Gwei(init.Amount),
 	)
-	if err != nil {
-		return nil, err
-	}
-	depositDataSig := share.SignByte(depositDataRoot[:])
-
-	// sign proof
-	encryptedShare, err := crypto.Encrypt(&sk.PublicKey, []byte(share.SerializeToHexStr()))
-	if err != nil {
-		return nil, err
-	}
-	proof := &Proof{
-		ValidatorPubKey: validatorPK,
-		EncryptedShare:  encryptedShare,
-		SharePubKey:     share.GetPublicKey().Serialize(),
-		Owner:           init.Owner,
-	}
-	byts, err := proof.MarshalSSZ()
-	if err != nil {
-		return nil, err
-	}
-	proofSig, err := crypto.SignRSA(sk, byts)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Result{
-		OperatorID:                 op.ID,
-		RequestID:                  requestID,
-		DepositPartialSignature:    depositDataSig.Serialize(),
-		OwnerNoncePartialSignature: share.SignByte(PartialNonceRoot(init.Owner, init.Nonce)).Serialize(),
-		SignedProof: SignedProof{
-			Proof:     proof,
-			Signature: proofSig,
-		},
-	}, nil
 }
 
 // Reshare is called when an operator receives a reshare message

testing/result_test.go

@@ -43,6 +43,36 @@ func TestBuildResult(t *testing.T) {
 	})
 }
 
+func TestVerifyCeremonyProofSignaturePath(t *testing.T) {
+	result, err := spec.BuildResult(
+		1,
+		fixtures.TestRequestID,
+		fixtures.ShareSK(fixtures.TestValidator4OperatorsShare1),
+		fixtures.OperatorSK(fixtures.TestOperator1SK),
+		fixtures.ShareSK(fixtures.TestValidator4Operators).GetPublicKey().Serialize(),
+		fixtures.TestOwnerAddress,
+		fixtures.TestWithdrawalCred,
+		fixtures.TestFork,
+		fixtures.TestNonce,
+		fixtures.TestAmount,
+	)
+	require.NoError(t, err)
+
+	require.NoError(t, spec.VerifyCeremonyProof(fixtures.GenerateOperators(4)[0].PubKey, result.SignedProof))
+
+	proofBytes, err := result.SignedProof.Proof.MarshalSSZ()
+	require.NoError(t, err)
+
+	marshalSignedProof := result.SignedProof
+	marshalSignedProof.Signature, err = spec_crypto.SignRSA(fixtures.OperatorSK(fixtures.TestOperator1SK), proofBytes)
+	require.NoError(t, err)
+
+	require.ErrorContains(t,
+		spec.VerifyCeremonyProof(fixtures.GenerateOperators(4)[0].PubKey, marshalSignedProof),
+		"crypto/rsa: verification error",
+	)
+}
+
 func TestValidateResults(t *testing.T) {
 	t.Run("valid 3 out of 4 operators", func(t *testing.T) {
 		_, _, _, err := spec.ValidateResults(