diff --git a/.golangci.yml b/.golangci.yml index 93b3dc5f4bb..8fd9d537ed4 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -17,11 +17,11 @@ linters: - prealloc - reassign - govet + - makezero + - errchkjson + - noctx disable: - testifylint - - errchkjson #TODO: enable me - - makezero #TODO: enable me - - noctx #TODO: enable me - errorlint #TODO: enable me - unused #TODO: enable me - contextcheck diff --git a/cl/antiquary/antiquary_test.go b/cl/antiquary/antiquary_test.go index 0e5793724cf..885c4937d14 100644 --- a/cl/antiquary/antiquary_test.go +++ b/cl/antiquary/antiquary_test.go @@ -587,7 +587,7 @@ func TestBeaconStatesCollector_CollectBalancesDump(t *testing.T) { binary.LittleEndian.PutUint64(balances[24:], 32_050_000_000) slot := uint64(clparams.SlotsPerDump * 2) // aligned to dump boundary - require.NoError(t, c.collectBalancesDump(slot, balances)) + require.NoError(t, c.collectBalancesDump(t.Context(), slot, balances)) db := memdb.NewTestDB(t, dbcfg.ChainDB) tx, err := db.BeginRw(context.Background()) diff --git a/cl/antiquary/beacon_states_collector.go b/cl/antiquary/beacon_states_collector.go index ae29fd7612b..96b9a743c84 100644 --- a/cl/antiquary/beacon_states_collector.go +++ b/cl/antiquary/beacon_states_collector.go @@ -284,16 +284,16 @@ func (i *beaconStatesCollector) collectEffectiveBalancesDump(slot uint64, uncomp return i.effectiveBalancesDumpCollector.Collect(base_encoding.Encode64ToBytes4(roundedSlot), i.buf.Bytes()) } -func (i *beaconStatesCollector) collectBalancesDump(slot uint64, uncompressed []byte) error { +func (i *beaconStatesCollector) collectBalancesDump(ctx context.Context, slot uint64, uncompressed []byte) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateField(context.Background(), slot, uncompressed, i.buf, i.compressor, i.balancesDumpsCollector) + return antiquateField(ctx, slot, uncompressed, i.buf, i.compressor, i.balancesDumpsCollector) } -func (i *beaconStatesCollector) collectPendingDepositsDump(slot uint64, pendingDeposits *solid.ListSSZ[*solid.PendingDeposit]) error { +func (i *beaconStatesCollector) collectPendingDepositsDump(ctx context.Context, slot uint64, pendingDeposits *solid.ListSSZ[*solid.PendingDeposit]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, pendingDeposits, i.buf, i.compressor, i.pendingDepositsCollectorDump) + return antiquateListSSZ(ctx, slot, pendingDeposits, i.buf, i.compressor, i.pendingDepositsCollectorDump) } func (i *beaconStatesCollector) preStateTransitionHook(preState *state.CachingBeaconState) { @@ -333,16 +333,16 @@ func (i *beaconStatesCollector) collectElectraQueuesDiffs(slot uint64, pendingDe return i.pendingWithdrawalsCollector.Collect(base_encoding.Encode64ToBytes4(slot), i.buf.Bytes()) } -func (i *beaconStatesCollector) collectPendingConsolidationsDump(slot uint64, pendingConsolidations *solid.ListSSZ[*solid.PendingConsolidation]) error { +func (i *beaconStatesCollector) collectPendingConsolidationsDump(ctx context.Context, slot uint64, pendingConsolidations *solid.ListSSZ[*solid.PendingConsolidation]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, pendingConsolidations, i.buf, i.compressor, i.pendingConsolidationsCollectorDump) + return antiquateListSSZ(ctx, slot, pendingConsolidations, i.buf, i.compressor, i.pendingConsolidationsCollectorDump) } -func (i *beaconStatesCollector) collectPendingWithdrawalsDump(slot uint64, pendingWithdrawals *solid.ListSSZ[*solid.PendingPartialWithdrawal]) error { +func (i *beaconStatesCollector) collectPendingWithdrawalsDump(ctx context.Context, slot uint64, pendingWithdrawals *solid.ListSSZ[*solid.PendingPartialWithdrawal]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, pendingWithdrawals, i.buf, i.compressor, i.pendingWithdrawalsCollectorDump) + return antiquateListSSZ(ctx, slot, pendingWithdrawals, i.buf, i.compressor, i.pendingWithdrawalsCollectorDump) } // -- gloas queue diffs -- @@ -378,22 +378,22 @@ func (i *beaconStatesCollector) collectGloasQueuesDiffs( // -- gloas dumps (SlotsPerDump boundary) -- -func (i *beaconStatesCollector) collectBuildersDump(slot uint64, builders *solid.ListSSZ[*cltypes.Builder]) error { +func (i *beaconStatesCollector) collectBuildersDump(ctx context.Context, slot uint64, builders *solid.ListSSZ[*cltypes.Builder]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, builders, i.buf, i.compressor, i.buildersCollectorDump) + return antiquateListSSZ(ctx, slot, builders, i.buf, i.compressor, i.buildersCollectorDump) } -func (i *beaconStatesCollector) collectBuilderPendingWithdrawalsDump(slot uint64, bpw *solid.ListSSZ[*cltypes.BuilderPendingWithdrawal]) error { +func (i *beaconStatesCollector) collectBuilderPendingWithdrawalsDump(ctx context.Context, slot uint64, bpw *solid.ListSSZ[*cltypes.BuilderPendingWithdrawal]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, bpw, i.buf, i.compressor, i.builderPendingWithdrawalsCollectorDump) + return antiquateListSSZ(ctx, slot, bpw, i.buf, i.compressor, i.builderPendingWithdrawalsCollectorDump) } -func (i *beaconStatesCollector) collectPayloadExpectedWithdrawalsDump(slot uint64, pew *solid.ListSSZ[*cltypes.Withdrawal]) error { +func (i *beaconStatesCollector) collectPayloadExpectedWithdrawalsDump(ctx context.Context, slot uint64, pew *solid.ListSSZ[*cltypes.Withdrawal]) error { i.buf.Reset() i.compressor.Reset(i.buf) - return antiquateListSSZ(context.Background(), slot, pew, i.buf, i.compressor, i.payloadExpectedWithdrawalsCollectorDump) + return antiquateListSSZ(ctx, slot, pew, i.buf, i.compressor, i.payloadExpectedWithdrawalsCollectorDump) } // -- gloas per-slot fields -- diff --git a/cl/antiquary/state_antiquary.go b/cl/antiquary/state_antiquary.go index 17c2231aa41..843a8bd97c1 100644 --- a/cl/antiquary/state_antiquary.go +++ b/cl/antiquary/state_antiquary.go @@ -427,31 +427,31 @@ func (s *Antiquary) IncrementBeaconState(ctx context.Context, to uint64) error { // If we have a missed block, we just skip it. if block == nil { if isDumpSlot { - if err := stateAntiquaryCollector.collectBalancesDump(slot, s.currentState.RawBalances()); err != nil { + if err := stateAntiquaryCollector.collectBalancesDump(ctx, slot, s.currentState.RawBalances()); err != nil { return err } if err := stateAntiquaryCollector.collectEffectiveBalancesDump(slot, s.currentState.RawValidatorSet()); err != nil { return err } if s.currentState.Version() >= clparams.ElectraVersion { - if err := stateAntiquaryCollector.collectPendingDepositsDump(slot, s.currentState.PendingDeposits()); err != nil { + if err := stateAntiquaryCollector.collectPendingDepositsDump(ctx, slot, s.currentState.PendingDeposits()); err != nil { return err } - if err := stateAntiquaryCollector.collectPendingConsolidationsDump(slot, s.currentState.PendingConsolidations()); err != nil { + if err := stateAntiquaryCollector.collectPendingConsolidationsDump(ctx, slot, s.currentState.PendingConsolidations()); err != nil { return err } - if err := stateAntiquaryCollector.collectPendingWithdrawalsDump(slot, s.currentState.PendingPartialWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectPendingWithdrawalsDump(ctx, slot, s.currentState.PendingPartialWithdrawals()); err != nil { return err } } if s.currentState.Version() >= clparams.GloasVersion { - if err := stateAntiquaryCollector.collectBuildersDump(slot, s.currentState.GetBuilders()); err != nil { + if err := stateAntiquaryCollector.collectBuildersDump(ctx, slot, s.currentState.GetBuilders()); err != nil { return err } - if err := stateAntiquaryCollector.collectBuilderPendingWithdrawalsDump(slot, s.currentState.GetBuilderPendingWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectBuilderPendingWithdrawalsDump(ctx, slot, s.currentState.GetBuilderPendingWithdrawals()); err != nil { return err } - if err := stateAntiquaryCollector.collectPayloadExpectedWithdrawalsDump(slot, s.currentState.GetPayloadExpectedWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectPayloadExpectedWithdrawalsDump(ctx, slot, s.currentState.GetPayloadExpectedWithdrawals()); err != nil { return err } } @@ -501,7 +501,7 @@ func (s *Antiquary) IncrementBeaconState(ctx context.Context, to uint64) error { events.Reset() if isDumpSlot { - if err := stateAntiquaryCollector.collectBalancesDump(slot, s.currentState.RawBalances()); err != nil { + if err := stateAntiquaryCollector.collectBalancesDump(ctx, slot, s.currentState.RawBalances()); err != nil { return err } if err := stateAntiquaryCollector.collectEffectiveBalancesDump(slot, s.currentState.RawValidatorSet()); err != nil { @@ -509,24 +509,24 @@ func (s *Antiquary) IncrementBeaconState(ctx context.Context, to uint64) error { } if s.currentState.Version() >= clparams.ElectraVersion { log.Debug("not-found dumping electra queues", "slot", slot, "pendingDeposits", s.currentState.PendingDeposits().Len(), "pendingConsolidations", s.currentState.PendingConsolidations().Len(), "pendingWithdrawals", s.currentState.PendingPartialWithdrawals().Len()) - if err := stateAntiquaryCollector.collectPendingDepositsDump(slot, s.currentState.PendingDeposits()); err != nil { + if err := stateAntiquaryCollector.collectPendingDepositsDump(ctx, slot, s.currentState.PendingDeposits()); err != nil { return err } - if err := stateAntiquaryCollector.collectPendingConsolidationsDump(slot, s.currentState.PendingConsolidations()); err != nil { + if err := stateAntiquaryCollector.collectPendingConsolidationsDump(ctx, slot, s.currentState.PendingConsolidations()); err != nil { return err } - if err := stateAntiquaryCollector.collectPendingWithdrawalsDump(slot, s.currentState.PendingPartialWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectPendingWithdrawalsDump(ctx, slot, s.currentState.PendingPartialWithdrawals()); err != nil { return err } } if s.currentState.Version() >= clparams.GloasVersion { - if err := stateAntiquaryCollector.collectBuildersDump(slot, s.currentState.GetBuilders()); err != nil { + if err := stateAntiquaryCollector.collectBuildersDump(ctx, slot, s.currentState.GetBuilders()); err != nil { return err } - if err := stateAntiquaryCollector.collectBuilderPendingWithdrawalsDump(slot, s.currentState.GetBuilderPendingWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectBuilderPendingWithdrawalsDump(ctx, slot, s.currentState.GetBuilderPendingWithdrawals()); err != nil { return err } - if err := stateAntiquaryCollector.collectPayloadExpectedWithdrawalsDump(slot, s.currentState.GetPayloadExpectedWithdrawals()); err != nil { + if err := stateAntiquaryCollector.collectPayloadExpectedWithdrawalsDump(ctx, slot, s.currentState.GetPayloadExpectedWithdrawals()); err != nil { return err } } diff --git a/cl/beacon/beaconhttp/api_test.go b/cl/beacon/beaconhttp/api_test.go index c224c25edfc..e26499c604f 100644 --- a/cl/beacon/beaconhttp/api_test.go +++ b/cl/beacon/beaconhttp/api_test.go @@ -25,7 +25,7 @@ func TestHandleEndpoint_SetsEthConsensusVersionHeaderFromBodyVersion(t *testing. return NewBeaconResponse(map[string]any{"ok": true}).WithVersion(clparams.DenebVersion), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) rr := httptest.NewRecorder() h(rr, req) @@ -47,7 +47,7 @@ func TestHandleEndpoint_UsesSSZForPreferredWeightedAccept(t *testing.T) { return NewBeaconResponse(testSSZResponse{}), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) req.Header.Set("Accept", "application/octet-stream;q=1,application/json;q=0.9") rr := httptest.NewRecorder() h(rr, req) @@ -65,7 +65,7 @@ func TestHandleEndpoint_UsesJSONForPreferredSSZAcceptWhenResponseDoesNotSupportS return NewBeaconResponse(map[string]any{"ok": true}), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) req.Header.Set("Accept", "application/octet-stream;q=1,application/json;q=0.9") rr := httptest.NewRecorder() h(rr, req) @@ -91,7 +91,7 @@ func TestHandleEndpoint_RejectsSSZOnlyAcceptWhenResponseDoesNotSupportSSZ(t *tes return NewBeaconResponse(map[string]any{"ok": true}), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) req.Header.Set("Accept", "application/octet-stream") rr := httptest.NewRecorder() h(rr, req) @@ -114,7 +114,7 @@ func TestHandleEndpoint_UsesSSZWhenExactTypeBeatsWildcard(t *testing.T) { return NewBeaconResponse(testSSZResponse{}), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) req.Header.Set("Accept", "application/octet-stream, */*") rr := httptest.NewRecorder() h(rr, req) @@ -164,7 +164,7 @@ func TestHandleEndpoint_DoesNotOverrideEthConsensusVersionHeader(t *testing.T) { WithVersion(clparams.DenebVersion), nil }) - req := httptest.NewRequest("GET", "/test", http.NoBody) + req := httptest.NewRequestWithContext(t.Context(), "GET", "/test", http.NoBody) rr := httptest.NewRecorder() h(rr, req) diff --git a/cl/beacon/beacontest/harness.go b/cl/beacon/beacontest/harness.go index d36a3dc2302..87056edbcd3 100644 --- a/cl/beacon/beacontest/harness.go +++ b/cl/beacon/beacontest/harness.go @@ -408,7 +408,7 @@ func (s *Source) executeRemote(ctx context.Context) (json.RawMessage, int, error } purl.RawQuery = q.Encode() - request, err := http.NewRequest(method, strings.ReplaceAll(purl.String(), "%3F", "?"), body) + request, err := http.NewRequestWithContext(ctx, method, strings.ReplaceAll(purl.String(), "%3F", "?"), body) if err != nil { return nil, 0, err } diff --git a/cl/beacon/handler/blobs.go b/cl/beacon/handler/blobs.go index f2f1e93d929..0d87fc6a36d 100644 --- a/cl/beacon/handler/blobs.go +++ b/cl/beacon/handler/blobs.go @@ -250,7 +250,7 @@ func (a *ApiHandler) GetEthV1BeaconBlobs(w http.ResponseWriter, r *http.Request) return nil, beaconhttp.NewEndpointError(http.StatusNotFound, errors.New("block not found")) } - indicies := []uint64{} + var indicies []uint64 commitments := block.Block.Body.GetBlobKzgCommitments() if commitments == nil { commitments = solid.NewStaticListSSZ[*cltypes.KZGCommitment](0, 48) @@ -263,6 +263,7 @@ func (a *ApiHandler) GetEthV1BeaconBlobs(w http.ResponseWriter, r *http.Request) } } else { // take the blobs by the versioned hashes + filtered := make([]uint64, 0, len(versionedHashes)) versionedHashesToIndex := make(map[common.Hash]uint64) commitments.Range(func(index int, value *cltypes.KZGCommitment, length int) bool { hash, err := utils.KzgCommitmentToVersionedHash(common.Bytes48(*value)) @@ -275,9 +276,10 @@ func (a *ApiHandler) GetEthV1BeaconBlobs(w http.ResponseWriter, r *http.Request) for _, hash := range versionedHashes { index, ok := versionedHashesToIndex[common.HexToHash(hash)] if ok { - indicies = append(indicies, index) + filtered = append(filtered, index) } } + indicies = filtered } // collect the blobs diff --git a/cl/beacon/handler/blobs_test.go b/cl/beacon/handler/blobs_test.go index 7417caf14e9..7ba355fe42c 100644 --- a/cl/beacon/handler/blobs_test.go +++ b/cl/beacon/handler/blobs_test.go @@ -130,7 +130,9 @@ func getBeaconBlobsStatus(t *testing.T, f blobsTestFixture) int { func requestBeaconBlobs(t *testing.T, baseURL string, f blobsTestFixture) *http.Response { t.Helper() - resp, err := http.Get(baseURL + "/eth/v1/beacon/blobs/" + strconv.FormatUint(f.slot, 10) + "?versioned_hashes=" + f.versionedHash.Hex()) + req, err := http.NewRequestWithContext(t.Context(), "GET", baseURL+"/eth/v1/beacon/blobs/"+strconv.FormatUint(f.slot, 10)+"?versioned_hashes="+f.versionedHash.Hex(), nil) + require.NoError(t, err) + resp, err := http.DefaultClient.Do(req) require.NoError(t, err) return resp } @@ -195,7 +197,9 @@ func TestBlobSidecarsResponseEnvelope(t *testing.T) { server := httptest.NewServer(f.handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/blob_sidecars/" + strconv.FormatUint(f.slot, 10)) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/blob_sidecars/"+strconv.FormatUint(f.slot, 10), nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, http.StatusOK, resp.StatusCode) @@ -230,7 +234,9 @@ func TestBlobSidecarsEmptyResponseEnvelope(t *testing.T) { server := httptest.NewServer(f.handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/blob_sidecars/" + strconv.FormatUint(f.slot, 10)) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/blob_sidecars/"+strconv.FormatUint(f.slot, 10), nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, http.StatusOK, resp.StatusCode) diff --git a/cl/beacon/handler/block_production_test.go b/cl/beacon/handler/block_production_test.go index 6f6951bc734..d52bb8594c8 100644 --- a/cl/beacon/handler/block_production_test.go +++ b/cl/beacon/handler/block_production_test.go @@ -83,7 +83,7 @@ func TestBlockBuilderWindowGloas(t *testing.T) { func TestPublishBlindedBlocksRejectsGloas(t *testing.T) { _, _, _, _, _, h, _, _, _, _ := setupTestingHandler(t, clparams.ElectraVersion, log.Root(), true) - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(nil)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(nil)) req.Header.Set("Eth-Consensus-Version", clparams.GloasVersion.String()) _, err := h.publishBlindedBlocks(httptest.NewRecorder(), req, 2) @@ -102,7 +102,7 @@ func TestPublishBlindedBlocksRejectsPreBellatrix(t *testing.T) { block := cltypes.NewSignedBlindedBeaconBlock(&clparams.MainnetBeaconConfig, version) body, err := json.Marshal(block) require.NoError(t, err) - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Eth-Consensus-Version", version.String()) @@ -119,7 +119,7 @@ func TestPublishBlindedBlocksRejectsPreBellatrix(t *testing.T) { func TestPublishBlindedBlocksRejectsUnsupportedContentType(t *testing.T) { h := &ApiHandler{beaconChainCfg: &clparams.MainnetBeaconConfig} - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", nil) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", nil) req.Header.Set("Content-Type", "text/plain") req.Header.Set("Eth-Consensus-Version", clparams.FuluVersion.String()) @@ -146,7 +146,7 @@ func TestPublishBlindedBlocksAcceptsEmptyFuluBuilderResponse(t *testing.T) { block := cltypes.NewSignedBlindedBeaconBlock(&clparams.MainnetBeaconConfig, clparams.FuluVersion) body, err := json.Marshal(block) require.NoError(t, err) - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) req.Header.Set("Content-Type", "application/json; charset=utf-8") req.Header.Set("Eth-Consensus-Version", clparams.FuluVersion.String()) @@ -166,7 +166,7 @@ func TestPublishBlindedBlocksRejectsMissingPreFuluPayload(t *testing.T) { block := cltypes.NewSignedBlindedBeaconBlock(&clparams.MainnetBeaconConfig, clparams.ElectraVersion) body, err := json.Marshal(block) require.NoError(t, err) - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Eth-Consensus-Version", clparams.ElectraVersion.String()) @@ -234,7 +234,7 @@ func TestPublishBlindedBlocksRejectsMalformedRequest(t *testing.T) { if tc.mutateJSON != nil { body = tc.mutateJSON(t, body) } - req := httptest.NewRequest(http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v2/beacon/blinded_blocks", bytes.NewReader(body)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Eth-Consensus-Version", clparams.FuluVersion.String()) diff --git a/cl/beacon/handler/duties_proposer_test.go b/cl/beacon/handler/duties_proposer_test.go index 87fc0bddb67..061f17bc57e 100644 --- a/cl/beacon/handler/duties_proposer_test.go +++ b/cl/beacon/handler/duties_proposer_test.go @@ -100,12 +100,12 @@ func TestGetHistoricalProposerDependentRootEpochZeroReturnsGenesisRoot(t *testin func TestGetDutiesProposerEpochZeroReturnsGenesisRootAndDuties(t *testing.T) { db, _, _, _, _, handler, _, _, fcu, _ := setupTestingHandler(t, clparams.Phase0Version, log.Root(), true) - genesisState, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesisState, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) handler.stateReader = historical_states_reader.NewHistoricalStatesReader(handler.beaconChainCfg, nil, state_accessors.NewStaticValidatorTable(), genesisState, nil, handler.syncedData) genesisRoot := common.Hash{1, 2, 3} - tx, err := db.BeginRw(context.Background()) + tx, err := db.BeginRw(t.Context()) require.NoError(t, err) defer tx.Rollback() require.NoError(t, beacon_indicies.MarkRootCanonical(context.Background(), tx, 0, genesisRoot)) @@ -301,7 +301,7 @@ func TestGetDutiesProposerFutureEpochTooFarReturnsBadRequest(t *testing.T) { headEpoch := postState.Slot() / handler.beaconChainCfg.SlotsPerEpoch epoch := headEpoch + maxEpochsLookaheadForDuties + 1 - request := httptest.NewRequest(http.MethodGet, "/eth/v1/validator/duties/proposer/"+strconv.FormatUint(epoch, 10), http.NoBody) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v1/validator/duties/proposer/"+strconv.FormatUint(epoch, 10), http.NoBody) recorder := httptest.NewRecorder() handler.mux.ServeHTTP(recorder, request) require.Equal(t, http.StatusBadRequest, recorder.Code, recorder.Body.String()) @@ -342,7 +342,7 @@ func TestGetDutiesProposerEpochOverflowReturnsBadRequest(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) epoch := uint64(math.MaxUint64) - request := httptest.NewRequest(http.MethodGet, "/eth/v1/validator/duties/proposer/"+strconv.FormatUint(epoch, 10), http.NoBody) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v1/validator/duties/proposer/"+strconv.FormatUint(epoch, 10), http.NoBody) recorder := httptest.NewRecorder() handler.mux.ServeHTTP(recorder, request) require.Equal(t, http.StatusBadRequest, recorder.Code, recorder.Body.String()) @@ -418,7 +418,7 @@ func TestGetAttesterDutiesEpochOverflowReturnsBadRequest(t *testing.T) { epoch := uint64(math.MaxUint64) body := strings.NewReader(`["0"]`) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/validator/duties/attester/"+strconv.FormatUint(epoch, 10), body) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/validator/duties/attester/"+strconv.FormatUint(epoch, 10), body) recorder := httptest.NewRecorder() handler.mux.ServeHTTP(recorder, request) require.Equal(t, http.StatusBadRequest, recorder.Code, recorder.Body.String()) @@ -430,7 +430,7 @@ func TestPostPtcDutiesEpochOverflowReturnsBadRequest(t *testing.T) { epoch := uint64(math.MaxUint64) body := strings.NewReader(`["0"]`) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/validator/duties/ptc/"+strconv.FormatUint(epoch, 10), body) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/validator/duties/ptc/"+strconv.FormatUint(epoch, 10), body) recorder := httptest.NewRecorder() handler.mux.ServeHTTP(recorder, request) require.Equal(t, http.StatusBadRequest, recorder.Code, recorder.Body.String()) @@ -446,7 +446,7 @@ func getProposerDutiesForEpoch(t *testing.T, handler *ApiHandler, epoch uint64) func getProposerDutiesForPath(t *testing.T, handler *ApiHandler, path string) proposerDutiesResponse { t.Helper() - request := httptest.NewRequest(http.MethodGet, path, http.NoBody) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, path, http.NoBody) recorder := httptest.NewRecorder() handler.mux.ServeHTTP(recorder, request) require.Equal(t, http.StatusOK, recorder.Code, recorder.Body.String()) diff --git a/cl/beacon/handler/epbs_test.go b/cl/beacon/handler/epbs_test.go index b2ad7acc422..4d83473f30b 100644 --- a/cl/beacon/handler/epbs_test.go +++ b/cl/beacon/handler/epbs_test.go @@ -44,7 +44,7 @@ import ( func TestPostPayloadAttestationsRejectsNullMessage(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[null]`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[null]`)) request.Header.Set("Content-Type", "application/json") recorder := httptest.NewRecorder() @@ -59,7 +59,7 @@ func TestPostPayloadAttestationsRejectsOversizedSSZ(t *testing.T) { msgSize := (&cltypes.PayloadAttestationMessage{Data: new(cltypes.PayloadAttestationData)}).EncodingSizeSSZ() maxSize := int(handler.beaconChainCfg.PtcSize) * msgSize - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(strings.Repeat("\x00", maxSize+1))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(strings.Repeat("\x00", maxSize+1))) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -77,7 +77,7 @@ func TestPostPayloadAttestationsAcceptsMoreThanBlockAggregateLimitSSZ(t *testing require.NoError(t, err) body := strings.Repeat(string(encoded), int(handler.beaconChainCfg.MaxPayloadAttestations)+1) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(body)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(body)) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -94,7 +94,7 @@ func TestPostPayloadAttestationsAcceptsSSZContentTypeParameters(t *testing.T) { body, err := msg.EncodeSSZ(nil) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/octet-stream; charset=utf-8") recorder := httptest.NewRecorder() @@ -116,7 +116,7 @@ func TestPostPayloadAttestationsAcceptsQueuedWithoutPooling(t *testing.T) { body, err := json.Marshal([]*cltypes.PayloadAttestationMessage{msg}) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/json") recorder := httptest.NewRecorder() @@ -130,7 +130,7 @@ func TestPostPayloadAttestationsAcceptsQueuedWithoutPooling(t *testing.T) { func TestPostPayloadAttestationsRejectsMalformedContentType(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[]`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[]`)) request.Header.Set("Content-Type", "application/octet-stream; bad") recorder := httptest.NewRecorder() @@ -142,7 +142,7 @@ func TestPostPayloadAttestationsRejectsMalformedContentType(t *testing.T) { func TestPostPayloadAttestationsRejectsUnsupportedContentType(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[]`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/payload_attestations", strings.NewReader(`[]`)) request.Header.Set("Content-Type", "text/plain") recorder := httptest.NewRecorder() @@ -155,7 +155,7 @@ func TestPostExecutionPayloadEnvelopeReturnsForkchoiceError(t *testing.T) { _, _, _, _, _, handler, _, _, fcu, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) fcu.OnExecutionPayloadErr = errors.New("invalid execution payload") - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_envelope", strings.NewReader(`{}`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_envelope", strings.NewReader(`{}`)) request.Header.Set("Content-Type", "application/json; charset=utf-8") recorder := httptest.NewRecorder() @@ -172,7 +172,7 @@ func TestPostPtcDutiesDoesNotCapValidatorCount(t *testing.T) { for i := range indices { indices[i] = `"1"` } - request := httptest.NewRequest(http.MethodPost, "/eth/v1/validator/duties/ptc/5", strings.NewReader("["+strings.Join(indices, ",")+"]")) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/validator/duties/ptc/5", strings.NewReader("["+strings.Join(indices, ",")+"]")) rctx := chi.NewRouteContext() rctx.URLParams.Add("epoch", "5") request = request.WithContext(context.WithValue(request.Context(), chi.RouteCtxKey, rctx)) @@ -189,7 +189,7 @@ func TestPostExecutionPayloadBidAcceptsSSZ(t *testing.T) { body, err := bid.EncodeSSZ(nil) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -213,7 +213,7 @@ func TestPostExecutionPayloadBidAcceptsQueuedBid(t *testing.T) { body, err := bid.EncodeSSZ(nil) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -237,7 +237,7 @@ func TestPostExecutionPayloadBidRejectsHardIgnore(t *testing.T) { body, err := bid.EncodeSSZ(nil) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -249,7 +249,7 @@ func TestPostExecutionPayloadBidRejectsHardIgnore(t *testing.T) { func TestPostExecutionPayloadBidRejectsOversizedSSZ(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(strings.Repeat("\x00", int(maxSignedExecutionPayloadBidSSZSize())+1))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(strings.Repeat("\x00", int(maxSignedExecutionPayloadBidSSZSize())+1))) request.Header.Set("Content-Type", "application/octet-stream") recorder := httptest.NewRecorder() @@ -261,7 +261,7 @@ func TestPostExecutionPayloadBidRejectsOversizedSSZ(t *testing.T) { func TestPostExecutionPayloadBidRejectsMissingMessage(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(`{}`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(`{}`)) request.Header.Set("Content-Type", "application/json") recorder := httptest.NewRecorder() @@ -274,7 +274,7 @@ func TestPostExecutionPayloadBidRejectsMissingMessage(t *testing.T) { func TestPostExecutionPayloadBidRejectsMalformedContentType(t *testing.T) { _, _, _, _, _, handler, _, _, _, _ := setupTestingHandler(t, clparams.BellatrixVersion, log.Root(), true) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(`{}`)) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/execution_payload_bid", strings.NewReader(`{}`)) request.Header.Set("Content-Type", "application/octet-stream; bad") recorder := httptest.NewRecorder() @@ -294,7 +294,7 @@ func TestGetValidatorExecutionPayloadBidReturnsUnsignedBid(t *testing.T) { ParentBlockRoot: bid.ParentBlockRoot, }, &cltypes.SignedExecutionPayloadBid{Message: bid}) - request := httptest.NewRequest(http.MethodGet, "/eth/v1/validator/execution_payload_bid/12/3", http.NoBody) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v1/validator/execution_payload_bid/12/3", http.NoBody) recorder := httptest.NewRecorder() handler.ServeHTTP(recorder, request) @@ -476,7 +476,7 @@ func TestPostValidatorProposerPreferencesAcceptsBatchJSON(t *testing.T) { }) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/validator/proposer_preferences", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/validator/proposer_preferences", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/json") recorder := httptest.NewRecorder() @@ -511,7 +511,7 @@ func TestPostBeaconPoolProposerPreferencesAcceptsBatchJSON(t *testing.T) { }) require.NoError(t, err) - request := httptest.NewRequest(http.MethodPost, "/eth/v1/beacon/pool/proposer_preferences", strings.NewReader(string(body))) + request := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/eth/v1/beacon/pool/proposer_preferences", strings.NewReader(string(body))) request.Header.Set("Content-Type", "application/json") recorder := httptest.NewRecorder() @@ -533,7 +533,7 @@ func TestGetValidatorExecutionPayloadEnvelopesBySlot(t *testing.T) { envelope.BuilderIndex = 7 handler.selfBuildEnvelopes.Add(slot, envelope) - request := httptest.NewRequest(http.MethodGet, "/eth/v1/validator/execution_payload_envelopes/3", http.NoBody) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v1/validator/execution_payload_envelopes/3", http.NoBody) recorder := httptest.NewRecorder() handler.ServeHTTP(recorder, request) diff --git a/cl/beacon/handler/head_test.go b/cl/beacon/handler/head_test.go index 868d8e6393c..9bf24ab8f1c 100644 --- a/cl/beacon/handler/head_test.go +++ b/cl/beacon/handler/head_test.go @@ -74,7 +74,7 @@ func TestDebugBeaconHeadsReportsSelectedHeadOptimistic(t *testing.T) { forkchoiceStore: fcu, } - response, err := a.GetEthV2DebugBeaconHeads(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/eth/v2/debug/beacon/heads", nil)) + response, err := a.GetEthV2DebugBeaconHeads(httptest.NewRecorder(), httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v2/debug/beacon/heads", nil)) require.NoError(t, err) heads := response.Data.([]any) require.Len(t, heads, 1) @@ -139,7 +139,7 @@ func TestHeadBlockIDUsesSelectedHead(t *testing.T) { forkchoiceStore: fcu, } - request := httptest.NewRequest(http.MethodGet, "/eth/v1/beacon/blocks/head/root", nil) + request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/eth/v1/beacon/blocks/head/root", nil) routeContext := chi.NewRouteContext() routeContext.URLParams.Add("block_id", "head") request = request.WithContext(context.WithValue(request.Context(), chi.RouteCtxKey, routeContext)) diff --git a/cl/beacon/handler/headers_test.go b/cl/beacon/handler/headers_test.go index 5771d32f8dd..d6833cc9b9b 100644 --- a/cl/beacon/handler/headers_test.go +++ b/cl/beacon/handler/headers_test.go @@ -111,7 +111,9 @@ func TestGetHeadersIncludesFinalized(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/headers?parent_root=0x" + common.Bytes2Hex(tc.parentRoot[:])) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/headers?parent_root=0x"+common.Bytes2Hex(tc.parentRoot[:]), nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, http.StatusOK, resp.StatusCode) @@ -151,7 +153,9 @@ func TestGetHeadHeaderIsCanonicalBeforeDatabasePromotion(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/headers/head") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/headers/head", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, http.StatusOK, resp.StatusCode) diff --git a/cl/beacon/handler/liveness_test.go b/cl/beacon/handler/liveness_test.go index 35717b22cc4..0f259b4e96e 100644 --- a/cl/beacon/handler/liveness_test.go +++ b/cl/beacon/handler/liveness_test.go @@ -156,11 +156,10 @@ func TestLivenessEndpoint_ValidatorLiveViaParticipation(t *testing.T) { body, err := json.Marshal([]string{"0", "1"}) require.NoError(t, err) - resp, err := server.Client().Post( - server.URL+"/eth/v1/validator/liveness/"+epochStr(epoch), - "application/json", - bytes.NewReader(body), - ) + req, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/liveness/"+epochStr(epoch), bytes.NewReader(body)) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -214,11 +213,10 @@ func TestLivenessEndpoint_NoParticipationNotLive(t *testing.T) { body, err := json.Marshal([]string{"5"}) require.NoError(t, err) - resp, err := server.Client().Post( - server.URL+"/eth/v1/validator/liveness/"+epochStr(epoch), - "application/json", - bytes.NewReader(body), - ) + req, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/liveness/"+epochStr(epoch), bytes.NewReader(body)) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -257,11 +255,10 @@ func TestLivenessEndpoint_FutureEpochReturnsError(t *testing.T) { body, err := json.Marshal([]string{"0"}) require.NoError(t, err) - resp, err := server.Client().Post( - server.URL+"/eth/v1/validator/liveness/"+epochStr(futureEpoch), - "application/json", - bytes.NewReader(body), - ) + req, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/liveness/"+epochStr(futureEpoch), bytes.NewReader(body)) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() diff --git a/cl/beacon/handler/pool.go b/cl/beacon/handler/pool.go index 4909765bd01..b96dfcd2229 100644 --- a/cl/beacon/handler/pool.go +++ b/cl/beacon/handler/pool.go @@ -367,7 +367,9 @@ func (a *ApiHandler) PostEthV1BeaconPoolBlsToExecutionChanges(w http.ResponseWri if len(failures) > 0 { w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}) + if err := json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}); err != nil { + a.logger.Debug("[Beacon REST] failed to encode pooling error", "err", err) + } return } // Only write 200 @@ -424,7 +426,9 @@ func (a *ApiHandler) PostEthV1ValidatorAggregatesAndProof(w http.ResponseWriter, if len(failures) > 0 { w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}) + if err := json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}); err != nil { + a.logger.Debug("[Beacon REST] failed to encode pooling error", "err", err) + } return } // Only write 200 @@ -481,7 +485,9 @@ func (a *ApiHandler) PostEthV1BeaconPoolSyncCommittees(w http.ResponseWriter, r } if len(failures) > 0 { w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}) + if err := json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}); err != nil { + a.logger.Debug("[Beacon REST] failed to encode pooling error", "err", err) + } return } // Only write 200 @@ -526,7 +532,9 @@ func (a *ApiHandler) PostEthV1ValidatorContributionsAndProofs(w http.ResponseWri if len(failures) > 0 { w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}) + if err := json.NewEncoder(w).Encode(poolingError{Code: http.StatusBadRequest, Message: "some failures", Failures: failures}); err != nil { + a.logger.Debug("[Beacon REST] failed to encode pooling error", "err", err) + } return } // Only write 200 diff --git a/cl/beacon/handler/pool_test.go b/cl/beacon/handler/pool_test.go index c7ebec85306..435c4263dcf 100644 --- a/cl/beacon/handler/pool_test.go +++ b/cl/beacon/handler/pool_test.go @@ -19,6 +19,7 @@ package handler import ( "bytes" "encoding/json" + "net/http" "net/http/httptest" "testing" @@ -55,13 +56,18 @@ func TestPoolAttesterSlashings(t *testing.T) { req, err := json.Marshal(attesterSlashing) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/beacon/pool/attester_slashings", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/beacon/pool/attester_slashings", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/beacon/pool/attester_slashings") + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/pool/attester_slashings", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -111,13 +117,18 @@ func TestPoolProposerSlashings(t *testing.T) { require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/beacon/pool/proposer_slashings", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/beacon/pool/proposer_slashings", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/beacon/pool/proposer_slashings") + // get proposer slashings + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/pool/proposer_slashings", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -156,13 +167,18 @@ func TestPoolVoluntaryExits(t *testing.T) { req, err := json.Marshal(voluntaryExit) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/beacon/pool/voluntary_exits", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/beacon/pool/voluntary_exits", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/beacon/pool/voluntary_exits") + // get voluntary exits + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/pool/voluntary_exits", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -209,13 +225,18 @@ func TestPoolBlsToExecutionChainges(t *testing.T) { req, err := json.Marshal(msg) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/beacon/pool/bls_to_execution_changes", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/beacon/pool/bls_to_execution_changes", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/beacon/pool/bls_to_execution_changes") + // get bls to execution changes + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/pool/bls_to_execution_changes", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -273,13 +294,18 @@ func TestPoolAggregatesAndProofs(t *testing.T) { req, err := json.Marshal(msg) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/validator/aggregate_and_proofs", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/aggregate_and_proofs", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/beacon/pool/attestations") + // get attestations + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/pool/attestations", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -324,7 +350,10 @@ func TestPoolAggregatesAndProofsReportsRequestIndex(t *testing.T) { requestBody, err := json.Marshal(msg) require.NoError(t, err) - resp, err := server.Client().Post(server.URL+"/eth/v1/validator/aggregate_and_proofs", "application/json", bytes.NewBuffer(requestBody)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/aggregate_and_proofs", bytes.NewBuffer(requestBody)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 400, resp.StatusCode) @@ -350,13 +379,18 @@ func TestPoolSyncCommittees(t *testing.T) { req, err := json.Marshal(msgs) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/beacon/pool/sync_committees", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/beacon/pool/sync_committees", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/validator/sync_committee_contribution?slot=1&subcommittee_index=0&beacon_block_root=0x0102030405060708000000000000000000000000000000000000000000000000") + + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/validator/sync_committee_contribution?slot=1&subcommittee_index=0&beacon_block_root=0x0102030405060708000000000000000000000000000000000000000000000000", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() @@ -399,13 +433,18 @@ func TestPoolSyncContributionAndProofs(t *testing.T) { req, err := json.Marshal(msgs) require.NoError(t, err) // post attester slashing - resp, err := server.Client().Post(server.URL+"/eth/v1/validator/contribution_and_proofs", "application/json", bytes.NewBuffer(req)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/contribution_and_proofs", bytes.NewBuffer(req)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) - // get attester slashings - resp, err = server.Client().Get(server.URL + "/eth/v1/validator/sync_committee_contribution?slot=1&subcommittee_index=0&beacon_block_root=0x0102030405060708000000000000000000000000000000000000000000000000") + + getReq, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/validator/sync_committee_contribution?slot=1&subcommittee_index=0&beacon_block_root=0x0102030405060708000000000000000000000000000000000000000000000000", nil) + require.NoError(t, err) + resp, err = server.Client().Do(getReq) require.NoError(t, err) defer resp.Body.Close() diff --git a/cl/beacon/handler/rewards_test.go b/cl/beacon/handler/rewards_test.go index de355cab52f..5cc180a7891 100644 --- a/cl/beacon/handler/rewards_test.go +++ b/cl/beacon/handler/rewards_test.go @@ -72,7 +72,9 @@ func TestGetBlockRewards(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() // Query the block in the handler with /eth/v2/beacon/blocks/{block_id} - resp, err := http.Get(server.URL + "/eth/v1/beacon/rewards/blocks/" + c.blockID) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/rewards/blocks/"+c.blockID, nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, c.code, resp.StatusCode) @@ -132,7 +134,7 @@ func TestPostSyncCommitteeRewards(t *testing.T) { url := fmt.Sprintf("%s/eth/v1/beacon/rewards/sync_committee/%s", server.URL, c.blockId) // Create a request - req, err := http.NewRequest("POST", url, strings.NewReader(c.request)) + req, err := http.NewRequestWithContext(t.Context(), "POST", url, strings.NewReader(c.request)) require.NoError(t, err) req.Header.Set("Content-Type", "application/json") diff --git a/cl/beacon/handler/states_test.go b/cl/beacon/handler/states_test.go index e4f7e190af4..d6eb19c567d 100644 --- a/cl/beacon/handler/states_test.go +++ b/cl/beacon/handler/states_test.go @@ -73,7 +73,9 @@ func TestGetStateFork(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() // Query the block in the handler with /eth/v2/beacon/blocks/{block_id} - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/fork") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/fork", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, c.code, resp.StatusCode) @@ -137,7 +139,9 @@ func TestGetStateRoot(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() // Query the block in the handler with /eth/v2/beacon/blocks/{block_id} - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/root") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/root", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, c.code, resp.StatusCode) @@ -195,7 +199,7 @@ func TestGetStateFullHistorical(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() // Query the block in the handler with /eth/v2/beacon/states/{block_id} with content-type octet-stream - req, err := http.NewRequest("GET", server.URL+"/eth/v2/debug/beacon/states/"+c.blockID, nil) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v2/debug/beacon/states/"+c.blockID, nil) require.NoError(t, err) req.Header.Set("Accept", "application/octet-stream") @@ -288,7 +292,7 @@ func TestGetStateFullForkchoice(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() // Query the block in the handler with /eth/v2/beacon/states/{block_id} with content-type octet-stream - req, err := http.NewRequest("GET", server.URL+"/eth/v2/debug/beacon/states/"+c.blockID, nil) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v2/debug/beacon/states/"+c.blockID, nil) require.NoError(t, err) req.Header.Set("Accept", "application/octet-stream") @@ -361,7 +365,9 @@ func TestGetStateSyncCommittees(t *testing.T) { t.Run(c.blockID, func(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/sync_committees") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/sync_committees", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -418,7 +424,9 @@ func TestGetStateSyncCommitteesHistorical(t *testing.T) { t.Run(c.blockID, func(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/sync_committees") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/sync_committees", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -475,7 +483,9 @@ func TestGetStateFinalityCheckpoints(t *testing.T) { t.Run(c.blockID, func(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/finality_checkpoints") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/finality_checkpoints", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -531,7 +541,9 @@ func TestGetRandao(t *testing.T) { t.Run(c.blockID, func(t *testing.T) { server := httptest.NewServer(handler.mux) defer server.Close() - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/" + c.blockID + "/randao") + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/"+c.blockID+"/randao", nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -571,7 +583,9 @@ func TestGetPendingQueuesConsensusVersionHeader(t *testing.T) { versions := map[string]string{} for _, endpoint := range []string{"pending_consolidations", "pending_deposits", "pending_partial_withdrawals"} { - resp, err := http.Get(server.URL + "/eth/v1/beacon/states/head/" + endpoint) + req, err := http.NewRequestWithContext(t.Context(), "GET", server.URL+"/eth/v1/beacon/states/head/"+endpoint, nil) + require.NoError(t, err) + resp, err := server.Client().Do(req) require.NoError(t, err) resp.Body.Close() require.Equal(t, http.StatusOK, resp.StatusCode, endpoint) diff --git a/cl/beacon/handler/utils_test.go b/cl/beacon/handler/utils_test.go index 71657e54917..0b04062b8de 100644 --- a/cl/beacon/handler/utils_test.go +++ b/cl/beacon/handler/utils_test.go @@ -101,7 +101,7 @@ func setupTestingHandler(t *testing.T, v clparams.StateVersion, logger log.Logge opPool = pool.NewOperationsPool(&bcfg) fcu.Pool = opPool - genesis, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesis, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) ethClock := eth_clock.NewEthereumClock(genesis.GenesisTime(), genesis.GenesisValidatorsRoot(), &bcfg) blobStorage := blob_storage.NewBlobStore(blobDb, afero.NewMemMapFs(), math.MaxUint64, &bcfg, ethClock) diff --git a/cl/beacon/handler/validator_registration_test.go b/cl/beacon/handler/validator_registration_test.go index ef935e29062..aab8878567a 100644 --- a/cl/beacon/handler/validator_registration_test.go +++ b/cl/beacon/handler/validator_registration_test.go @@ -48,7 +48,10 @@ func TestPostEthV1ValidatorPreparation(t *testing.T) { reqByte, err := json.Marshal(req) require.NoError(t, err) - resp, err := http.Post(server.URL+"/eth/v1/validator/prepare_beacon_proposer", "application/json", bytes.NewBuffer(reqByte)) + postReq, err := http.NewRequestWithContext(t.Context(), "POST", server.URL+"/eth/v1/validator/prepare_beacon_proposer", bytes.NewBuffer(reqByte)) + require.NoError(t, err) + postReq.Header.Set("Content-Type", "application/json") + resp, err := server.Client().Do(postReq) require.NoError(t, err) defer resp.Body.Close() require.Equal(t, 200, resp.StatusCode) diff --git a/cl/beacon/handler/validator_test.go b/cl/beacon/handler/validator_test.go index 0a457074878..2b45245d4ea 100644 --- a/cl/beacon/handler/validator_test.go +++ b/cl/beacon/handler/validator_test.go @@ -201,7 +201,7 @@ func (t *validatorTestSuite) TestGetEthV1ValidatorAggregateAttestation() { for _, tc := range tests { log.Printf("test case: %s", tc.name) tc.mock() - req, err := http.NewRequest(tc.method, tc.url, nil) + req, err := http.NewRequestWithContext(t.T().Context(), tc.method, tc.url, nil) t.NoError(err) rr := httptest.NewRecorder() t.apiHandler.ServeHTTP(rr, req) diff --git a/cl/beacon/router.go b/cl/beacon/router.go index 275701939e8..811d4f5ee63 100644 --- a/cl/beacon/router.go +++ b/cl/beacon/router.go @@ -18,6 +18,8 @@ package beacon import ( "context" + "errors" + "fmt" "net" "net/http" "time" @@ -34,11 +36,11 @@ type LayeredBeaconHandler struct { ArchiveApi *handler.ApiHandler } -func ListenAndServe(beaconHandler *LayeredBeaconHandler, routerCfg beacon_router_configuration.RouterConfiguration) error { - listener, err := net.Listen(routerCfg.Protocol, routerCfg.Address) +func ListenAndServe(ctx context.Context, beaconHandler *LayeredBeaconHandler, routerCfg beacon_router_configuration.RouterConfiguration) error { + var lc net.ListenConfig + listener, err := lc.Listen(ctx, routerCfg.Protocol, routerCfg.Address) if err != nil { - log.Warn("[Beacon API] Failed to start listening", "addr", routerCfg.Address, "err", err) - return err + return fmt.Errorf("[Beacon API] failed to start listening on %s: %w", routerCfg.Address, err) } defer listener.Close() mux := chi.NewRouter() @@ -73,11 +75,18 @@ func ListenAndServe(beaconHandler *LayeredBeaconHandler, routerCfg beacon_router ReadTimeout: routerCfg.ReadTimeTimeout, IdleTimeout: routerCfg.IdleTimeout, WriteTimeout: routerCfg.WriteTimeout, + BaseContext: func(net.Listener) context.Context { return ctx }, } - if err := server.Serve(listener); err != nil { - log.Warn("[Beacon API] failed to start serving", "addr", routerCfg.Address, "err", err) - return err + go func() { + <-ctx.Done() + shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + _ = server.Shutdown(shutdownCtx) + }() + + if err := server.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) { + return fmt.Errorf("[Beacon API] failed to serve on %s: %w", routerCfg.Address, err) } log.Info("[Beacon API] Listening", "addr", routerCfg.Address) return nil diff --git a/cl/clparams/initial_state/initial_state.go b/cl/clparams/initial_state/initial_state.go index 78911a8fc67..efa44942589 100644 --- a/cl/clparams/initial_state/initial_state.go +++ b/cl/clparams/initial_state/initial_state.go @@ -17,6 +17,7 @@ package initial_state import ( + "context" _ "embed" "fmt" "io" @@ -27,9 +28,12 @@ import ( chainspec "github.com/erigontech/erigon/execution/chain/spec" ) -func downloadGenesisState(url string) ([]byte, error) { - // Download genesis state by wget the url. MUST NOT RETURN NIL thorugh GET request. use go stnadard library - resp, err := http.Get(url) +func downloadGenesisState(ctx context.Context, url string) ([]byte, error) { + req, err := http.NewRequestWithContext(ctx, "GET", url, nil) + if err != nil { + return nil, err + } + resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } @@ -56,7 +60,7 @@ var chiadoStateSSZ []byte var bloatnetStateSSZ []byte // Return genesis state -func GetGenesisState(network clparams.NetworkType) (*state.CachingBeaconState, error) { +func GetGenesisState(ctx context.Context, network clparams.NetworkType) (*state.CachingBeaconState, error) { _, config := clparams.GetConfigsByNetwork(network) returnState := state.New(config) @@ -79,7 +83,7 @@ func GetGenesisState(network clparams.NetworkType) (*state.CachingBeaconState, e } case chainspec.HoodiChainID: // Download genesis state by wget the url - encodedState, err := downloadGenesisState("https://github.com/eth-clients/hoodi/raw/main/metadata/genesis.ssz") + encodedState, err := downloadGenesisState(ctx, "https://github.com/eth-clients/hoodi/raw/main/metadata/genesis.ssz") if err != nil { return nil, err } diff --git a/cl/clparams/initial_state/initial_state_test.go b/cl/clparams/initial_state/initial_state_test.go index 39de71e6677..ba3eb59e547 100644 --- a/cl/clparams/initial_state/initial_state_test.go +++ b/cl/clparams/initial_state/initial_state_test.go @@ -28,7 +28,7 @@ import ( ) func TestMainnet(t *testing.T) { - state, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + state, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) root, err := state.HashSSZ() require.NoError(t, err) @@ -36,7 +36,7 @@ func TestMainnet(t *testing.T) { } func TestSepolia(t *testing.T) { - state, err := initial_state.GetGenesisState(chainspec.SepoliaChainID) + state, err := initial_state.GetGenesisState(t.Context(), chainspec.SepoliaChainID) require.NoError(t, err) root, err := state.HashSSZ() require.NoError(t, err) diff --git a/cl/merkle_tree/merkle_tree_test.go b/cl/merkle_tree/merkle_tree_test.go index f029d8e575f..319dab1b917 100644 --- a/cl/merkle_tree/merkle_tree_test.go +++ b/cl/merkle_tree/merkle_tree_test.go @@ -56,7 +56,7 @@ func TestMerkleTreeAppendLeaf(t *testing.T) { }, nil) // Test AppendLeaf mt.AppendLeaf() - testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) + testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) //nolint:makezero testBuffer[128] = 5 expectedRoot1 := getExpectedRoot(testBuffer) require.Equal(t, expectedRoot1, mt.ComputeRoot()) @@ -96,7 +96,7 @@ func TestMerkleTreeAppendLeafWithLowMaxDepth(t *testing.T) { }, nil) // Test AppendLeaf mt.AppendLeaf() - testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) + testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) //nolint:makezero testBuffer[128] = 5 expectedRoot := getExpectedRoot(testBuffer) require.Equal(t, expectedRoot, mt.ComputeRoot()) @@ -136,7 +136,7 @@ func TestMerkleTreeAppendLeafWithLowMaxDepthAndLimitAndTestWR(t *testing.T) { }, &lm) // Test AppendLeaf mt.AppendLeaf() - testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) + testBuffer = append(testBuffer, make([]byte, 4*length.Hash)...) //nolint:makezero testBuffer[128] = 5 expectedRoot := getExpectedRootWithLimit(testBuffer, int(lm)) require.Equal(t, expectedRoot, mt.ComputeRoot()) diff --git a/cl/p2p/p2p_localnode.go b/cl/p2p/p2p_localnode.go index 880688a84a7..d817c332ca4 100644 --- a/cl/p2p/p2p_localnode.go +++ b/cl/p2p/p2p_localnode.go @@ -95,7 +95,7 @@ func detectOutboundIP(unspecified net.IP) net.IP { if unspecified.To4() == nil { network, target = "udp6", "[2001:4860:4860::8888]:80" } - conn, err := net.Dial(network, target) + conn, err := net.Dial(network, target) //nolint:noctx if err != nil { return nil } diff --git a/cl/p2p/p2p_test.go b/cl/p2p/p2p_test.go index 4ec0b83c103..72388e8bf07 100644 --- a/cl/p2p/p2p_test.go +++ b/cl/p2p/p2p_test.go @@ -33,7 +33,8 @@ func TestHostTCPPortReturnsBoundPort(t *testing.T) { port := hostTCPPort(host) require.NotZero(t, port) - conn, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", port)) + var dialer net.Dialer + conn, err := dialer.DialContext(t.Context(), "tcp", fmt.Sprintf("127.0.0.1:%d", port)) require.NoError(t, err) conn.Close() } diff --git a/cl/persistence/base_encoding/uint64_diff.go b/cl/persistence/base_encoding/uint64_diff.go index b7f20a1636e..7f49e4c22e4 100644 --- a/cl/persistence/base_encoding/uint64_diff.go +++ b/cl/persistence/base_encoding/uint64_diff.go @@ -262,7 +262,7 @@ func ApplyCompressedSerializedValidatorListDiff(in, out []byte, diff []byte, rev if n != validatorSSZSize { return nil, fmt.Errorf("read %d bytes, expected %d", n, validatorSSZSize) } - out = append(out, currValidator...) + out = append(out, currValidator...) //nolint:makezero } return out, nil diff --git a/cl/persistence/state/historical_states_reader/gloas_roundtrip_test.go b/cl/persistence/state/historical_states_reader/gloas_roundtrip_test.go index 5513c86fe00..96a8195717f 100644 --- a/cl/persistence/state/historical_states_reader/gloas_roundtrip_test.go +++ b/cl/persistence/state/historical_states_reader/gloas_roundtrip_test.go @@ -476,7 +476,7 @@ func TestReadHistoricalState_GloasFieldsReconstruction(t *testing.T) { slot := cfg.SlotsPerEpoch // = 32 // ---- Genesis state (mainnet has real validators) ---- - genesisState, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesisState, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) numValidators := uint64(genesisState.ValidatorLength()) diff --git a/cl/persistence/state/historical_states_reader/missing_history_vector_test.go b/cl/persistence/state/historical_states_reader/missing_history_vector_test.go index dd95e163ad1..73b6435c844 100644 --- a/cl/persistence/state/historical_states_reader/missing_history_vector_test.go +++ b/cl/persistence/state/historical_states_reader/missing_history_vector_test.go @@ -40,7 +40,7 @@ func TestReadHistoryHashVector_MissingEntryIsTyped(t *testing.T) { const size = uint64(64) const slot = 2 * size // needFromGenesis=0; window [slot-size, slot-1] - genesisState, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesisState, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) for _, tc := range []struct { @@ -85,7 +85,7 @@ func TestReadHistoryHashVector_CorruptEntryIsHardError(t *testing.T) { const slot = 2 * size const corruptAt = slot - size/2 - genesisState, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesisState, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) db := memdb.NewTestDB(t, dbcfg.ChainDB) diff --git a/cl/persistence/state/slot_data_test.go b/cl/persistence/state/slot_data_test.go index 61c7f7c320d..13164fe41a0 100644 --- a/cl/persistence/state/slot_data_test.go +++ b/cl/persistence/state/slot_data_test.go @@ -32,7 +32,7 @@ import ( ) func TestSlotData(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) m := &SlotData{ Version: clparams.ElectraVersion, @@ -61,7 +61,7 @@ func TestSlotData(t *testing.T) { } func TestSlotDataGloas(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) m := &SlotData{ Version: clparams.GloasVersion, @@ -89,7 +89,7 @@ func TestSlotDataGloas(t *testing.T) { } func TestSlotDataGloasDefaultHash(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) // Test with zero-value hash to ensure it round-trips correctly m := &SlotData{ @@ -121,7 +121,7 @@ func TestSlotDataGloasDefaultHash(t *testing.T) { // correctly when all fields carry non-trivial values (including Eth1Data with // non-zero sub-fields and large uint64 values). func TestSlotDataGloasAllFieldsNonZero(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) m := &SlotData{ @@ -168,7 +168,7 @@ func TestSlotDataGloasAllFieldsNonZero(t *testing.T) { // populated on the struct, they are NOT included in the serialized form. // After deserialization, the GLOAS fields must be zero-valued. func TestSlotDataPreGloasDoesNotIncludeGloasFields(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) for _, version := range []clparams.StateVersion{ @@ -253,7 +253,7 @@ func TestSlotDataGloasEncodesMoreBytesThanElectra(t *testing.T) { // mock GetValFn that simulates reading from the kv.SlotData table. This tests // the integration between WriteTo, ReadSlotData, and the SlotData DB encoding. func TestSlotDataReadSlotDataRoundTrip(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) testCases := []struct { @@ -326,7 +326,7 @@ func TestSlotDataReadSlotDataRoundTrip(t *testing.T) { // TestSlotDataReadSlotDataPreGloasReturnsZeroGloasFields reads an Electra SlotData // via ReadSlotData and confirms the GLOAS fields are zero. func TestSlotDataReadSlotDataPreGloasReturnsZeroGloasFields(t *testing.T) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) m := &SlotData{ diff --git a/cl/phase1/forkchoice/fork_choice_test.go b/cl/phase1/forkchoice/fork_choice_test.go index 16260bb914a..5be05f13392 100644 --- a/cl/phase1/forkchoice/fork_choice_test.go +++ b/cl/phase1/forkchoice/fork_choice_test.go @@ -88,7 +88,7 @@ func TestForkChoiceBasic(t *testing.T) { emitters := beaconevents.NewEventEmitter() // Create required components - genesisState, err := initial_state.GetGenesisState(1) // Mainnet + genesisState, err := initial_state.GetGenesisState(t.Context(), 1) // Mainnet require.NoError(t, err) ethClock := eth_clock.NewEthereumClock(genesisState.GenesisTime(), genesisState.GenesisValidatorsRoot(), &clparams.MainnetBeaconConfig) blobStorage := blob_storage.NewBlobStore(memdb.NewTestDB(t, dbcfg.ChainDB), afero.NewMemMapFs(), math.MaxUint64, &clparams.MainnetBeaconConfig, ethClock) @@ -184,7 +184,7 @@ func TestForkChoiceChainBellatrix(t *testing.T) { sd := synced_data.NewSyncedDataManager(&clparams.MainnetBeaconConfig, true) // Create required components - genesisState, err := initial_state.GetGenesisState(1) // Mainnet + genesisState, err := initial_state.GetGenesisState(t.Context(), 1) // Mainnet require.NoError(t, err) ethClock := eth_clock.NewEthereumClock(genesisState.GenesisTime(), genesisState.GenesisValidatorsRoot(), &clparams.MainnetBeaconConfig) blobStorage := blob_storage.NewBlobStore(memdb.NewTestDB(t, dbcfg.ChainDB), afero.NewMemMapFs(), math.MaxUint64, &clparams.MainnetBeaconConfig, ethClock) diff --git a/cl/phase1/forkchoice/weight_store_diff_test.go b/cl/phase1/forkchoice/weight_store_diff_test.go index 1787283e4e3..56f63f0ab03 100644 --- a/cl/phase1/forkchoice/weight_store_diff_test.go +++ b/cl/phase1/forkchoice/weight_store_diff_test.go @@ -81,7 +81,7 @@ func buildExAnteStore(tb testing.TB) *ForkChoiceStore { anchor := state2.New(cfg) require.NoError(tb, utils.DecodeSSZSnappy(anchor, diffAnchorEnc, int(clparams.AltairVersion))) em := beaconevents.NewEventEmitter() - gs, err := initial_state.GetGenesisState(1) + gs, err := initial_state.GetGenesisState(tb.Context(), 1) require.NoError(tb, err) clk := eth_clock.NewEthereumClock(gs.GenesisTime(), gs.GenesisValidatorsRoot(), cfg) bs := blob_storage.NewBlobStore(memdb.NewTestDB(tb, dbcfg.ChainDB), afero.NewMemMapFs(), math.MaxUint64, cfg, clk) diff --git a/cl/sentinel/discovery.go b/cl/sentinel/discovery.go index 4dd806acd37..71f6717ab6b 100644 --- a/cl/sentinel/discovery.go +++ b/cl/sentinel/discovery.go @@ -579,7 +579,7 @@ func (s *Sentinel) onConnection(_ network.Network, conn network.Conn) { return } - valid, err := s.handshaker.ValidatePeer(peerId) + valid, err := s.handshaker.ValidatePeer(s.ctx, peerId) if err != nil { // Handshake transport error (stream reset, timeout, etc.) — keep the peer. // The peer may still work for gossip even if status exchange failed. diff --git a/cl/sentinel/handlers/execution_payload_envelopes_test.go b/cl/sentinel/handlers/execution_payload_envelopes_test.go index a88b8247e12..4659c68287e 100644 --- a/cl/sentinel/handlers/execution_payload_envelopes_test.go +++ b/cl/sentinel/handlers/execution_payload_envelopes_test.go @@ -31,7 +31,7 @@ import ( // getGloasEthClockAndConfig returns an EthereumClock and BeaconChainConfig // with all fork epochs set to 0, so that GLOAS is active from the start. func getGloasEthClockAndConfig(t *testing.T) (eth_clock.EthereumClock, *clparams.BeaconChainConfig) { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) cfg := s.BeaconConfig() diff --git a/cl/sentinel/handlers/test_helpers.go b/cl/sentinel/handlers/test_helpers.go index 344c066d694..611f065da34 100644 --- a/cl/sentinel/handlers/test_helpers.go +++ b/cl/sentinel/handlers/test_helpers.go @@ -10,7 +10,7 @@ import ( ) func getEthClock(t *testing.T) eth_clock.EthereumClock { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) return eth_clock.NewEthereumClock(s.GenesisTime(), s.GenesisValidatorsRoot(), s.BeaconConfig()) } diff --git a/cl/sentinel/handshake/handshake.go b/cl/sentinel/handshake/handshake.go index 327d0dbe077..035bd23d76b 100644 --- a/cl/sentinel/handshake/handshake.go +++ b/cl/sentinel/handshake/handshake.go @@ -125,7 +125,7 @@ func (h *HandShaker) IsSet() bool { return h.set } -func (h *HandShaker) ValidatePeer(id peer.ID) (bool, error) { +func (h *HandShaker) ValidatePeer(ctx context.Context, id peer.ID) (bool, error) { // Always validate fork digest — the constructor initialises it from // ethClock, so we can reject wrong-network peers even before the CL // stages call SetStatus with finalized/head info. @@ -155,7 +155,7 @@ func (h *HandShaker) ValidatePeer(id peer.ID) (bool, error) { if err := ssz_snappy.EncodeAndWrite(buf, status); err != nil { return false, err } - req, err := http.NewRequest("GET", "http://service.internal/", buf) + req, err := http.NewRequestWithContext(ctx, "GET", "http://service.internal/", buf) if err != nil { return false, err } diff --git a/cl/sentinel/httpreqresp/server_test.go b/cl/sentinel/httpreqresp/server_test.go index 9807951e8d1..9d7bf48df55 100644 --- a/cl/sentinel/httpreqresp/server_test.go +++ b/cl/sentinel/httpreqresp/server_test.go @@ -139,7 +139,7 @@ func TestDoCopiesHandlerWriteBuffer(t *testing.T) { _, _ = w.Write(buf) copy(buf, "XXXXX") // simulate fmt reusing its pooled buffer after Write returns }) - req, err := http.NewRequest("GET", "http://service.internal/", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), "GET", "http://service.internal/", http.NoBody) require.NoError(t, err) resp, err := Do(h, req) require.NoError(t, err) @@ -199,7 +199,7 @@ func TestDoRecoversHandlerPanic(t *testing.T) { h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { panic("boom") }) - req, err := http.NewRequest("GET", "http://service.internal/", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), "GET", "http://service.internal/", http.NoBody) require.NoError(t, err) resp, err := Do(h, req) require.NoError(t, err) @@ -227,7 +227,7 @@ func TestDoThroughChiRouterPreservesStreamingHandoff(t *testing.T) { mux := chi.NewRouter() mux.Get("/", h) - req, err := http.NewRequest("GET", "http://service.internal/", http.NoBody) + req, err := http.NewRequestWithContext(t.Context(), "GET", "http://service.internal/", http.NoBody) require.NoError(t, err) resp, err := Do(mux, req) require.NoError(t, err) diff --git a/cl/sentinel/sentinel_requests_test.go b/cl/sentinel/sentinel_requests_test.go index 2194fd6ebc3..f72468d88ef 100644 --- a/cl/sentinel/sentinel_requests_test.go +++ b/cl/sentinel/sentinel_requests_test.go @@ -98,7 +98,7 @@ func retryTestFunc(t *testing.T, maxRetries int, fn func()) { } func getEthClock(t *testing.T) eth_clock.EthereumClock { - s, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + s, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) noErr(err) return eth_clock.NewEthereumClock(s.GenesisTime(), s.GenesisValidatorsRoot(), s.BeaconConfig()) } diff --git a/cl/sentinel/service/service.go b/cl/sentinel/service/service.go index a82c10b158d..ad7eef7920e 100644 --- a/cl/sentinel/service/service.go +++ b/cl/sentinel/service/service.go @@ -90,7 +90,7 @@ func (s *SentinelServer) SubscribeGossip(data *sentinelproto.SubscriptionData, s func (s *SentinelServer) requestPeer(ctx context.Context, pid peer.ID, req *sentinelproto.RequestData) (*sentinelproto.ResponseData, error) { // prepare the http request - httpReq, err := http.NewRequest("GET", "http://service.internal/", bytes.NewBuffer(req.Data)) + httpReq, err := http.NewRequestWithContext(ctx, "GET", "http://service.internal/", bytes.NewBuffer(req.Data)) if err != nil { return nil, err } diff --git a/cl/sentinel/service/start.go b/cl/sentinel/service/start.go index dd5cf77a596..bf9c3ee0e53 100644 --- a/cl/sentinel/service/start.go +++ b/cl/sentinel/service/start.go @@ -134,7 +134,7 @@ func StartServe( srvCfg *ServerConfig, creds credentials.TransportCredentials, ) { - lis, err := net.Listen(srvCfg.Network, srvCfg.Addr) + lis, err := net.Listen(srvCfg.Network, srvCfg.Addr) //nolint:noctx if err != nil { log.Warn("[Sentinel] could not serve service", "reason", err) return diff --git a/cl/spectest/consensus_tests/fork_choice.go b/cl/spectest/consensus_tests/fork_choice.go index 34371ac8fdb..3bd62d16519 100644 --- a/cl/spectest/consensus_tests/fork_choice.go +++ b/cl/spectest/consensus_tests/fork_choice.go @@ -303,7 +303,7 @@ func (b *ForkChoice) Run(t *testing.T, root fs.FS, c spectest.TestCase) (err err anchorState, err := spectest.ReadBeaconState(root, c.Version(), "anchor_state.ssz_snappy") require.NoError(t, err) - genesisState, err := initial_state.GetGenesisState(chainspec.MainnetChainID) + genesisState, err := initial_state.GetGenesisState(t.Context(), chainspec.MainnetChainID) require.NoError(t, err) emitters := beaconevents.NewEventEmitter() diff --git a/cmd/capcli/cli.go b/cmd/capcli/cli.go index 47b55dd035a..c68d7b93c13 100644 --- a/cmd/capcli/cli.go +++ b/cmd/capcli/cli.go @@ -691,7 +691,7 @@ func (r *RetrieveHistoricalState) Run(ctx *Context) error { return err } snr := freezeblocks.NewBeaconSnapshotReader(csn, eth1Getter, beaconConfig) - gSpot, err := initial_state.GetGenesisState(t) + gSpot, err := initial_state.GetGenesisState(context.Background(), t) if err != nil { return err } @@ -813,9 +813,9 @@ type ArchiveSanitizer struct { FaultOut string `help:"fault out" default:""` } -func getHead(beaconApiURL string) (uint64, error) { +func getHead(ctx context.Context, beaconApiURL string) (uint64, error) { headResponse := map[string]any{} - req, err := http.NewRequest("GET", beaconApiURL+"/eth/v2/debug/beacon/heads", nil) + req, err := http.NewRequestWithContext(ctx, "GET", beaconApiURL+"/eth/v2/debug/beacon/heads", nil) if err != nil { return 0, err } @@ -844,9 +844,9 @@ func getHead(beaconApiURL string) (uint64, error) { return slot, nil } -func getStateRootAtSlot(beaconApiURL string, slot uint64) (common.Hash, error) { +func getStateRootAtSlot(ctx context.Context, beaconApiURL string, slot uint64) (common.Hash, error) { response := map[string]any{} - req, err := http.NewRequest("GET", fmt.Sprintf("%s/eth/v1/beacon/states/%d/root", beaconApiURL, slot), nil) + req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/eth/v1/beacon/states/%d/root", beaconApiURL, slot), nil) if err != nil { return common.Hash{}, err } @@ -912,13 +912,13 @@ func (a *ArchiveSanitizer) Run(ctx *Context) error { log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StderrHandler)) // retrieve the head slot first through /eth/v2/debug/beacon/heads - headSlot, err := getHead(a.BeaconApiURL) + headSlot, err := getHead(ctx, a.BeaconApiURL) if err != nil { return err } for i := a.StartSlot; i < headSlot; i += a.IntervalSlot { // retrieve the state root at slot i and skip if not found (can happen) - stateRoot, err := getStateRootAtSlot(a.BeaconApiURL, i) + stateRoot, err := getStateRootAtSlot(ctx, a.BeaconApiURL, i) if err != nil { return err } @@ -969,7 +969,7 @@ func (b *BenchmarkNode) Run(ctx *Context) error { log.Root().SetHandler(log.LvlFilterHandler(log.LvlDebug, log.StderrHandler)) // retrieve the head slot first through /eth/v2/debug/beacon/heads - headSlot, err := getHead(b.BaseURL) + headSlot, err := getHead(ctx, b.BaseURL) if err != nil { return err } @@ -994,7 +994,7 @@ func (b *BenchmarkNode) Run(ctx *Context) error { uri := b.BaseURL + b.Endpoint uri = strings.Replace(uri, "{slot}", strconv.FormatUint(i, 10), 1) uri = strings.Replace(uri, "{epoch}", strconv.FormatUint(i/beaconConfig.SlotsPerEpoch, 10), 1) - elapsed, err := timeRequest(uri, b.Accept, b.Method, b.Body) + elapsed, err := timeRequest(ctx, uri, b.Accept, b.Method, b.Body) if err != nil { log.Warn("Failed to benchmark", "error", err, "uri", uri) continue @@ -1008,8 +1008,8 @@ func (b *BenchmarkNode) Run(ctx *Context) error { return nil } -func timeRequest(uri, accept, method, body string) (time.Duration, error) { - req, err := http.NewRequest(method, uri, nil) +func timeRequest(ctx context.Context, uri, accept, method, body string) (time.Duration, error) { + req, err := http.NewRequestWithContext(ctx, method, uri, nil) if err != nil { return 0, err } diff --git a/cmd/caplin/caplin1/run.go b/cmd/caplin/caplin1/run.go index a744357bc8e..8d936caea4d 100644 --- a/cmd/caplin/caplin1/run.go +++ b/cmd/caplin/caplin1/run.go @@ -21,6 +21,7 @@ import ( "errors" "fmt" "math" + "net/http" "os" "path" "time" @@ -247,7 +248,7 @@ func RunCaplinService(ctx context.Context, engine execution_client.ExecutionEngi // If genesis state is provided and is hardcoded, use it if initial_state.IsGenesisStateSupported(config.NetworkId) && !isGenesisDBInitialized { - genesisState, err = initial_state.GetGenesisState(config.NetworkId) + genesisState, err = initial_state.GetGenesisState(ctx, config.NetworkId) if err != nil { return err } @@ -623,9 +624,13 @@ func RunCaplinService(ctx context.Context, engine execution_client.ExecutionEngi payloadAttestationService, proposerPreferencesService, ) - go beacon.ListenAndServe(&beacon.LayeredBeaconHandler{ - ArchiveApi: apiHandler, - }, config.BeaconAPIRouter) + go func() { + if err := beacon.ListenAndServe(ctx, &beacon.LayeredBeaconHandler{ + ArchiveApi: apiHandler, + }, config.BeaconAPIRouter); err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Warn("[Beacon API] error serving", "err", err) + } + }() log.Info("Beacon API started", "addr", config.BeaconAPIRouter.Address) } diff --git a/cmd/downloader/main.go b/cmd/downloader/main.go index 07fcfc3b0ea..08044e2dce8 100644 --- a/cmd/downloader/main.go +++ b/cmd/downloader/main.go @@ -373,7 +373,7 @@ func Downloader(cmd *cobra.Command, logger log.Logger) error { } } - grpcServer, err := StartGrpc(bittorrentServer, downloaderApiAddr, nil /* transportCredentials */, logger) + grpcServer, err := StartGrpc(ctx, bittorrentServer, downloaderApiAddr, nil /* transportCredentials */, logger) if err != nil { return err } @@ -754,13 +754,13 @@ func doDiffTorrentHashes(ctx context.Context, local map[string]string) error { return nil } -func StartGrpc(snServer *downloader.GrpcServer, addr string, creds credentials.TransportCredentials, logger log.Logger) (*grpc.Server, error) { +func StartGrpc(ctx context.Context, snServer *downloader.GrpcServer, addr string, creds credentials.TransportCredentials, logger log.Logger) (*grpc.Server, error) { grpcServer := grpcutil.NewServerWithOpts(creds) if snServer != nil { downloaderproto.RegisterDownloaderServer(grpcServer, snServer) } - if err := grpcutil.StartServer(grpcServer, addr, true, logger, "gRPC server stop"); err != nil { + if err := grpcutil.StartServer(ctx, grpcServer, addr, true, logger, "gRPC server stop"); err != nil { return nil, err } logger.Info("Started gRPC server", "on", addr) diff --git a/cmd/evm/reporter.go b/cmd/evm/reporter.go index 4e0fbd1b88c..ebf21de81c8 100644 --- a/cmd/evm/reporter.go +++ b/cmd/evm/reporter.go @@ -66,8 +66,9 @@ func (r testResult) String() string { out := fmt.Sprintf("%s %s%s", status, r.Name, extra) if r.State != nil { - state, _ := json.MarshalIndent(r.State, "", " ") - out += "\n" + string(state) + if state, err := json.MarshalIndent(r.State, "", " "); err == nil { + out += "\n" + string(state) + } } return out } @@ -79,7 +80,7 @@ func report(ctx *cli.Command, results []testResult) { // MarshalIndent -> string -> Println allocation chain. enc := json.NewEncoder(os.Stdout) enc.SetIndent("", " ") - enc.Encode(results) //nolint:errcheck + _ = enc.Encode(results) //nolint:errcheck,errchkjson return } pass := 0 diff --git a/cmd/mcp/main.go b/cmd/mcp/main.go index a7cef443059..77bf52a2c94 100644 --- a/cmd/mcp/main.go +++ b/cmd/mcp/main.go @@ -129,7 +129,7 @@ Examples: url = fmt.Sprintf("http://127.0.0.1:%d", port) } else { // Auto-discover: probe default ports. - if discovered := autoDiscover(logger); discovered != "" { + if discovered := autoDiscover(ctx, logger); discovered != "" { url = discovered } } @@ -193,11 +193,14 @@ func serve(ctx context.Context, srv *mcpserver.ErigonMCPServer, transport, sseAd } // autoDiscover probes localhost on well-known JSON-RPC ports. -func autoDiscover(logger log.Logger) string { +func autoDiscover(ctx context.Context, logger log.Logger) string { logger.Info("[MCP] Auto-discovering Erigon JSON-RPC endpoint...") + var dialer net.Dialer for _, p := range defaultRPCPorts { addr := fmt.Sprintf("127.0.0.1:%d", p) - conn, err := net.DialTimeout("tcp", addr, 500*time.Millisecond) + dialCtx, cancel := context.WithTimeout(ctx, 500*time.Millisecond) + conn, err := dialer.DialContext(dialCtx, "tcp", addr) + cancel() if err == nil { conn.Close() url := fmt.Sprintf("http://%s", addr) diff --git a/cmd/rpcdaemon/cli/config.go b/cmd/rpcdaemon/cli/config.go index bc65c7bcaea..5846b5a8335 100644 --- a/cmd/rpcdaemon/cli/config.go +++ b/cmd/rpcdaemon/cli/config.go @@ -749,7 +749,7 @@ func startRegularRpcServer(ctx context.Context, cfg *httpcfg.HttpCfg, rpcAPI []r if err != nil { return fmt.Errorf("malformatted socket url %s: %w", cfg.SocketListenUrl, err) } - tcpListener, err := net.Listen(socketUrl.Scheme, socketUrl.Host+socketUrl.EscapedPath()) + tcpListener, err := net.Listen(socketUrl.Scheme, socketUrl.Host+socketUrl.EscapedPath()) //nolint:noctx if err != nil { return fmt.Errorf("could not start Socket Listener: %w", err) } @@ -872,7 +872,7 @@ func startRegularRpcServer(ctx context.Context, cfg *httpcfg.HttpCfg, rpcAPI []r ) if cfg.GRPCServerEnabled { grpcEndpoint = fmt.Sprintf("%s:%d", cfg.GRPCListenAddress, cfg.GRPCPort) - if grpcListener, err = net.Listen("tcp", grpcEndpoint); err != nil { + if grpcListener, err = net.Listen("tcp", grpcEndpoint); err != nil { //nolint:noctx return fmt.Errorf("could not start GRPC listener: %w", err) } grpcServer = grpc.NewServer() diff --git a/cmd/rpcdaemon/cli/config_test.go b/cmd/rpcdaemon/cli/config_test.go index 2c6105c669e..6d6634b6056 100644 --- a/cmd/rpcdaemon/cli/config_test.go +++ b/cmd/rpcdaemon/cli/config_test.go @@ -33,7 +33,7 @@ import ( // TestIsWebsocket tests if an incoming websocket upgrade request is detected properly. func TestIsWebsocket(t *testing.T) { - r, _ := http.NewRequest("GET", "/", nil) + r, _ := http.NewRequestWithContext(t.Context(), "GET", "/", nil) require.False(t, isWebsocket(r)) r.Header.Set("upgrade", "websocket") diff --git a/cmd/rpcdaemon/graphql/graphql_test.go b/cmd/rpcdaemon/graphql/graphql_test.go index 03cdc9793cd..87f4c7ec0d4 100644 --- a/cmd/rpcdaemon/graphql/graphql_test.go +++ b/cmd/rpcdaemon/graphql/graphql_test.go @@ -29,7 +29,7 @@ func TestGraphQLQueryBlock(t *testing.T) { // Probe the GraphQL endpoint itself (not just the TCP port) so the test skips // cleanly unless a rpcdaemon with GraphQL enabled is actually answering. const endpoint = "http://localhost:8545/graphql" - probe, err := (&http.Client{Timeout: time.Second}).Post(endpoint, "application/json", strings.NewReader(`{"query":"{chainID}","variables":null}`)) + probe, err := (&http.Client{Timeout: time.Second}).Post(endpoint, "application/json", strings.NewReader(`{"query":"{chainID}","variables":null}`)) //nolint:noctx if err != nil { t.Skipf("requires a running rpcdaemon with GraphQL at %s: %v", endpoint, err) } @@ -146,7 +146,7 @@ func TestGraphQLQueryBlock(t *testing.T) { }, */ } { - resp, err := http.Post("http://localhost:8545/graphql", "application/json", strings.NewReader(tt.body)) + resp, err := http.Post("http://localhost:8545/graphql", "application/json", strings.NewReader(tt.body)) //nolint:noctx if err != nil { t.Fatalf("could not post: %v", err) } diff --git a/cmd/rpcdaemon/health/health_test.go b/cmd/rpcdaemon/health/health_test.go index ea40df7cb08..c8e813d1b5f 100644 --- a/cmd/rpcdaemon/health/health_test.go +++ b/cmd/rpcdaemon/health/health_test.go @@ -352,7 +352,7 @@ func TestProcessHealthcheckIfNeeded_HeadersTests(t *testing.T) { for idx, c := range cases { w := httptest.NewRecorder() - r, err := http.NewRequest(http.MethodGet, "http://localhost:9090/health", nil) + r, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://localhost:9090/health", nil) if err != nil { t.Errorf("%v: creating request: %v", idx, err) } @@ -516,7 +516,7 @@ func TestProcessHealthcheckIfNeeded_RequestBody(t *testing.T) { for idx, c := range cases { w := httptest.NewRecorder() - r, err := http.NewRequest(http.MethodGet, "http://localhost:9090/health", nil) + r, err := http.NewRequest(http.MethodGet, "http://localhost:9090/health", nil) //nolint:noctx if err != nil { t.Errorf("%v: creating request: %v", idx, err) } diff --git a/cmd/rpctest/rpctest/utils.go b/cmd/rpctest/rpctest/utils.go index 79c70ab478d..9979b865a43 100644 --- a/cmd/rpctest/rpctest/utils.go +++ b/cmd/rpctest/rpctest/utils.go @@ -709,7 +709,7 @@ func post(client *http.Client, url, request string, response any) error { //fmt.Printf("Request=%s\n", request) //log.Info("Getting", "url", url, "request", request) //start := time.Now() - r, err := client.Post(url, "application/json", strings.NewReader(request)) + r, err := client.Post(url, "application/json", strings.NewReader(request)) //nolint:noctx if err != nil { return err } @@ -733,7 +733,7 @@ func post2(client *http.Client, url, request string) ([]byte, *fastjson.Value, e //fmt.Printf("Request=%s\n", request) //log.Info("Getting", "url", url, "request", request) //start := time.Now() - r, err := client.Post(url, "application/json", strings.NewReader(request)) + r, err := client.Post(url, "application/json", strings.NewReader(request)) //nolint:noctx if err != nil { return nil, nil, err } @@ -756,7 +756,7 @@ func post2(client *http.Client, url, request string) ([]byte, *fastjson.Value, e } func printRPCRequest(client *http.Client, url, request string) { - r, err := client.Post(url, "application/json", strings.NewReader(request)) + r, err := client.Post(url, "application/json", strings.NewReader(request)) //nolint:noctx if err != nil { fmt.Printf("Could not print: %v\n", err) return diff --git a/cmd/txnbench/internal/rpcclient/client.go b/cmd/txnbench/internal/rpcclient/client.go index d41dd994e48..08a7ebd4310 100644 --- a/cmd/txnbench/internal/rpcclient/client.go +++ b/cmd/txnbench/internal/rpcclient/client.go @@ -43,7 +43,10 @@ type rpcResp[T any] struct { } func (c *Client) Call(ctx context.Context, method string, params any, out any) error { - body, _ := json.Marshal(rpcReq{JsonRPC: "2.0", ID: 1, Method: method, Params: params}) + body, err := json.Marshal(rpcReq{JsonRPC: "2.0", ID: 1, Method: method, Params: params}) + if err != nil { + return err + } req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.url, bytes.NewReader(body)) if err != nil { return err diff --git a/cmd/txpool/main.go b/cmd/txpool/main.go index bbdaab4034e..8ac7c27d398 100644 --- a/cmd/txpool/main.go +++ b/cmd/txpool/main.go @@ -202,7 +202,7 @@ func doTxpool(ctx context.Context, logger log.Logger) error { } miningGrpcServer := privateapi.NewMiningServer(ctx, &rpcdaemontest.IsMiningMock{}, nil, logger) - grpcServer, err := txpool.StartGrpc(txpoolGrpcServer, miningGrpcServer, txpoolApiAddr, nil, logger) + grpcServer, err := txpool.StartGrpc(ctx, txpoolGrpcServer, miningGrpcServer, txpoolApiAddr, nil, logger) if err != nil { return err } diff --git a/cmd/utils/cmdtest/test_cmd.go b/cmd/utils/cmdtest/test_cmd.go index b800c2f250d..3ea43c994bd 100644 --- a/cmd/utils/cmdtest/test_cmd.go +++ b/cmd/utils/cmdtest/test_cmd.go @@ -142,7 +142,7 @@ func (tt *TestCmd) matchExactOutput(want []byte) error { if n < len(want) || !bytes.Equal(buf, want) { // Grab any additional buffered output in case of mismatch // because it might help with debugging. - buf = append(buf, make([]byte, tt.stdout.Buffered())...) + buf = append(buf, make([]byte, tt.stdout.Buffered())...) //nolint:makezero tt.stdout.Read(buf[n:]) // Find the mismatch position. for i := 0; i < n; i++ { diff --git a/common/freeport/free_port.go b/common/freeport/free_port.go index 3cb2a3c636e..58fa837c2de 100644 --- a/common/freeport/free_port.go +++ b/common/freeport/free_port.go @@ -58,7 +58,7 @@ func NextFreePort() (int, error) { } portNum = nextPortNum(portNum) - listener, err := net.Listen("tcp", "127.0.0.1:"+strconv.FormatInt(portNum, 10)) + listener, err := net.Listen("tcp", "127.0.0.1:"+strconv.FormatInt(portNum, 10)) //nolint:noctx if err != nil { continue } diff --git a/db/etl/etl_test.go b/db/etl/etl_test.go index 74d4b6ca973..35b9a262bdf 100644 --- a/db/etl/etl_test.go +++ b/db/etl/etl_test.go @@ -1497,7 +1497,7 @@ func TestVmtouchMmap(t *testing.T) { vmtouch := func(label string) { fmt.Printf("\n=== %s ===\n", label) - cmd := exec.Command("vmtouch", "-v", fname) + cmd := exec.Command("vmtouch", "-v", fname) //nolint:noctx cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr cmd.Run() diff --git a/db/kv/temporal/kv_temporal_test.go b/db/kv/temporal/kv_temporal_test.go index 37884f86bac..aa54c66b630 100644 --- a/db/kv/temporal/kv_temporal_test.go +++ b/db/kv/temporal/kv_temporal_test.go @@ -82,7 +82,7 @@ func TestTemporalTx_HasPrefix_StorageDomain(t *testing.T) { require.Equal(t, append(append([]byte{}, acc1[:]...), acc1slot1[:]...), k) wantValueBytes := make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(1)) // step num - wantValueBytes = append(wantValueBytes, byte(1)) // value we wrote to the storage slot + wantValueBytes = append(wantValueBytes, byte(1)) //nolint:makezero // value we wrote to the storage slot require.Equal(t, wantValueBytes, v) k, v, err = c1.Next() require.NoError(t, err) @@ -152,7 +152,7 @@ func TestTemporalTx_HasPrefix_StorageDomain(t *testing.T) { require.Equal(t, append(append([]byte{}, acc2[:]...), acc2slot2[:]...), k) wantValueBytes := make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(2)) // step num - wantValueBytes = append(wantValueBytes, byte(2)) // value we wrote to the storage slot + wantValueBytes = append(wantValueBytes, byte(2)) //nolint:makezero // value we wrote to the storage slot require.Equal(t, wantValueBytes, v) k, v, err = c2.Next() // acc1 storage from step 1 must not be there require.NoError(t, err) diff --git a/db/state/domain.go b/db/state/domain.go index 9290270633d..a974b68c65e 100644 --- a/db/state/domain.go +++ b/db/state/domain.go @@ -1398,7 +1398,7 @@ func (dt *DomainRoTx) unwind(ctx context.Context, rwTx kv.RwTx, step, txNumUnwin // returns the smallest. nil = different step, skip; []byte{} = absent, write tombstone. lastForKey := i+1 == len(domainDiffs) || domainDiffs[i+1].Key[:len(domainDiffs[i+1].Key)-8] != keyStr[:len(keyStr)-8] if value != nil && lastForKey { - if err := valsCursor.Put(fullKey, append(unwindStepBytes, value...)); err != nil { + if err := valsCursor.Put(fullKey, append(unwindStepBytes, value...)); err != nil { //nolint:makezero return err } } diff --git a/db/state/execctx/domain_shared_test.go b/db/state/execctx/domain_shared_test.go index 0e6969625d8..140fba04b2b 100644 --- a/db/state/execctx/domain_shared_test.go +++ b/db/state/execctx/domain_shared_test.go @@ -997,7 +997,7 @@ func TestSharedDomain_StorageIter(t *testing.T) { for locs := range 1000 { binary.BigEndian.PutUint64(l0[24:], uint64(locs)) - pv, _, err := domains.GetLatest(kv.AccountsDomain, rwTx, append(k0, l0...)) + pv, _, err := domains.GetLatest(kv.AccountsDomain, rwTx, append(k0, l0...)) //nolint:makezero require.NoError(t, err) err = domains.DomainPut(kv.StorageDomain, rwTx, composite(k0, l0), l0[24:], txNum, pv) @@ -1324,7 +1324,7 @@ func TestSharedDomain_HasPrefix_StorageDomain(t *testing.T) { require.Equal(t, append(append([]byte{}, acc1[:]...), acc1slot1[:]...), k) wantValueBytes := make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(1)) // step num - wantValueBytes = append(wantValueBytes, byte(1)) // value we wrote to the storage slot + wantValueBytes = append(wantValueBytes, byte(1)) //nolint:makezero // value we wrote to the storage slot require.Equal(t, wantValueBytes, v) k, v, err = c1.Next() require.NoError(t, err) @@ -1403,7 +1403,7 @@ func TestSharedDomain_HasPrefix_StorageDomain(t *testing.T) { require.Equal(t, append(append([]byte{}, acc2[:]...), acc2slot2[:]...), k) wantValueBytes := make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(2)) // step num - wantValueBytes = append(wantValueBytes, byte(2)) // value we wrote to the storage slot + wantValueBytes = append(wantValueBytes, byte(2)) //nolint:makezero // value we wrote to the storage slot require.Equal(t, wantValueBytes, v) k, v, err = c2.Next() // acc1 storage from step 1 must not be there require.NoError(t, err) @@ -1779,7 +1779,7 @@ func TestSharedDomain_TouchChangedKeysFromHistory(t *testing.T) { require.Equal(t, acc1Addr[:], k) wantValueBytes := make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(1)) // step num - wantValueBytes = append(wantValueBytes, acc1Encoded...) // value we wrote to the account + wantValueBytes = append(wantValueBytes, acc1Encoded...) //nolint:makezero // value we wrote to the account require.Equal(t, wantValueBytes, v) k, v, err = c1.Next() require.NoError(t, err) @@ -1793,7 +1793,7 @@ func TestSharedDomain_TouchChangedKeysFromHistory(t *testing.T) { require.Equal(t, append(append([]byte{}, acc1Addr[:]...), acc1Slot[:]...), k) wantValueBytes = make([]byte, 8) // 8 bytes for uint64 step num binary.BigEndian.PutUint64(wantValueBytes, ^uint64(1)) // step num - wantValueBytes = append(wantValueBytes, storageV1...) // value we wrote to the storage slot + wantValueBytes = append(wantValueBytes, storageV1...) //nolint:makezero // value we wrote to the storage slot require.Equal(t, wantValueBytes, v) k, v, err = c2.Next() require.NoError(t, err) diff --git a/db/test/aggregator_ext_test.go b/db/test/aggregator_ext_test.go index 17a3314572b..ef4e9c87bdd 100644 --- a/db/test/aggregator_ext_test.go +++ b/db/test/aggregator_ext_test.go @@ -103,7 +103,7 @@ func TestAggregatorV3_RestartOnFiles(t *testing.T) { err = domains.DomainPut(kv.StorageDomain, tx, composite(addr, loc), []byte{addr[0], loc[0]}, txNum, nil) require.NoError(t, err) - keys[txNum-1] = append(addr, loc...) + keys[txNum-1] = append(addr, loc...) //nolint:makezero if (txNum+1)%stepSize == 0 { trieState, err := hph.EncodeCurrentState(nil) @@ -243,7 +243,7 @@ func TestAggregatorV3_ReplaceCommittedKeys(t *testing.T) { n, err = rnd.Read(loc) require.NoError(t, err) require.Equal(t, length.Hash, n) - keys[txNum-1] = append(addr, loc...) + keys[txNum-1] = append(addr, loc...) //nolint:makezero acc := accounts.Account{ Nonce: 1, diff --git a/execution/commitment/hex_patricia_hashed_fuzz_test.go b/execution/commitment/hex_patricia_hashed_fuzz_test.go index 566678b4fd4..22444a3b528 100644 --- a/execution/commitment/hex_patricia_hashed_fuzz_test.go +++ b/execution/commitment/hex_patricia_hashed_fuzz_test.go @@ -240,7 +240,7 @@ func Fuzz_HexPatriciaHashed_ReviewKeys(f *testing.F) { addr := hex.EncodeToString(key) builder.Balance(addr, rnd.Uint64()) builder.Nonce(addr, uint64(i)) - builder.CodeHash(addr, hex.EncodeToString(append(key, make([]byte, 12)...))) + builder.CodeHash(addr, hex.EncodeToString(append(key, make([]byte, 12)...))) //nolint:makezero } t.Logf("keys count: %d", kc) diff --git a/execution/commitment/nibbles/nibbles_test.go b/execution/commitment/nibbles/nibbles_test.go index 92f98aeff27..6614af2887d 100644 --- a/execution/commitment/nibbles/nibbles_test.go +++ b/execution/commitment/nibbles/nibbles_test.go @@ -94,7 +94,7 @@ func TestHexCompactRoundtrip(t *testing.T) { // half with terminator, half without if i%2 == 0 { - hex = append(hex, Terminator) + hex = append(hex, Terminator) //nolint:makezero } compact := HexToCompact(hex) diff --git a/execution/commitment/trie/witness_marshalling.go b/execution/commitment/trie/witness_marshalling.go index dbc17576648..e281a601d80 100644 --- a/execution/commitment/trie/witness_marshalling.go +++ b/execution/commitment/trie/witness_marshalling.go @@ -238,7 +238,7 @@ func witnessKeyBytesToNibbles(b []byte) []byte { } } if hasTerminator { - return append(nibbles, 0x10) + return append(nibbles, 0x10) //nolint:makezero } return nibbles } diff --git a/execution/engineapi/engineapitester/engine_api_tester.go b/execution/engineapi/engineapitester/engine_api_tester.go index 924d410a45c..8c5431c3650 100644 --- a/execution/engineapi/engineapitester/engine_api_tester.go +++ b/execution/engineapi/engineapitester/engine_api_tester.go @@ -233,13 +233,13 @@ func InitialiseEngineApiTester(ctx context.Context, args EngineApiTesterInitArgs // happy path the http server's Shutdown closes the listener first and the // cleanup is a silent no-op. The sentry/P2P stack picks its own kernel- // assigned port directly via its config below, so no pre-bind there. - jsonRpcListener, err := net.Listen("tcp", localhostEphemeral) + jsonRpcListener, err := net.Listen("tcp", localhostEphemeral) //nolint:noctx if err != nil { return EngineApiTester{}, fmt.Errorf("listen json-rpc: %w", err) } addCleanup(closeListenerCleanup(jsonRpcListener)) jsonRpcPort := jsonRpcListener.Addr().(*net.TCPAddr).Port - engineApiListener, err := net.Listen("tcp", localhostEphemeral) + engineApiListener, err := net.Listen("tcp", localhostEphemeral) //nolint:noctx if err != nil { return EngineApiTester{}, fmt.Errorf("listen engine-api: %w", err) } diff --git a/execution/engineapi/sszrest_test.go b/execution/engineapi/sszrest_test.go index aa81d19715b..5e0bc87e264 100644 --- a/execution/engineapi/sszrest_test.go +++ b/execution/engineapi/sszrest_test.go @@ -156,7 +156,7 @@ func TestSSZRESTCapabilitiesRoute(t *testing.T) { body, err := encodeCapabilities([]string{"engine_newPayloadV1"}) require.NoError(t, err) - req := httptest.NewRequest(http.MethodPost, "/engine/v1/capabilities", bytes.NewReader(body)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/engine/v1/capabilities", bytes.NewReader(body)) rec := httptest.NewRecorder() srv.SSZRESTHandler().ServeHTTP(rec, req) @@ -197,7 +197,7 @@ func TestSSZRESTAdvertisedRoutes(t *testing.T) { {http.MethodPost, "/engine/v1/client/version", http.StatusBadRequest}, } { t.Run(route.method+" "+route.path, func(t *testing.T) { - req := httptest.NewRequest(route.method, route.path, strings.NewReader("bad-ssz")) + req := httptest.NewRequestWithContext(t.Context(), route.method, route.path, strings.NewReader("bad-ssz")) rec := httptest.NewRecorder() srv.SSZRESTHandler().ServeHTTP(rec, req) require.Equal(t, route.code, rec.Code) diff --git a/execution/state/dump.go b/execution/state/dump.go index 2ed973fdeb7..afaa425232f 100644 --- a/execution/state/dump.go +++ b/execution/state/dump.go @@ -117,14 +117,14 @@ func (d iterativeDump) OnAccount(addr common.Address, account DumpAccount) { if addr != (common.Address{}) { dumpAccount.Address = &addr } - //nolint:errcheck - d.Encode(dumpAccount) + //nolint:errcheck,errchkjson + _ = d.Encode(dumpAccount) } // OnRoot implements DumpCollector interface func (d iterativeDump) OnRoot(root common.Hash) { - //nolint:errcheck - d.Encoder.Encode(struct { + //nolint:errcheck,errchkjson + _ = d.Encoder.Encode(struct { Root common.Hash `json:"root"` }{root}) } diff --git a/execution/tracing/tracers/logger/logger_json.go b/execution/tracing/tracers/logger/logger_json.go index 702f2b7e47b..5e7e2b12989 100644 --- a/execution/tracing/tracers/logger/logger_json.go +++ b/execution/tracing/tracers/logger/logger_json.go @@ -98,7 +98,7 @@ func (l *JSONLogger) OnOpcode(pc uint64, typ byte, gas, cost uint64, scope traci if l.cfg.EnableReturnData { log.ReturnData = rData } - _ = l.encoder.Encode(log) + _ = l.encoder.Encode(log) //nolint:errchkjson } func (l *JSONLogger) OnFault(pc uint64, op byte, gas uint64, cost uint64, scope tracing.OpContext, depth int, err error) { @@ -118,5 +118,5 @@ func (l *JSONLogger) OnExit(depth int, output []byte, gasUsed uint64, err error, if err != nil { errMsg = err.Error() } - _ = l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), errMsg}) + _ = l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), errMsg}) //nolint:errchkjson } diff --git a/execution/types/encdec_test.go b/execution/types/encdec_test.go index c78577a6bdf..ad05351710b 100644 --- a/execution/types/encdec_test.go +++ b/execution/types/encdec_test.go @@ -1127,7 +1127,8 @@ func BenchmarkLogJSONUnmarshal(b *testing.B) { } log := mkLog() - encoded, _ := json.Marshal(log) + encoded, err := json.Marshal(log) + require.NoError(b, err) b.Run("Log/Single", func(b *testing.B) { b.ReportAllocs() @@ -1137,7 +1138,8 @@ func BenchmarkLogJSONUnmarshal(b *testing.B) { }) rpcLog := &RPCLog{Log: *log, BlockTimestamp: hexutil.Uint64(1700000000)} - rpcEncoded, _ := json.Marshal(rpcLog) + rpcEncoded, err := json.Marshal(rpcLog) + require.NoError(b, err) var rpcSink RPCLog b.Run("RPCLog/Single", func(b *testing.B) { b.ReportAllocs() @@ -1147,7 +1149,8 @@ func BenchmarkLogJSONUnmarshal(b *testing.B) { }) erigonLog := &ErigonLog{Log: *log, Timestamp: hexutil.Uint64(1700000000)} - erigonEncoded, _ := json.Marshal(erigonLog) + erigonEncoded, err := json.Marshal(erigonLog) + require.NoError(b, err) var erigonSink ErigonLog b.Run("ErigonLog/Single", func(b *testing.B) { b.ReportAllocs() diff --git a/node/components/sentry/provider_test.go b/node/components/sentry/provider_test.go index 56b5316125b..2e02dd65f77 100644 --- a/node/components/sentry/provider_test.go +++ b/node/components/sentry/provider_test.go @@ -17,6 +17,7 @@ package sentry import ( + "context" "net" "path/filepath" "testing" @@ -180,13 +181,18 @@ func TestProviderClose_StopsSharedP2PServer(t *testing.T) { require.NotNil(t, srv) addr := srv.NodeInfo().ListenAddr - c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond) + var dialer net.Dialer + dialCtx, dialCancel := context.WithTimeout(t.Context(), 200*time.Millisecond) + c, err := dialer.DialContext(dialCtx, "tcp", addr) + dialCancel() require.NoError(t, err, "listener should be up before Close") c.Close() require.NoError(t, p.Close()) require.Nil(t, p.sharedP2PServer, "Close must clear the shared server reference") - _, err = net.DialTimeout("tcp", addr, 200*time.Millisecond) + dialCtx2, dialCancel2 := context.WithTimeout(t.Context(), 200*time.Millisecond) + _, err = dialer.DialContext(dialCtx2, "tcp", addr) + dialCancel2() require.Error(t, err, "Provider.Close must shut the shared p2p.Server's listener down") } diff --git a/node/endpoints.go b/node/endpoints.go index d6faf7446fc..bde856437ea 100644 --- a/node/endpoints.go +++ b/node/endpoints.go @@ -60,7 +60,7 @@ func StartHTTPEndpoint(urlEndpoint string, cfg *HttpEndpointConfig, handler http if err != nil { return nil, nil, fmt.Errorf("malformed http listen url %s: %w", urlEndpoint, err) } - if listener, err = net.Listen(socketUrl.Scheme, socketUrl.Host+socketUrl.EscapedPath()); err != nil { + if listener, err = net.Listen(socketUrl.Scheme, socketUrl.Host+socketUrl.EscapedPath()); err != nil { //nolint:noctx return nil, nil, err } } diff --git a/node/eth/backend.go b/node/eth/backend.go index 4fa96ce419e..d84e930dac9 100644 --- a/node/eth/backend.go +++ b/node/eth/backend.go @@ -853,6 +853,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger } } backend.privateAPI, err = privateapi2.StartGrpc( + ctx, backend.kvRPC, backend.ethBackendRPC, backend.txPoolGrpcServer, diff --git a/node/gointerfaces/grpcutil/utils.go b/node/gointerfaces/grpcutil/utils.go index 80470508cfd..4bbfc811d81 100644 --- a/node/gointerfaces/grpcutil/utils.go +++ b/node/gointerfaces/grpcutil/utils.go @@ -97,8 +97,9 @@ func NewServerWithOpts(creds credentials.TransportCredentials, extraOpts ...grpc return grpcServer } -func StartServer(srv *grpc.Server, addr string, healthCheck bool, logger log.Logger, serveErrMsg string) error { - lis, err := net.Listen("tcp", addr) +func StartServer(ctx context.Context, srv *grpc.Server, addr string, healthCheck bool, logger log.Logger, serveErrMsg string) error { + var lc net.ListenConfig + lis, err := lc.Listen(ctx, "tcp", addr) if err != nil { return fmt.Errorf("could not create listener: %w, addr=%s", err, addr) } diff --git a/node/privateapi/all.go b/node/privateapi/all.go index 78bc4dca626..7beebb5aadb 100644 --- a/node/privateapi/all.go +++ b/node/privateapi/all.go @@ -17,6 +17,8 @@ package privateapi import ( + "context" + "google.golang.org/grpc" "google.golang.org/grpc/credentials" @@ -29,7 +31,7 @@ import ( "github.com/erigontech/erigon/polygon/heimdall" ) -func StartGrpc(kv *remotedbserver.KvServer, ethBackendSrv *EthBackendServer, txPoolServer txpoolproto.TxpoolServer, +func StartGrpc(ctx context.Context, kv *remotedbserver.KvServer, ethBackendSrv *EthBackendServer, txPoolServer txpoolproto.TxpoolServer, miningServer txpoolproto.MiningServer, bridgeServer *bridge.BackendServer, heimdallServer *heimdall.BackendServer, addr string, rateLimit uint32, creds credentials.TransportCredentials, healthCheck bool, logger log.Logger) (*grpc.Server, error) { logger.Info("Starting private RPC server", "on", addr) @@ -50,7 +52,7 @@ func StartGrpc(kv *remotedbserver.KvServer, ethBackendSrv *EthBackendServer, txP } remoteproto.RegisterKVServer(grpcServer, kv) - if err := grpcutil.StartServer(grpcServer, addr, healthCheck, logger, "private RPC server fail"); err != nil { + if err := grpcutil.StartServer(ctx, grpcServer, addr, healthCheck, logger, "private RPC server fail"); err != nil { return nil, err } return grpcServer, nil diff --git a/node/rpcstack_gzip_batch_race_test.go b/node/rpcstack_gzip_batch_race_test.go index 85eb01932e7..934698af4ff 100644 --- a/node/rpcstack_gzip_batch_race_test.go +++ b/node/rpcstack_gzip_batch_race_test.go @@ -59,7 +59,7 @@ func TestGzipHandlerBatchConcurrentStreamableFlush(t *testing.T) { } reqBody := "[" + strings.Join(calls, ",") + "]" - req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(reqBody)) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", strings.NewReader(reqBody)) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept-Encoding", "gzip") rec := httptest.NewRecorder() diff --git a/node/rpcstack_gzip_bench_test.go b/node/rpcstack_gzip_bench_test.go index 739f2faf619..dbbc36e35fb 100644 --- a/node/rpcstack_gzip_bench_test.go +++ b/node/rpcstack_gzip_bench_test.go @@ -134,7 +134,7 @@ func measureHandlerLatency(t testing.TB, payload []byte, wrap func(http.Handler) client := &http.Client{Transport: &http.Transport{DisableCompression: true}} for range 10 { - req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) + req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) //nolint:noctx req.Header.Set("Accept-Encoding", "gzip") resp, _ := client.Do(req) if resp != nil { @@ -145,7 +145,7 @@ func measureHandlerLatency(t testing.TB, payload []byte, wrap func(http.Handler) latencies := make([]time.Duration, 0, requests) for range requests { - req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) + req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) //nolint:noctx req.Header.Set("Accept-Encoding", "gzip") start := time.Now() resp, err := client.Do(req) @@ -174,7 +174,7 @@ func measureRPCLatency(t testing.TB, endpoint, blockTag string) latencyStats { // Warmup + fetch payload size var payloadKB int for i := range 10 { - req, _ := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(body)) + req, _ := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(body)) //nolint:noctx req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept-Encoding", "gzip") resp, err := client.Do(req) @@ -191,7 +191,7 @@ func measureRPCLatency(t testing.TB, endpoint, blockTag string) latencyStats { latencies := make([]time.Duration, 0, requests) for range requests { - req, _ := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(body)) + req, _ := http.NewRequest(http.MethodPost, endpoint, strings.NewReader(body)) //nolint:noctx req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept-Encoding", "gzip") start := time.Now() @@ -235,7 +235,7 @@ func fetchPayload(t testing.TB, blockTag string) []byte { `{"jsonrpc":"2.0","id":1,"method":"eth_getBlockByNumber","params":[%q,true]}`, blockTag, ) - resp, err := http.Post(rpcEndpoint, "application/json", strings.NewReader(body)) + resp, err := http.Post(rpcEndpoint, "application/json", strings.NewReader(body)) //nolint:noctx if err != nil { t.Skipf("local node not reachable at %s: %v", rpcEndpoint, err) return nil @@ -326,7 +326,7 @@ func benchmarkGzipHandler(b *testing.B, payload []byte, wrap func(http.Handler) client := &http.Client{Transport: &http.Transport{DisableCompression: true}} for range 5 { - req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) + req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) //nolint:noctx req.Header.Set("Accept-Encoding", "gzip") resp, _ := client.Do(req) if resp != nil { @@ -341,7 +341,7 @@ func benchmarkGzipHandler(b *testing.B, payload []byte, wrap func(http.Handler) var totalLatency time.Duration for i := 0; i < b.N; i++ { - req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) + req, _ := http.NewRequest(http.MethodPost, srv.URL, bytes.NewReader(payload)) //nolint:noctx req.Header.Set("Accept-Encoding", "gzip") start := time.Now() resp, err := client.Do(req) diff --git a/node/rpcstack_gzip_handler_test.go b/node/rpcstack_gzip_handler_test.go index 3a01cf3666f..5cb9bfbbfde 100644 --- a/node/rpcstack_gzip_handler_test.go +++ b/node/rpcstack_gzip_handler_test.go @@ -45,7 +45,7 @@ func decompressGzip(t *testing.T, r io.Reader) []byte { // gzipRequest issues a POST to handler with Accept-Encoding: gzip and returns the recorder. func gzipRequest(t *testing.T, handler http.Handler) *httptest.ResponseRecorder { t.Helper() - req := httptest.NewRequest(http.MethodPost, "/", nil) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil) req.Header.Set("Accept-Encoding", "gzip") rec := httptest.NewRecorder() handler.ServeHTTP(rec, req) @@ -93,7 +93,7 @@ func TestGzipHandlerNoAcceptEncoding(t *testing.T) { _, _ = w.Write(body) })) - req := httptest.NewRequest(http.MethodPost, "/", nil) + req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil) rec := httptest.NewRecorder() handler.ServeHTTP(rec, req) diff --git a/node/rpcstack_test.go b/node/rpcstack_test.go index 8fa67254ec9..f4acd769527 100644 --- a/node/rpcstack_test.go +++ b/node/rpcstack_test.go @@ -244,7 +244,7 @@ func TestAllowList(t *testing.T) { func testCustomRequest(t *testing.T, url, method string) bool { body := bytes.NewReader(fmt.Appendf(nil, `{"jsonrpc":"2.0","id":1,"method":"%s"}`, method)) - req, _ := http.NewRequest("POST", url, body) + req, _ := http.NewRequestWithContext(t.Context(), "POST", url, body) req.Header.Set("content-type", "application/json") client := http.DefaultClient @@ -265,7 +265,7 @@ func rpcRequest(t *testing.T, url string, extraHeaders ...string) *http.Response // Create the request. body := bytes.NewReader([]byte(`{"jsonrpc":"2.0","id":1,"method":"rpc_modules","params":[]}`)) - req, err := http.NewRequest("POST", url, body) + req, err := http.NewRequestWithContext(t.Context(), "POST", url, body) if err != nil { t.Fatal("could not create http request:", err) } @@ -307,7 +307,10 @@ func TestHTTP2H2C(t *testing.T) { client := &http.Client{Transport: transport} body := strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"rpc_modules","params":[]}`) - resp, err := client.Post("http://"+addr.String(), "application/json", body) + req, err := http.NewRequestWithContext(t.Context(), "POST", "http://"+addr.String(), body) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := client.Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -332,7 +335,8 @@ func TestHTTP2H2CUpgrade(t *testing.T) { require.NoError(t, err) t.Cleanup(func() { _ = httpSrv.Shutdown(context.Background()) }) - conn, err := net.Dial("tcp", addr.String()) + var dialer net.Dialer + conn, err := dialer.DialContext(t.Context(), "tcp", addr.String()) require.NoError(t, err) defer conn.Close() require.NoError(t, conn.SetDeadline(time.Now().Add(10*time.Second))) @@ -386,7 +390,10 @@ func TestHTTPSEndpoint(t *testing.T) { defer client.CloseIdleConnections() body := strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"rpc_modules","params":[]}`) - resp, err := client.Post("https://"+addr.String(), "application/json", body) + req, err := http.NewRequestWithContext(t.Context(), "POST", "https://"+addr.String(), body) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := client.Do(req) require.NoError(t, err) defer resp.Body.Close() @@ -440,14 +447,14 @@ func TestRPCAdmissionHandler(t *testing.T) { t.Run("disabled when limit is zero", func(t *testing.T) { h := newRPCAdmissionHandler(0, okHandler) rec := httptest.NewRecorder() - h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/", nil)) + h.ServeHTTP(rec, httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil)) assert.Equal(t, http.StatusOK, rec.Code) }) t.Run("allows requests under the limit", func(t *testing.T) { h := newRPCAdmissionHandler(5, okHandler) rec := httptest.NewRecorder() - h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/", nil)) + h.ServeHTTP(rec, httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil)) assert.Equal(t, http.StatusOK, rec.Code) }) @@ -466,7 +473,7 @@ func TestRPCAdmissionHandler(t *testing.T) { var wg sync.WaitGroup for range limit { wg.Go(func() { - h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodPost, "/", nil)) + h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil)) }) } @@ -479,7 +486,7 @@ func TestRPCAdmissionHandler(t *testing.T) { // Now the limit is reached — next request must be rejected. rec := httptest.NewRecorder() - h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/", nil)) + h.ServeHTTP(rec, httptest.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil)) assert.Equal(t, http.StatusServiceUnavailable, rec.Code) // Release the held requests. @@ -540,7 +547,7 @@ func TestNewWSConnectionLimiter(t *testing.T) { w.WriteHeader(http.StatusOK) })) rr0 := httptest.NewRecorder() - passthrough.ServeHTTP(rr0, httptest.NewRequest(http.MethodGet, "/", nil)) + passthrough.ServeHTTP(rr0, httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil)) assert.Equal(t, http.StatusOK, rr0.Code) // Build a limiter with limit=1. @@ -554,7 +561,7 @@ func TestNewWSConnectionLimiter(t *testing.T) { // First request: should be accepted (blocks on hold). go func() { - req := httptest.NewRequest(http.MethodGet, "/", nil) + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil) limiter.ServeHTTP(httptest.NewRecorder(), req) }() @@ -565,7 +572,7 @@ func TestNewWSConnectionLimiter(t *testing.T) { // Second request: should be rejected with 503. rr := httptest.NewRecorder() - req := httptest.NewRequest(http.MethodGet, "/", nil) + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/", nil) limiter.ServeHTTP(rr, req) assert.Equal(t, http.StatusServiceUnavailable, rr.Code) diff --git a/p2p/enr/enr.go b/p2p/enr/enr.go index 68e81628e78..ffd76b31c22 100644 --- a/p2p/enr/enr.go +++ b/p2p/enr/enr.go @@ -166,12 +166,12 @@ func (r *Record) Set(e Entry) { case i < len(r.pairs): // insert pair before i-th elem el := pair{e.ENRKey(), blob} - pairs = append(pairs, pair{}) + pairs = append(pairs, pair{}) //nolint:makezero copy(pairs[i+1:], pairs[i:]) pairs[i] = el default: // element should be placed at the end of r.pairs - pairs = append(pairs, pair{e.ENRKey(), blob}) + pairs = append(pairs, pair{e.ENRKey(), blob}) //nolint:makezero } r.pairs = pairs } diff --git a/p2p/nat/natupnp_test.go b/p2p/nat/natupnp_test.go index 97070016a33..fb5d5ee9d49 100644 --- a/p2p/nat/natupnp_test.go +++ b/p2p/nat/natupnp_test.go @@ -205,7 +205,8 @@ type fakeIGD struct { // httpu.Handler func (dev *fakeIGD) ServeMessage(r *http.Request) { dev.t.Logf(`HTTPU request %s %s`, r.Method, r.RequestURI) - conn, err := net.Dial("udp4", r.RemoteAddr) + var dialer net.Dialer + conn, err := dialer.DialContext(r.Context(), "udp4", r.RemoteAddr) if err != nil { fmt.Printf("reply Dial error: %v", err) return @@ -230,7 +231,7 @@ func (dev *fakeIGD) replaceListenAddr(resp string) string { } func (dev *fakeIGD) listen() (err error) { - if dev.listener, err = net.Listen("tcp", "127.0.0.1:0"); err != nil { + if dev.listener, err = net.Listen("tcp", "127.0.0.1:0"); err != nil { //nolint:noctx return err } laddr := &net.UDPAddr{IP: net.ParseIP("239.255.255.250"), Port: 1900} diff --git a/p2p/netutil/error_test.go b/p2p/netutil/error_test.go index 4454da34c93..7a37394c04e 100644 --- a/p2p/netutil/error_test.go +++ b/p2p/netutil/error_test.go @@ -29,12 +29,14 @@ import ( // errors that result from receiving a UDP packet larger // than the supplied receive buffer. func TestIsPacketTooBig(t *testing.T) { - listener, err := net.ListenPacket("udp", "127.0.0.1:0") + var lc net.ListenConfig + listener, err := lc.ListenPacket(t.Context(), "udp", "127.0.0.1:0") if err != nil { t.Fatal(err) } defer listener.Close() - sender, err := net.Dial("udp", listener.LocalAddr().String()) + var dialer net.Dialer + sender, err := dialer.DialContext(t.Context(), "udp", listener.LocalAddr().String()) if err != nil { t.Fatal(err) } diff --git a/p2p/pipes/pipes.go b/p2p/pipes/pipes.go index 09d15083602..db366c550ce 100644 --- a/p2p/pipes/pipes.go +++ b/p2p/pipes/pipes.go @@ -25,7 +25,7 @@ import ( // TCPPipe creates an in process full duplex pipe based on a localhost TCP socket func TCPPipe() (_ net.Conn, _ net.Conn, err error) { - l, err := net.Listen("tcp", "127.0.0.1:0") + l, err := net.Listen("tcp", "127.0.0.1:0") //nolint:noctx if err != nil { return nil, nil, err } @@ -40,7 +40,7 @@ func TCPPipe() (_ net.Conn, _ net.Conn, err error) { }() var dconn net.Conn - if dconn, err = net.Dial("tcp", l.Addr().String()); err != nil { + if dconn, err = net.Dial("tcp", l.Addr().String()); err != nil { //nolint:noctx <-aerr return nil, nil, err } diff --git a/p2p/rlpx/rlpx.go b/p2p/rlpx/rlpx.go index ebcbd016661..2d0a49020c3 100644 --- a/p2p/rlpx/rlpx.go +++ b/p2p/rlpx/rlpx.go @@ -642,7 +642,7 @@ func (h *handshakeState) sealEIP8(msg any) ([]byte, error) { binary.BigEndian.PutUint16(prefix, uint16(len(h.wbuf.data)+eciesOverhead)) enc, err := ecies.Encrypt(rand.Reader, h.remote, h.wbuf.data, nil, prefix) - return append(prefix, enc...), err + return append(prefix, enc...), err //nolint:makezero } // importPublicKey unmarshals 64 or 65 bytes long public keys. diff --git a/p2p/sentry/sentry_grpc_server_test.go b/p2p/sentry/sentry_grpc_server_test.go index e5704c94614..43e4b56f38c 100644 --- a/p2p/sentry/sentry_grpc_server_test.go +++ b/p2p/sentry/sentry_grpc_server_test.go @@ -1027,7 +1027,8 @@ func minimalP2PServerWithListener(t *testing.T) *p2p.Server { func listenerReachable(t *testing.T, srv *p2p.Server) bool { t.Helper() addr := srv.NodeInfo().ListenAddr - c, err := net.DialTimeout("tcp", addr, 200*time.Millisecond) + var dialer net.Dialer + c, err := dialer.DialContext(t.Context(), "tcp", addr) if err != nil { return false } diff --git a/p2p/server_test.go b/p2p/server_test.go index 5fa994f8c76..9af28fdb391 100644 --- a/p2p/server_test.go +++ b/p2p/server_test.go @@ -113,7 +113,8 @@ func TestServerListen(t *testing.T) { defer srv.Stop() // dial the test server - conn, err := net.DialTimeout("tcp", srv.ListenAddr, 5*time.Second) + var dialer net.Dialer + conn, err := dialer.DialContext(t.Context(), "tcp", srv.ListenAddr) if err != nil { t.Fatalf("could not dial: %v", err) } @@ -137,7 +138,7 @@ func TestServerListen(t *testing.T) { func TestServerDial(t *testing.T) { logger := log.New() // run a one-shot TCP server to handle the connection. - listener, err := net.Listen("tcp", "127.0.0.1:0") + listener, err := net.Listen("tcp", "127.0.0.1:0") //nolint:noctx if err != nil { t.Fatalf("could not setup listener: %v", err) } @@ -584,7 +585,8 @@ func TestServerInboundUsesStaticEnode(t *testing.T) { srv.AddPeer(staticEnode) // Drive an inbound connection. - conn, err := net.DialTimeout("tcp", srv.ListenAddr, 5*time.Second) + var dialer net.Dialer + conn, err := dialer.DialContext(t.Context(), "tcp", srv.ListenAddr) require.NoError(t, err) defer conn.Close() @@ -630,7 +632,8 @@ func TestServerInboundThrottle(t *testing.T) { defer srv.Stop() // Dial the test server. - conn, err := net.DialTimeout("tcp", srv.ListenAddr, timeout) + var dialer net.Dialer + conn, err := dialer.DialContext(t.Context(), "tcp", srv.ListenAddr) if err != nil { t.Fatalf("could not dial: %v", err) } @@ -644,7 +647,7 @@ func TestServerInboundThrottle(t *testing.T) { // Dial again. This time the server should close the connection immediately. connClosed := make(chan struct{}, 1) - conn, err = net.DialTimeout("tcp", srv.ListenAddr, timeout) + conn, err = dialer.DialContext(t.Context(), "tcp", srv.ListenAddr) if err != nil { t.Fatalf("could not dial: %v", err) } @@ -668,7 +671,7 @@ func TestServerInboundThrottle(t *testing.T) { } func listenFakeAddr(network, laddr string, remoteAddr net.Addr) (net.Listener, error) { - l, err := net.Listen(network, laddr) + l, err := net.Listen(network, laddr) //nolint:noctx if err == nil { l = &fakeAddrListener{l, remoteAddr} } diff --git a/rpc/client_test.go b/rpc/client_test.go index 1c73fe9350f..4812d326e5c 100644 --- a/rpc/client_test.go +++ b/rpc/client_test.go @@ -675,7 +675,7 @@ func TestClientReconnect(t *testing.T) { logger := log.New() startServer := func(addr string) (*Server, net.Listener) { srv := newTestServer(logger) - l, err := net.Listen("tcp", addr) + l, err := net.Listen("tcp", addr) //nolint:noctx if err != nil { t.Fatal("can't listen:", err) } diff --git a/rpc/handler.go b/rpc/handler.go index 1887fc7b644..85911357a64 100644 --- a/rpc/handler.go +++ b/rpc/handler.go @@ -681,8 +681,10 @@ func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *cal // except '<', '>', '&' and U+2028/2029 in the id/result are left unescaped (valid JSON, same value). func (msg *jsonrpcMessage) writeTo(stream jsonstream.Stream) { if msg.Error != nil || msg.Result == nil || msg.ID == nil || msg.Version == "" || msg.Method != "" || msg.Params != nil { - buf, _ := json.Marshal(msg) - _, _ = stream.Write(buf) + buf, err := json.Marshal(msg) + if err == nil { + _, _ = stream.Write(buf) + } return } stream.WriteObjectStart() diff --git a/rpc/http.go b/rpc/http.go index b25a78ba70b..1796c531549 100644 --- a/rpc/http.go +++ b/rpc/http.go @@ -214,7 +214,7 @@ func newHTTPServerConn(r *http.Request, w http.ResponseWriter) ServerCodec { param = pb } buf := new(bytes.Buffer) - json.NewEncoder(buf).Encode(jsonrpcMessage{ + _ = json.NewEncoder(buf).Encode(jsonrpcMessage{ //nolint:errchkjson ID: json.RawMessage(id), Method: method_up, Params: param, diff --git a/rpc/http_test.go b/rpc/http_test.go index 24ceba44f51..8ff74b33eb8 100644 --- a/rpc/http_test.go +++ b/rpc/http_test.go @@ -50,7 +50,7 @@ func confirmStatusCode(t *testing.T, got, want int) { func confirmRequestValidationCode(t *testing.T, method, contentType, body string, expectedStatusCode int) { t.Helper() - request := httptest.NewRequest(method, "http://url.com", strings.NewReader(body)) + request := httptest.NewRequestWithContext(t.Context(), method, "http://url.com", strings.NewReader(body)) if len(contentType) > 0 { request.Header.Set("Content-Type", contentType) } @@ -93,7 +93,7 @@ func confirmHTTPRequestYieldsStatusCode(t *testing.T, method, contentType, body ts := httptest.NewServer(&s) defer ts.Close() - request, err := http.NewRequest(method, ts.URL, strings.NewReader(body)) + request, err := http.NewRequestWithContext(t.Context(), method, ts.URL, strings.NewReader(body)) if err != nil { t.Fatalf("failed to create a valid HTTP request: %v", err) } @@ -160,7 +160,10 @@ func TestHTTPBatchPreservesOrderWithStreaming(t *testing.T) { `{"jsonrpc":"2.0","id":4,"method":"test_echo","params":["four",4,{"S":"y"}]}` + `]` - resp, err := http.Post(ts.URL, "application/json", strings.NewReader(body)) + req, err := http.NewRequestWithContext(t.Context(), "POST", ts.URL, strings.NewReader(body)) + require.NoError(t, err) + req.Header.Set("Content-Type", "application/json") + resp, err := ts.Client().Do(req) require.NoError(t, err) defer resp.Body.Close() raw, err := io.ReadAll(resp.Body) @@ -267,7 +270,7 @@ func TestCheckJwtSecretAuthScheme(t *testing.T) { } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { - r := httptest.NewRequest(http.MethodPost, "http://url.com", nil) + r := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "http://url.com", nil) r.Header.Set("Authorization", tc.header) require.Equal(t, tc.want, CheckJwtSecret(httptest.NewRecorder(), r, secret)) }) diff --git a/rpc/json.go b/rpc/json.go index ac21f7494f8..ac3eed2d141 100644 --- a/rpc/json.go +++ b/rpc/json.go @@ -94,7 +94,10 @@ func (msg *jsonrpcMessage) namespace() string { } func (msg *jsonrpcMessage) String() string { - b, _ := json.Marshal(msg) + b, err := json.Marshal(msg) + if err != nil { + return "" + } return string(b) } diff --git a/rpc/jsonrpc/trace_adhoc.go b/rpc/jsonrpc/trace_adhoc.go index 6520e6571da..9b39e1c08d9 100644 --- a/rpc/jsonrpc/trace_adhoc.go +++ b/rpc/jsonrpc/trace_adhoc.go @@ -1087,7 +1087,7 @@ func (api *TraceAPIImpl) ReplayBlockTransactions(ctx context.Context, blockNrOrH } } } - result = append(result, &TraceCallResult{ + result = append(result, &TraceCallResult{ //nolint:makezero Trace: []*ParityTrace{}, StateDiff: sdMap, }) diff --git a/rpc/mcp/mcp_test.go b/rpc/mcp/mcp_test.go index 2916ac16d1c..6e5e25acc21 100644 --- a/rpc/mcp/mcp_test.go +++ b/rpc/mcp/mcp_test.go @@ -98,7 +98,7 @@ func TestAllToolsDeclareReadOnlyHint(t *testing.T) { func freeAddr(t *testing.T) string { t.Helper() - l, err := net.Listen("tcp", "127.0.0.1:0") + l, err := net.Listen("tcp", "127.0.0.1:0") //nolint:noctx require.NoError(t, err) addr := l.Addr().String() require.NoError(t, l.Close()) diff --git a/rpc/mcp/transport_test.go b/rpc/mcp/transport_test.go index d01882977f9..2663071ffb6 100644 --- a/rpc/mcp/transport_test.go +++ b/rpc/mcp/transport_test.go @@ -28,7 +28,7 @@ func TestListenAndServeServesBothTransports(t *testing.T) { var resp *http.Response var err error for range 100 { - req, reqErr := http.NewRequest(http.MethodPost, "http://"+addr+"/mcp", strings.NewReader(initBody)) + req, reqErr := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://"+addr+"/mcp", strings.NewReader(initBody)) require.NoError(t, reqErr) req.Header.Set("Content-Type", "application/json") req.Header.Set("Accept", "application/json, text/event-stream") @@ -45,13 +45,15 @@ func TestListenAndServeServesBothTransports(t *testing.T) { require.Equal(t, http.StatusOK, resp.StatusCode) require.Contains(t, string(body), `"ErigonMCP"`) - sseResp, err := client.Get("http://" + addr + "/sse") + sseReq, err := http.NewRequestWithContext(t.Context(), "GET", "http://"+addr+"/sse", nil) + require.NoError(t, err) + sseResp, err := client.Do(sseReq) require.NoError(t, err) defer sseResp.Body.Close() require.Equal(t, http.StatusOK, sseResp.StatusCode) require.Equal(t, "text/event-stream", sseResp.Header.Get("Content-Type")) - slashReq, err := http.NewRequest(http.MethodPost, "http://"+addr+"/mcp/", strings.NewReader(initBody)) + slashReq, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "http://"+addr+"/mcp/", strings.NewReader(initBody)) require.NoError(t, err) slashReq.Header.Set("Content-Type", "application/json") slashReq.Header.Set("Accept", "application/json, text/event-stream") @@ -79,7 +81,12 @@ func TestListenAndServeShutsDownWithOpenStream(t *testing.T) { var err error for range 100 { var resp *http.Response - resp, err = probe.Get("http://" + addr + "/sse") + getReq, getErr := http.NewRequestWithContext(t.Context(), "GET", "http://"+addr+"/sse", nil) + if getErr == nil { + resp, err = probe.Do(getReq) + } else { + err = getErr + } if err == nil { resp.Body.Close() break @@ -88,7 +95,7 @@ func TestListenAndServeShutsDownWithOpenStream(t *testing.T) { } require.NoError(t, err) - streamReq, err := http.NewRequest(http.MethodGet, "http://"+addr+"/mcp", nil) + streamReq, err := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://"+addr+"/mcp", nil) require.NoError(t, err) streamReq.Header.Set("Accept", "text/event-stream") // Bounds the header wait without a request deadline that would end the diff --git a/rpc/requests/request_generator.go b/rpc/requests/request_generator.go index 0525cf069f2..a5890d61c00 100644 --- a/rpc/requests/request_generator.go +++ b/rpc/requests/request_generator.go @@ -350,7 +350,7 @@ func (req *requestGenerator) rpcClient(ctx context.Context) (*rpc.Client, error) func post(ctx context.Context, client *http.Client, url, method, request string, response any, logger log.Logger) error { start := time.Now() - req, err := http.NewRequest("POST", url, strings.NewReader(request)) + req, err := http.NewRequestWithContext(ctx, "POST", url, strings.NewReader(request)) if err != nil { return err } diff --git a/rpc/server_test.go b/rpc/server_test.go index 8d8900f24a7..5b76628dd98 100644 --- a/rpc/server_test.go +++ b/rpc/server_test.go @@ -156,7 +156,7 @@ func TestServerShortLivedConn(t *testing.T) { server := newTestServer(logger) defer server.Stop() - listener, err := net.Listen("tcp", "127.0.0.1:0") + listener, err := net.Listen("tcp", "127.0.0.1:0") //nolint:noctx if err != nil { t.Fatal("can't listen:", err) } @@ -168,8 +168,9 @@ func TestServerShortLivedConn(t *testing.T) { wantResp = `{"jsonrpc":"2.0","id":1,"result":{"nftest":"1.0","rpc":"1.0","test":"1.0"}}` + "\n" deadline = time.Now().Add(10 * time.Second) ) + var dialer net.Dialer for range 20 { - conn, err := net.Dial("tcp", listener.Addr().String()) + conn, err := dialer.DialContext(t.Context(), "tcp", listener.Addr().String()) if err != nil { t.Fatal("can't dial:", err) } diff --git a/rpc/subscription.go b/rpc/subscription.go index 0792b992156..565d0df6b80 100644 --- a/rpc/subscription.go +++ b/rpc/subscription.go @@ -226,7 +226,10 @@ func (n *RemoteNotifier) activate() error { } func (n *RemoteNotifier) send(sub *Subscription, data json.RawMessage) error { - params, _ := json.Marshal(&subscriptionResult{ID: string(sub.ID), Result: data}) + params, err := json.Marshal(&subscriptionResult{ID: string(sub.ID), Result: data}) + if err != nil { + return err + } ctx := context.Background() return n.h.conn.WriteJSON(ctx, &jsonrpcMessage{ Version: vsn, diff --git a/rpc/websocket_test.go b/rpc/websocket_test.go index cdc695871e0..0f762c00910 100644 --- a/rpc/websocket_test.go +++ b/rpc/websocket_test.go @@ -239,7 +239,7 @@ func wsPingTestServer(t *testing.T, sendPing <-chan struct{}) *http.Server { }) // Start the server. - listener, err := net.Listen("tcp", "127.0.0.1:0") + listener, err := net.Listen("tcp", "127.0.0.1:0") //nolint:noctx if err != nil { t.Fatal("can't listen:", err) } diff --git a/txnprovider/txpool/tests/helper/p2p_client.go b/txnprovider/txpool/tests/helper/p2p_client.go index 19d8597d057..27f1bc7ed6d 100644 --- a/txnprovider/txpool/tests/helper/p2p_client.go +++ b/txnprovider/txpool/tests/helper/p2p_client.go @@ -63,7 +63,7 @@ func (p *p2pClient) Connect() (<-chan TxMessage, <-chan error, error) { PrivateKey: privateKey, } - r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( + r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( //nolint:noctx `{"jsonrpc":"2.0","method":"admin_nodeInfo","params":[],"id":1}`, )) if err != nil { @@ -144,7 +144,7 @@ func (p *p2pClient) Connect() (<-chan TxMessage, <-chan error, error) { func (p *p2pClient) notifyWhenReady() (<-chan struct{}, error) { ready := make(chan struct{}) - r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( + r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( //nolint:noctx `{"jsonrpc":"2.0","method":"admin_peers","params":[],"id":1}`, )) if err != nil { @@ -168,7 +168,7 @@ func (p *p2pClient) notifyWhenReady() (<-chan struct{}, error) { for { time.Sleep(100 * time.Millisecond) - r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( + r, err := http.Post(p.adminRPC, "application/json", strings.NewReader( //nolint:noctx `{"jsonrpc":"2.0","method":"admin_peers","params":[],"id":1}`, )) if err != nil { diff --git a/txnprovider/txpool/tests/pool_test.go b/txnprovider/txpool/tests/pool_test.go index d28ef6129f3..150ed178370 100644 --- a/txnprovider/txpool/tests/pool_test.go +++ b/txnprovider/txpool/tests/pool_test.go @@ -54,8 +54,9 @@ var ( // P2P helper is binded to node1 port, that's why we measure performance of local txs processing func skipIfNodeUnreachable(t *testing.T, addrs ...string) { t.Helper() + var dialer net.Dialer for _, addr := range addrs { - conn, err := net.DialTimeout("tcp", addr, 300*time.Millisecond) + conn, err := dialer.DialContext(t.Context(), "tcp", addr) if err != nil { t.Skipf("requires a running node at %s: %v", addr, err) } diff --git a/txnprovider/txpool/txpool_grpc_server.go b/txnprovider/txpool/txpool_grpc_server.go index 4f6306f21b3..a8621ed01a8 100644 --- a/txnprovider/txpool/txpool_grpc_server.go +++ b/txnprovider/txpool/txpool_grpc_server.go @@ -319,7 +319,7 @@ func (s *GrpcServer) Nonce(ctx context.Context, in *txpoolproto.NonceRequest) (* // NewSlotsStreams - it's safe to use this class as non-pointer type NewSlotsStreams = grpcutil.StreamBroadcaster[txpoolproto.OnAddReply] -func StartGrpc(txPoolServer txpoolproto.TxpoolServer, miningServer txpoolproto.MiningServer, addr string, creds credentials.TransportCredentials, logger log.Logger) (*grpc.Server, error) { +func StartGrpc(ctx context.Context, txPoolServer txpoolproto.TxpoolServer, miningServer txpoolproto.MiningServer, addr string, creds credentials.TransportCredentials, logger log.Logger) (*grpc.Server, error) { grpcServer := grpcutil.NewServerWithOpts(creds, grpc.ReadBufferSize(0), // reduce buffers to save mem grpc.WriteBufferSize(0), // reduce buffers to save mem @@ -331,7 +331,7 @@ func StartGrpc(txPoolServer txpoolproto.TxpoolServer, miningServer txpoolproto.M txpoolproto.RegisterMiningServer(grpcServer, miningServer) } - if err := grpcutil.StartServer(grpcServer, addr, true, logger, "txpool gRPC server fail"); err != nil { + if err := grpcutil.StartServer(ctx, grpcServer, addr, true, logger, "txpool gRPC server fail"); err != nil { return nil, err } logger.Info("Started gRPC server", "on", addr)