Update go to 1.19.3 (#11630)

* Update go to 1.19.3

* Update other items to 1.19

* Update golangci-lint to latest release

* Run gofmt -s with go1.19

* Huge gofmt changes

Co-authored-by: Raul Jordan <raul@prysmaticlabs.com>

crypto/bls/blst/doc.go

@@ -3,5 +3,4 @@
 // verifying and aggregating BLS signatures used by Ethereum.
 //
 // This implementation uses the library written by Supranational, blst.
-//
 package blst

crypto/bls/blst/secret_key.go

@@ -67,7 +67,8 @@ func IsZero(sKey []byte) bool {
 //
 // In IETF draft BLS specification:
 // Sign(SK, message) -> signature: a signing algorithm that generates
-//      a deterministic signature given a secret key SK and a message.
+//
+//	a deterministic signature given a secret key SK and a message.
 //
 // In Ethereum proof of stake specification:
 // def Sign(SK: int, message: Bytes) -> BLSSignature

crypto/bls/blst/signature.go

@@ -85,8 +85,9 @@ func MultipleSignaturesFromBytes(multiSigs [][]byte) ([]common.Signature, error)
 //
 // In IETF draft BLS specification:
 // Verify(PK, message, signature) -> VALID or INVALID: a verification
-//      algorithm that outputs VALID if signature is a valid signature of
-//      message under public key PK, and INVALID otherwise.
+//
+//	algorithm that outputs VALID if signature is a valid signature of
+//	message under public key PK, and INVALID otherwise.
 //
 // In the Ethereum proof of stake specification:
 // def Verify(PK: BLSPubkey, message: Bytes, signature: BLSSignature) -> bool
@@ -103,10 +104,11 @@ func (s *Signature) Verify(pubKey common.PublicKey, msg []byte) bool {
 //
 // In IETF draft BLS specification:
 // AggregateVerify((PK_1, message_1), ..., (PK_n, message_n),
-//      signature) -> VALID or INVALID: an aggregate verification
-//      algorithm that outputs VALID if signature is a valid aggregated
-//      signature for a collection of public keys and messages, and
-//      outputs INVALID otherwise.
+//
+//	signature) -> VALID or INVALID: an aggregate verification
+//	algorithm that outputs VALID if signature is a valid aggregated
+//	signature for a collection of public keys and messages, and
+//	outputs INVALID otherwise.
 //
 // In the Ethereum proof of stake specification:
 // def AggregateVerify(pairs: Sequence[PK: BLSPubkey, message: Bytes], signature: BLSSignature) -> bool
@@ -134,9 +136,10 @@ func (s *Signature) AggregateVerify(pubKeys []common.PublicKey, msgs [][32]byte)
 //
 // In IETF draft BLS specification:
 // FastAggregateVerify(PK_1, ..., PK_n, message, signature) -> VALID
-//      or INVALID: a verification algorithm for the aggregate of multiple
-//      signatures on the same message.  This function is faster than
-//      AggregateVerify.
+//
+//	or INVALID: a verification algorithm for the aggregate of multiple
+//	signatures on the same message.  This function is faster than
+//	AggregateVerify.
 //
 // In the Ethereum proof of stake specification:
 // def FastAggregateVerify(PKs: Sequence[BLSPubkey], message: Bytes, signature: BLSSignature) -> bool
@@ -156,12 +159,13 @@ func (s *Signature) FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte
 //
 // Spec code:
 // def eth2_fast_aggregate_verify(pubkeys: Sequence[BLSPubkey], message: Bytes32, signature: BLSSignature) -> bool:
-//    """
-//    Wrapper to ``bls.FastAggregateVerify`` accepting the ``G2_POINT_AT_INFINITY`` signature when ``pubkeys`` is empty.
-//    """
-//    if len(pubkeys) == 0 and signature == G2_POINT_AT_INFINITY:
-//        return True
-//    return bls.FastAggregateVerify(pubkeys, message, signature)
+//
+//	"""
+//	Wrapper to ``bls.FastAggregateVerify`` accepting the ``G2_POINT_AT_INFINITY`` signature when ``pubkeys`` is empty.
+//	"""
+//	if len(pubkeys) == 0 and signature == G2_POINT_AT_INFINITY:
+//	    return True
+//	return bls.FastAggregateVerify(pubkeys, message, signature)
 func (s *Signature) Eth2FastAggregateVerify(pubKeys []common.PublicKey, msg [32]byte) bool {
 	if len(pubKeys) == 0 && bytes.Equal(s.Marshal(), common.InfiniteSignature[:]) {
 		return true

crypto/rand/rand.go

@@ -7,26 +7,26 @@ This limits the scope of code that needs to be hardened.
 There are two modes, one for deterministic and another non-deterministic randomness:
 1. If deterministic pseudo-random generator is enough, use:
 
-	import "github.com/prysmaticlabs/prysm/v3/crypto/rand"
-	randGen := rand.NewDeterministicGenerator()
-	randGen.Intn(32) // or any other func defined in math.rand API
+		import "github.com/prysmaticlabs/prysm/v3/crypto/rand"
+		randGen := rand.NewDeterministicGenerator()
+		randGen.Intn(32) // or any other func defined in math.rand API
 
-   In this mode, only seed is generated using cryptographically secure source (crypto/rand). So,
-   once seed is obtained, and generator is seeded, the next generations are deterministic, thus fast.
-   However given that we only seed this 63 bits from crypto/rand and use math/rand to generate the outputs,
-   this method is not cryptographically secure. This is directly stated in the math/rand package,
-   https://github.com/golang/go/blob/release-branch.go1.17/src/math/rand/rand.go#L15. For any security
-   sensitive work this particular generator is NOT to be used.
+	   In this mode, only seed is generated using cryptographically secure source (crypto/rand). So,
+	   once seed is obtained, and generator is seeded, the next generations are deterministic, thus fast.
+	   However given that we only seed this 63 bits from crypto/rand and use math/rand to generate the outputs,
+	   this method is not cryptographically secure. This is directly stated in the math/rand package,
+	   https://github.com/golang/go/blob/release-branch.go1.17/src/math/rand/rand.go#L15. For any security
+	   sensitive work this particular generator is NOT to be used.
 
 2. For cryptographically secure non-deterministic mode (CSPRNG), use:
 
-	import "github.com/prysmaticlabs/prysm/v3/crypto/rand"
-	randGen := rand.NewGenerator()
-	randGen.Intn(32) // or any other func defined in math.rand API
+		import "github.com/prysmaticlabs/prysm/v3/crypto/rand"
+		randGen := rand.NewGenerator()
+		randGen.Intn(32) // or any other func defined in math.rand API
 
-   Again, any of the functions from `math/rand` can be used, however, they all use custom source
-   of randomness (crypto/rand), on every step. This makes randomness non-deterministic. However,
-   you take a performance hit -- as it is an order of magnitude slower.
+	   Again, any of the functions from `math/rand` can be used, however, they all use custom source
+	   of randomness (crypto/rand), on every step. This makes randomness non-deterministic. However,
+	   you take a performance hit -- as it is an order of magnitude slower.
 */
 package rand