github/prysm
1
1
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-07 22:54:17 -05:00
Code Issues Packages Projects Releases Wiki Activity

goethereum dependency to v1.14~ (#14351)

Browse Source 
* updating the goethereum dependency

* fixing dependencies

* reverting workspace

* more fixes, work in progress

* trying with upgraded geth version

* fixing deprecated functions except for the time related ones on eth1 distance due to time issues

* fixing time issues

* gaz

* fixing test and upgrading some dependencies and reverting others

* Disable cgo in hid, delete old vendored usb library

* changelog

* rolling back dependencies

* fixing go mod tidy

* Geth v1.13.6

* fix tests

* Add ping interval, set to 500ms for tests. This didnt work

* Update to v1.14.8

* Spread it out to different bootnodes

* Fix it

* Remove Memsize

* Update all out of date dependencies

* Fix geth body change

* Fix Test

* Fix Build

* Fix Tests

* Fix Tests Again

* Fix Tests Again

* Fix Tests

* Fix Test

* Copy USB Package for HID

* Push it up

* Finally fix all tests with felix's changes

* updating geth dependency

* Update go-ethereum to v1.14.11

* fixing import

* reverting blob change

* fixing Implicit memory aliasing in for loop.

* WIP changes

* wip getting a little further on e2e runs

* getting a little further

* getting a little further

* setting everything to capella

* more partial fixes

* more fixes but still WIP

* fixing access list transactions"

* some cleanup

* making configs dynamic

* reverting time

* skip lower bound in builder

* updating to geth v1.14.12

* fixing verify blob to pointer

* go mod tidy

* fixing linting

* missed removing another terminal difficulty item

* another missed update

* updating more dependencies to fix cicd

* fixing holiman dependency update

* downgrading geth to 1.14.11 due to p2p loop issue

* reverting builder middleware caused by downgrade

* fixing more rollback issues

* upgrading back to 1.14.12 after discussing with preston

* mod tidy

* gofmt

* partial review feedback

* trying to start e2e from bellatrix instead

* reverting some changes

---------

Co-authored-by: Preston Van Loon <preston@pvl.dev>
Co-authored-by: nisdas <nishdas93@gmail.com>
This commit is contained in:
james-prysm
2025-01-14 02:35:49 -06:00
committed by GitHub
parent e5784d09f0
commit e36564c4d3
57 changed files with 614 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@@ -44,6 +44,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
- Fixed Metadata errors for peers connected via QUIC. - Fixed Metadata errors for peers connected via QUIC.
- Process light client finality updates only for new finalized epochs instead of doing it for every block. - Process light client finality updates only for new finalized epochs instead of doing it for every block.
- Update blobs by rpc topics from V2 to V1. - Update blobs by rpc topics from V2 to V1.
- Updated geth to 1.14 ~
- E2e tests start from bellatrix
### Deprecated ### Deprecated
@@ -52,6 +54,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
- Cleanup ProcessSlashings method to remove unnecessary argument. - Cleanup ProcessSlashings method to remove unnecessary argument.
- Remove `/proto/eth/v2` directory. [PR](https://github.com/prysmaticlabs/prysm/pull/14765) - Remove `/proto/eth/v2` directory. [PR](https://github.com/prysmaticlabs/prysm/pull/14765)
- Remove `/memsize/` pprof endpoint as it will no longer be supported in go 1.23, geth also removed in https://github.com/ethereum/go-ethereum/commit/e4675771eda550e7eeb63a8884816982c1980644
### Fixed ### Fixed

7
beacon-chain/blockchain/kzg/validation.go
View File

@@ -20,16 +20,17 @@ func Verify(sidecars ...blocks.ROBlob) error {
cmts := make([]GoKZG.KZGCommitment, len(sidecars)) cmts := make([]GoKZG.KZGCommitment, len(sidecars))
proofs := make([]GoKZG.KZGProof, len(sidecars)) proofs := make([]GoKZG.KZGProof, len(sidecars))
for i, sidecar := range sidecars { for i, sidecar := range sidecars {
blobs[i] = bytesToBlob(sidecar.Blob) blobs[i] = *bytesToBlob(sidecar.Blob)
cmts[i] = bytesToCommitment(sidecar.KzgCommitment) cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
proofs[i] = bytesToKZGProof(sidecar.KzgProof) proofs[i] = bytesToKZGProof(sidecar.KzgProof)
} }
return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs) return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
} }
func bytesToBlob(blob []byte) (ret GoKZG.Blob) { func bytesToBlob(blob []byte) *GoKZG.Blob {
var ret GoKZG.Blob
copy(ret[:], blob) copy(ret[:], blob)
return return &ret
} }
func bytesToCommitment(commitment []byte) (ret GoKZG.KZGCommitment) { func bytesToCommitment(commitment []byte) (ret GoKZG.KZGCommitment) {

6
beacon-chain/blockchain/kzg/validation_test.go
View File

@@ -10,11 +10,11 @@ import (
) )
func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) { func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) {
commitment, err := kzgContext.BlobToKZGCommitment(blob, 0) commitment, err := kzgContext.BlobToKZGCommitment(&blob, 0)
if err != nil { if err != nil {
return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
} }
proof, err := kzgContext.ComputeBlobKZGProof(blob, commitment, 0) proof, err := kzgContext.ComputeBlobKZGProof(&blob, commitment, 0)
if err != nil { if err != nil {
return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
} }
@@ -31,7 +31,7 @@ func TestBytesToAny(t *testing.T) {
blob := GoKZG.Blob{0x01, 0x02} blob := GoKZG.Blob{0x01, 0x02}
commitment := GoKZG.KZGCommitment{0x01, 0x02} commitment := GoKZG.KZGCommitment{0x01, 0x02}
proof := GoKZG.KZGProof{0x01, 0x02} proof := GoKZG.KZGProof{0x01, 0x02}
require.DeepEqual(t, blob, bytesToBlob(bytes)) require.DeepEqual(t, blob, *bytesToBlob(bytes))
require.DeepEqual(t, commitment, bytesToCommitment(bytes)) require.DeepEqual(t, commitment, bytesToCommitment(bytes))
require.DeepEqual(t, proof, bytesToKZGProof(bytes)) require.DeepEqual(t, proof, bytesToKZGProof(bytes))
} }

2
beacon-chain/execution/BUILD.bazel
View File

@@ -131,11 +131,11 @@ go_test(
"//testing/util:go_default_library", "//testing/util:go_default_library",
"//time/slots:go_default_library", "//time/slots:go_default_library",
"@com_github_ethereum_go_ethereum//:go_default_library", "@com_github_ethereum_go_ethereum//:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
"@com_github_ethereum_go_ethereum//beacon/engine:go_default_library", "@com_github_ethereum_go_ethereum//beacon/engine:go_default_library",
"@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
"@com_github_ethereum_go_ethereum//core/types:go_default_library", "@com_github_ethereum_go_ethereum//core/types:go_default_library",
"@com_github_ethereum_go_ethereum//ethclient/simulated:go_default_library",
"@com_github_ethereum_go_ethereum//rpc:go_default_library", "@com_github_ethereum_go_ethereum//rpc:go_default_library",
"@com_github_holiman_uint256//:go_default_library", "@com_github_holiman_uint256//:go_default_library",
"@com_github_pkg_errors//:go_default_library", "@com_github_pkg_errors//:go_default_library",

25
beacon-chain/execution/block_reader_test.go
View File

@@ -12,6 +12,7 @@ import (
dbutil "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing" dbutil "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing" mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/types" "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/types"
"github.com/prysmaticlabs/prysm/v5/config/params"
contracts "github.com/prysmaticlabs/prysm/v5/contracts/deposit" contracts "github.com/prysmaticlabs/prysm/v5/contracts/deposit"
"github.com/prysmaticlabs/prysm/v5/contracts/deposit/mock" "github.com/prysmaticlabs/prysm/v5/contracts/deposit/mock"
"github.com/prysmaticlabs/prysm/v5/testing/assert" "github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -44,7 +45,7 @@ func TestLatestMainchainInfo_OK(t *testing.T) {
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -141,7 +142,7 @@ func TestBlockExists_ValidHash(t *testing.T) {
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
testAcc.Backend.Commit() testAcc.Backend.Commit()
block, err := testAcc.Backend.BlockByNumber(context.Background(), big.NewInt(0)) block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), big.NewInt(0))
assert.NoError(t, err) assert.NoError(t, err)
exists, height, err := web3Service.BlockExists(context.Background(), block.Hash()) exists, height, err := web3Service.BlockExists(context.Background(), block.Hash())
@@ -201,8 +202,10 @@ func TestBlockExists_UsesCachedBlockInfo(t *testing.T) {
} }
func TestService_BlockNumberByTimestamp(t *testing.T) { func TestService_BlockNumberByTimestamp(t *testing.T) {
ctx := context.Background()
beaconDB := dbutil.SetupDB(t) beaconDB := dbutil.SetupDB(t)
testAcc, err := mock.Setup() testAcc, err := mock.Setup()
require.NoError(t, err, "Unable to set up simulated backend") require.NoError(t, err, "Unable to set up simulated backend")
server, endpoint, err := mockExecution.SetupRPCServer() server, endpoint, err := mockExecution.SetupRPCServer()
require.NoError(t, err) require.NoError(t, err)
@@ -216,16 +219,22 @@ func TestService_BlockNumberByTimestamp(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
// simulated backend sets eth1 block
params.SetupTestConfigCleanup(t)
conf := params.BeaconConfig().Copy()
conf.SecondsPerETH1Block = 1
params.OverrideBeaconConfig(conf)
initialHead, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
require.NoError(t, err)
for i := 0; i < 200; i++ { for i := 0; i < 200; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
ctx := context.Background()
hd, err := testAcc.Backend.HeaderByNumber(ctx, nil) hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
require.NoError(t, err) require.NoError(t, err)
web3Service.latestEth1Data.BlockTime = hd.Time web3Service.latestEth1Data.BlockTime = hd.Time
web3Service.latestEth1Data.BlockHeight = hd.Number.Uint64() web3Service.latestEth1Data.BlockHeight = hd.Number.Uint64()
blk, err := web3Service.BlockByTimestamp(ctx, 1000 /* time */) blk, err := web3Service.BlockByTimestamp(ctx, initialHead.Time+100 /* time */)
require.NoError(t, err) require.NoError(t, err)
if blk.Number.Cmp(big.NewInt(0)) == 0 { if blk.Number.Cmp(big.NewInt(0)) == 0 {
t.Error("Returned a block with zero number, expected to be non zero") t.Error("Returned a block with zero number, expected to be non zero")
@@ -253,7 +262,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
ctx := context.Background() ctx := context.Background()
hd, err := testAcc.Backend.HeaderByNumber(ctx, nil) hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
require.NoError(t, err) require.NoError(t, err)
web3Service.latestEth1Data.BlockTime = hd.Time web3Service.latestEth1Data.BlockTime = hd.Time
// Use extremely small deadline to illustrate that context deadlines are respected. // Use extremely small deadline to illustrate that context deadlines are respected.
@@ -291,7 +300,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
ctx := context.Background() ctx := context.Background()
hd, err := testAcc.Backend.HeaderByNumber(ctx, nil) hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
require.NoError(t, err) require.NoError(t, err)
web3Service.latestEth1Data.BlockTime = hd.Time web3Service.latestEth1Data.BlockTime = hd.Time
// Use extremely small deadline to illustrate that context deadlines are respected. // Use extremely small deadline to illustrate that context deadlines are respected.

61
beacon-chain/execution/log_processing_test.go
View File

@@ -47,7 +47,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -72,7 +72,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
}, },
} }
logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query) logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
require.NoError(t, err, "Unable to retrieve logs") require.NoError(t, err, "Unable to retrieve logs")
if len(logs) == 0 { if len(logs) == 0 {
@@ -116,7 +116,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -144,7 +144,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
}, },
} }
logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query) logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
require.NoError(t, err, "Unable to retrieve logs") require.NoError(t, err, "Unable to retrieve logs")
web3Service.chainStartData.Chainstarted = true web3Service.chainStartData.Chainstarted = true
@@ -176,7 +176,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -199,7 +199,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
}, },
} }
logz, err := testAcc.Backend.FilterLogs(web3Service.ctx, query) logz, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
require.NoError(t, err, "Unable to retrieve logs") require.NoError(t, err, "Unable to retrieve logs")
loggedPubkey, withCreds, _, loggedSig, index, err := contracts.UnpackDepositLogData(logz[0].Data) loggedPubkey, withCreds, _, loggedSig, index, err := contracts.UnpackDepositLogData(logz[0].Data)
@@ -232,7 +232,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
params.SetupTestConfigCleanup(t) params.SetupTestConfigCleanup(t)
@@ -269,7 +269,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
}, },
} }
logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query) logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
require.NoError(t, err, "Unable to retrieve logs") require.NoError(t, err, "Unable to retrieve logs")
for i := range logs { for i := range logs {
@@ -307,7 +307,7 @@ func TestProcessETH2GenesisLog(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
require.NoError(t, err) require.NoError(t, err)
params.SetupTestConfigCleanup(t) params.SetupTestConfigCleanup(t)
@@ -342,7 +342,7 @@ func TestProcessETH2GenesisLog(t *testing.T) {
}, },
} }
logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query) logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
require.NoError(t, err, "Unable to retrieve logs") require.NoError(t, err, "Unable to retrieve logs")
require.Equal(t, depositsReqForChainStart, len(logs)) require.Equal(t, depositsReqForChainStart, len(logs))
@@ -400,16 +400,18 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
web3Service.httpLogger = testAcc.Backend web3Service.httpLogger = testAcc.Backend.Client()
web3Service.latestEth1Data.LastRequestedBlock = 0 web3Service.latestEth1Data.LastRequestedBlock = 0
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = block.NumberU64()
web3Service.latestEth1Data.BlockTime = block.Time()
bConfig := params.MinimalSpecConfig().Copy() bConfig := params.MinimalSpecConfig().Copy()
bConfig.MinGenesisTime = 0 bConfig.MinGenesisTime = 0
bConfig.SecondsPerETH1Block = 10 bConfig.SecondsPerETH1Block = 1
params.OverrideBeaconConfig(bConfig) params.OverrideBeaconConfig(bConfig)
nConfig := params.BeaconNetworkConfig() nConfig := params.BeaconNetworkConfig()
nConfig.ContractDeploymentBlock = 0 nConfig.ContractDeploymentBlock = 0
@@ -444,8 +446,10 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ { for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = b.NumberU64()
web3Service.latestEth1Data.BlockTime = b.Time()
// Set up our subscriber now to listen for the chain started event. // Set up our subscriber now to listen for the chain started event.
stateChannel := make(chan *feed.Event, 1) stateChannel := make(chan *feed.Event, 1)
@@ -497,13 +501,15 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
web3Service.httpLogger = testAcc.Backend web3Service.httpLogger = testAcc.Backend.Client()
web3Service.latestEth1Data.LastRequestedBlock = 0 web3Service.latestEth1Data.LastRequestedBlock = 0
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = b.NumberU64()
web3Service.latestEth1Data.BlockTime = b.Time()
bConfig := params.MinimalSpecConfig().Copy() bConfig := params.MinimalSpecConfig().Copy()
bConfig.SecondsPerETH1Block = 10 bConfig.SecondsPerETH1Block = 10
params.OverrideBeaconConfig(bConfig) params.OverrideBeaconConfig(bConfig)
@@ -540,14 +546,19 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
for i := uint64(0); i < 1500; i++ { for i := uint64(0); i < 1500; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
wantedGenesisTime := testAcc.Backend.Blockchain().CurrentBlock().Time genesisBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
require.NoError(t, err)
wantedGenesisTime := genesisBlock.Time()
// Forward the chain to account for the follow distance // Forward the chain to account for the follow distance
for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ { for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() currBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = currBlock.NumberU64()
web3Service.latestEth1Data.BlockTime = currBlock.Time()
// Set the genesis time 500 blocks ahead of the last // Set the genesis time 500 blocks ahead of the last
// deposit log. // deposit log.
@@ -608,7 +619,7 @@ func newPowchainService(t *testing.T, eth1Backend *mock.TestAccount, beaconDB db
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(eth1Backend.ContractAddr, eth1Backend.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(eth1Backend.ContractAddr, eth1Backend.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: eth1Backend.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: eth1Backend.Backend}

61
beacon-chain/execution/service_test.go
View File

@@ -8,10 +8,10 @@ import (
"time" "time"
"github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
gethTypes "github.com/ethereum/go-ethereum/core/types" gethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethclient/simulated"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/v5/async/event" "github.com/prysmaticlabs/prysm/v5/async/event"
@@ -44,7 +44,7 @@ var _ POWBlockFetcher = (*Service)(nil)
var _ Chain = (*Service)(nil) var _ Chain = (*Service)(nil)
type goodLogger struct { type goodLogger struct {
backend *backends.SimulatedBackend backend *simulated.Backend
} }
func (_ *goodLogger) Close() {} func (_ *goodLogger) Close() {}
@@ -53,7 +53,7 @@ func (g *goodLogger) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQ
if g.backend == nil { if g.backend == nil {
return new(event.Feed).Subscribe(ch), nil return new(event.Feed).Subscribe(ch), nil
} }
return g.backend.SubscribeFilterLogs(ctx, q, ch) return g.backend.Client().SubscribeFilterLogs(ctx, q, ch)
} }
func (g *goodLogger) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]gethTypes.Log, error) { func (g *goodLogger) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]gethTypes.Log, error) {
@@ -69,7 +69,7 @@ func (g *goodLogger) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]
} }
return logs, nil return logs, nil
} }
return g.backend.FilterLogs(ctx, q) return g.backend.Client().FilterLogs(ctx, q)
} }
type goodNotifier struct { type goodNotifier struct {
@@ -109,7 +109,7 @@ func TestStart_OK(t *testing.T) {
require.NoError(t, err, "unable to setup execution service") require.NoError(t, err, "unable to setup execution service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -156,7 +156,7 @@ func TestStop_OK(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -186,10 +186,12 @@ func TestService_Eth1Synced(t *testing.T) {
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
currTime := testAcc.Backend.Blockchain().CurrentHeader().Time header, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
require.NoError(t, err)
currTime := header.Time
now := time.Now() now := time.Now()
assert.NoError(t, testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0)))) assert.NoError(t, testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0))))
testAcc.Backend.Commit() testAcc.Backend.Commit()
@@ -212,22 +214,29 @@ func TestFollowBlock_OK(t *testing.T) {
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
// simulated backend sets eth1 block // simulated backend sets eth1 block
// time as 10 seconds
params.SetupTestConfigCleanup(t) params.SetupTestConfigCleanup(t)
conf := params.BeaconConfig().Copy() conf := params.BeaconConfig().Copy()
conf.SecondsPerETH1Block = 10 conf.SecondsPerETH1Block = 1
params.OverrideBeaconConfig(conf) params.OverrideBeaconConfig(conf)
web3Service = setDefaultMocks(web3Service) web3Service = setDefaultMocks(web3Service)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
baseHeight := testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
require.NoError(t, err)
baseHeight := block.NumberU64()
// process follow_distance blocks // process follow_distance blocks
var lastHash common.Hash
for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ { for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ {
testAcc.Backend.Commit() lastHash = testAcc.Backend.Commit()
} }
lb, err := testAcc.Backend.Client().BlockByHash(context.Background(), lastHash)
require.NoError(t, err)
log.Println(lb.NumberU64())
// set current height // set current height
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() block, err = testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = block.NumberU64()
web3Service.latestEth1Data.BlockTime = block.Time()
h, err := web3Service.followedBlockHeight(context.Background()) h, err := web3Service.followedBlockHeight(context.Background())
require.NoError(t, err) require.NoError(t, err)
@@ -238,9 +247,12 @@ func TestFollowBlock_OK(t *testing.T) {
for i := uint64(0); i < numToForward; i++ { for i := uint64(0); i < numToForward; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
newBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
require.NoError(t, err)
// set current height // set current height
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64() web3Service.latestEth1Data.BlockHeight = newBlock.NumberU64()
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time web3Service.latestEth1Data.BlockTime = newBlock.Time()
h, err = web3Service.followedBlockHeight(context.Background()) h, err = web3Service.followedBlockHeight(context.Background())
require.NoError(t, err) require.NoError(t, err)
@@ -325,11 +337,11 @@ func TestLogTillGenesis_OK(t *testing.T) {
WithDatabase(beaconDB), WithDatabase(beaconDB),
) )
require.NoError(t, err, "unable to setup web3 ETH1.0 chain service") require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend) web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
require.NoError(t, err) require.NoError(t, err)
web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend} web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
web3Service.httpLogger = testAcc.Backend web3Service.httpLogger = testAcc.Backend.Client()
for i := 0; i < 30; i++ { for i := 0; i < 30; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
@@ -485,15 +497,18 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
for i := 0; i < numToForward; i++ { for i := 0; i < numToForward; i++ {
testAcc.Backend.Commit() testAcc.Backend.Commit()
} }
currTime := testAcc.Backend.Blockchain().CurrentHeader().Time currHeader, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
require.NoError(t, err)
currTime := currHeader.Time
now := time.Now() now := time.Now()
err = testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0))) err = testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0)))
require.NoError(t, err) require.NoError(t, err)
testAcc.Backend.Commit() testAcc.Backend.Commit()
currHeader, err = testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
currTime = testAcc.Backend.Blockchain().CurrentHeader().Time require.NoError(t, err)
web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentHeader().Number.Uint64() currTime = currHeader.Time
web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentHeader().Time web3Service.latestEth1Data.BlockHeight = currHeader.Number.Uint64()
web3Service.latestEth1Data.BlockTime = currHeader.Time
web3Service.chainStartData.GenesisTime = currTime web3Service.chainStartData.GenesisTime = currTime
// With a current slot of zero, only request follow_blocks behind. // With a current slot of zero, only request follow_blocks behind.

2
beacon-chain/execution/testing/BUILD.bazel
View File

@@ -25,10 +25,10 @@ go_library(
"//encoding/bytesutil:go_default_library", "//encoding/bytesutil:go_default_library",
"//proto/engine/v1:go_default_library", "//proto/engine/v1:go_default_library",
"//proto/prysm/v1alpha1:go_default_library", "//proto/prysm/v1alpha1:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
"@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
"@com_github_ethereum_go_ethereum//core/types:go_default_library", "@com_github_ethereum_go_ethereum//core/types:go_default_library",
"@com_github_ethereum_go_ethereum//ethclient/simulated:go_default_library",
"@com_github_ethereum_go_ethereum//rpc:go_default_library", "@com_github_ethereum_go_ethereum//rpc:go_default_library",
"@com_github_holiman_uint256//:go_default_library", "@com_github_holiman_uint256//:go_default_library",
"@com_github_pkg_errors//:go_default_library", "@com_github_pkg_errors//:go_default_library",

10
beacon-chain/execution/testing/mock_execution_chain.go
View File

@@ -9,10 +9,10 @@ import (
"net/http/httptest" "net/http/httptest"
"time" "time"
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
gethTypes "github.com/ethereum/go-ethereum/core/types" gethTypes "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/ethclient/simulated"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/v5/async/event" "github.com/prysmaticlabs/prysm/v5/async/event"
@@ -141,7 +141,7 @@ func (m *Chain) ETH1ConnectionErrors() []error {
// RPCClient defines the mock rpc client. // RPCClient defines the mock rpc client.
type RPCClient struct { type RPCClient struct {
Backend *backends.SimulatedBackend Backend *simulated.Backend
BlockNumMap map[uint64]*types.HeaderInfo BlockNumMap map[uint64]*types.HeaderInfo
} }
@@ -195,7 +195,7 @@ func (r *RPCClient) CallContext(ctx context.Context, obj interface{}, methodName
return err return err
} }
} }
h, err := r.Backend.HeaderByNumber(ctx, num) h, err := r.Backend.Client().HeaderByNumber(ctx, num)
if err != nil { if err != nil {
return err return err
} }
@@ -213,7 +213,7 @@ func (r *RPCClient) CallContext(ctx context.Context, obj interface{}, methodName
if !ok { if !ok {
return errors.Errorf("wrong argument type provided: %T", args[0]) return errors.Errorf("wrong argument type provided: %T", args[0])
} }
h, err := r.Backend.HeaderByHash(ctx, val) h, err := r.Backend.Client().HeaderByHash(ctx, val)
if err != nil { if err != nil {
return err return err
} }
@@ -241,7 +241,7 @@ func (r *RPCClient) BatchCall(b []rpc.BatchElem) error {
if err != nil { if err != nil {
return err return err
} }
h, err := r.Backend.HeaderByNumber(context.Background(), num) h, err := r.Backend.Client().HeaderByNumber(context.Background(), num)
if err != nil { if err != nil {
return err return err
} }

6
beacon-chain/p2p/broadcaster_test.go
View File

@@ -209,7 +209,7 @@ func TestService_BroadcastAttestation(t *testing.T) {
func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) { func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
// Setup bootnode. // Setup bootnode.
cfg := &Config{} cfg := &Config{PingInterval: testPingInterval}
port := 2000 port := 2000
cfg.UDPPort = uint(port) cfg.UDPPort = uint(port)
_, pkey := createAddrAndPrivKey(t) _, pkey := createAddrAndPrivKey(t)
@@ -234,12 +234,16 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
cfg = &Config{ cfg = &Config{
Discv5BootStrapAddrs: []string{bootNode.String()}, Discv5BootStrapAddrs: []string{bootNode.String()},
MaxPeers: 2, MaxPeers: 2,
PingInterval: testPingInterval,
} }
// Setup 2 different hosts // Setup 2 different hosts
for i := 1; i <= 2; i++ { for i := 1; i <= 2; i++ {
h, pkey, ipAddr := createHost(t, port+i) h, pkey, ipAddr := createHost(t, port+i)
cfg.UDPPort = uint(port + i) cfg.UDPPort = uint(port + i)
cfg.TCPPort = uint(port + i) cfg.TCPPort = uint(port + i)
if len(listeners) > 0 {
cfg.Discv5BootStrapAddrs = append(cfg.Discv5BootStrapAddrs, listeners[len(listeners)-1].Self().String())
}
s := &Service{ s := &Service{
cfg: cfg, cfg: cfg,
genesisTime: genesisTime, genesisTime: genesisTime,

4
beacon-chain/p2p/config.go
View File

@@ -1,6 +1,8 @@
package p2p package p2p
import ( import (
"time"
statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state" statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
"github.com/prysmaticlabs/prysm/v5/beacon-chain/db" "github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup" "github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
@@ -15,6 +17,7 @@ type Config struct {
NoDiscovery bool NoDiscovery bool
EnableUPnP bool EnableUPnP bool
StaticPeerID bool StaticPeerID bool
DisableLivenessCheck bool
StaticPeers []string StaticPeers []string
Discv5BootStrapAddrs []string Discv5BootStrapAddrs []string
RelayNodeAddr string RelayNodeAddr string
@@ -27,6 +30,7 @@ type Config struct {
QUICPort uint QUICPort uint
TCPPort uint TCPPort uint
UDPPort uint UDPPort uint
PingInterval time.Duration
MaxPeers uint MaxPeers uint
QueueSize uint QueueSize uint
AllowListCIDR string AllowListCIDR string

6
beacon-chain/p2p/discovery.go
View File

@@ -418,8 +418,10 @@ func (s *Service) createListener(
} }
dv5Cfg := discover.Config{ dv5Cfg := discover.Config{
PrivateKey: privKey, PrivateKey: privKey,
Bootnodes: bootNodes, Bootnodes: bootNodes,
PingInterval: s.cfg.PingInterval,
NoFindnodeLivenessCheck: s.cfg.DisableLivenessCheck,
} }
listener, err := discover.ListenV5(conn, localNode, dv5Cfg) listener, err := discover.ListenV5(conn, localNode, dv5Cfg)

8
beacon-chain/p2p/discovery_test.go
View File

@@ -87,7 +87,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
genesisTime := time.Now() genesisTime := time.Now()
genesisValidatorsRoot := make([]byte, 32) genesisValidatorsRoot := make([]byte, 32)
s := &Service{ s := &Service{
cfg: &Config{UDPPort: uint(port)}, cfg: &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
genesisTime: genesisTime, genesisTime: genesisTime,
genesisValidatorsRoot: genesisValidatorsRoot, genesisValidatorsRoot: genesisValidatorsRoot,
} }
@@ -95,6 +95,10 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer bootListener.Close() defer bootListener.Close()
// Allow bootnode's table to have its initial refresh. This allows
// inbound nodes to be added in.
time.Sleep(5 * time.Second)
bootNode := bootListener.Self() bootNode := bootListener.Self()
var listeners []*listenerWrapper var listeners []*listenerWrapper
@@ -103,6 +107,8 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
cfg := &Config{ cfg := &Config{
Discv5BootStrapAddrs: []string{bootNode.String()}, Discv5BootStrapAddrs: []string{bootNode.String()},
UDPPort: uint(port), UDPPort: uint(port),
PingInterval: testPingInterval,
DisableLivenessCheck: true,
} }
ipAddr, pkey := createAddrAndPrivKey(t) ipAddr, pkey := createAddrAndPrivKey(t)
s = &Service{ s = &Service{

21
beacon-chain/p2p/fork_test.go
View File

@@ -34,8 +34,10 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
genesisValidatorsRoot := make([]byte, fieldparams.RootLength) genesisValidatorsRoot := make([]byte, fieldparams.RootLength)
s := &Service{ s := &Service{
cfg: &Config{ cfg: &Config{
UDPPort: uint(port), UDPPort: uint(port),
StateNotifier: &mock.MockStateNotifier{}, StateNotifier: &mock.MockStateNotifier{},
PingInterval: testPingInterval,
DisableLivenessCheck: true,
}, },
genesisTime: genesisTime, genesisTime: genesisTime,
genesisValidatorsRoot: genesisValidatorsRoot, genesisValidatorsRoot: genesisValidatorsRoot,
@@ -44,11 +46,17 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer bootListener.Close() defer bootListener.Close()
// Allow bootnode's table to have its initial refresh. This allows
// inbound nodes to be added in.
time.Sleep(5 * time.Second)
bootNode := bootListener.Self() bootNode := bootListener.Self()
cfg := &Config{ cfg := &Config{
Discv5BootStrapAddrs: []string{bootNode.String()}, Discv5BootStrapAddrs: []string{bootNode.String()},
UDPPort: uint(port), UDPPort: uint(port),
StateNotifier: &mock.MockStateNotifier{}, StateNotifier: &mock.MockStateNotifier{},
PingInterval: testPingInterval,
DisableLivenessCheck: true,
} }
var listeners []*listenerWrapper var listeners []*listenerWrapper
@@ -124,7 +132,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
genesisTime := time.Now() genesisTime := time.Now()
genesisValidatorsRoot := make([]byte, 32) genesisValidatorsRoot := make([]byte, 32)
s := &Service{ s := &Service{
cfg: &Config{UDPPort: uint(port)}, cfg: &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
genesisTime: genesisTime, genesisTime: genesisTime,
genesisValidatorsRoot: genesisValidatorsRoot, genesisValidatorsRoot: genesisValidatorsRoot,
} }
@@ -132,10 +140,16 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer bootListener.Close() defer bootListener.Close()
// Allow bootnode's table to have its initial refresh. This allows
// inbound nodes to be added in.
time.Sleep(5 * time.Second)
bootNode := bootListener.Self() bootNode := bootListener.Self()
cfg := &Config{ cfg := &Config{
Discv5BootStrapAddrs: []string{bootNode.String()}, Discv5BootStrapAddrs: []string{bootNode.String()},
UDPPort: uint(port), UDPPort: uint(port),
PingInterval: testPingInterval,
DisableLivenessCheck: true,
} }
var listeners []*listenerWrapper var listeners []*listenerWrapper
@@ -143,7 +157,6 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
port := 3000 + i port := 3000 + i
cfg.UDPPort = uint(port) cfg.UDPPort = uint(port)
ipAddr, pkey := createAddrAndPrivKey(t) ipAddr, pkey := createAddrAndPrivKey(t)
c := params.BeaconConfig().Copy() c := params.BeaconConfig().Copy()
nextForkEpoch := primitives.Epoch(i) nextForkEpoch := primitives.Epoch(i)
c.ForkVersionSchedule[[4]byte{'A', 'B', 'C', 'D'}] = nextForkEpoch c.ForkVersionSchedule[[4]byte{'A', 'B', 'C', 'D'}] = nextForkEpoch

10
beacon-chain/p2p/service_test.go
View File

@@ -28,6 +28,8 @@ import (
logTest "github.com/sirupsen/logrus/hooks/test" logTest "github.com/sirupsen/logrus/hooks/test"
) )
const testPingInterval = 100 * time.Millisecond
type mockListener struct { type mockListener struct {
localNode *enode.LocalNode localNode *enode.LocalNode
} }
@@ -186,7 +188,7 @@ func TestListenForNewNodes(t *testing.T) {
params.SetupTestConfigCleanup(t) params.SetupTestConfigCleanup(t)
// Setup bootnode. // Setup bootnode.
notifier := &mock.MockStateNotifier{} notifier := &mock.MockStateNotifier{}
cfg := &Config{StateNotifier: notifier} cfg := &Config{StateNotifier: notifier, PingInterval: testPingInterval, DisableLivenessCheck: true}
port := 2000 port := 2000
cfg.UDPPort = uint(port) cfg.UDPPort = uint(port)
_, pkey := createAddrAndPrivKey(t) _, pkey := createAddrAndPrivKey(t)
@@ -202,6 +204,10 @@ func TestListenForNewNodes(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer bootListener.Close() defer bootListener.Close()
// Allow bootnode's table to have its initial refresh. This allows
// inbound nodes to be added in.
time.Sleep(5 * time.Second)
// Use shorter period for testing. // Use shorter period for testing.
currentPeriod := pollingPeriod currentPeriod := pollingPeriod
pollingPeriod = 1 * time.Second pollingPeriod = 1 * time.Second
@@ -217,6 +223,8 @@ func TestListenForNewNodes(t *testing.T) {
cs := startup.NewClockSynchronizer() cs := startup.NewClockSynchronizer()
cfg = &Config{ cfg = &Config{
Discv5BootStrapAddrs: []string{bootNode.String()}, Discv5BootStrapAddrs: []string{bootNode.String()},
PingInterval: testPingInterval,
DisableLivenessCheck: true,
MaxPeers: 30, MaxPeers: 30,
ClockWaiter: cs, ClockWaiter: cs,
} }

10
beacon-chain/p2p/subnets_test.go
View File

@@ -66,7 +66,7 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
genesisTime := time.Now() genesisTime := time.Now()
bootNodeService := &Service{ bootNodeService := &Service{
cfg: &Config{UDPPort: 2000, TCPPort: 3000, QUICPort: 3000}, cfg: &Config{UDPPort: 2000, TCPPort: 3000, QUICPort: 3000, DisableLivenessCheck: true, PingInterval: testPingInterval},
genesisTime: genesisTime, genesisTime: genesisTime,
genesisValidatorsRoot: genesisValidatorsRoot, genesisValidatorsRoot: genesisValidatorsRoot,
} }
@@ -78,6 +78,10 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
defer bootListener.Close() defer bootListener.Close()
// Allow bootnode's table to have its initial refresh. This allows
// inbound nodes to be added in.
time.Sleep(5 * time.Second)
bootNodeENR := bootListener.Self().String() bootNodeENR := bootListener.Self().String()
// Create 3 nodes, each subscribed to a different subnet. // Create 3 nodes, each subscribed to a different subnet.
@@ -92,6 +96,8 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
UDPPort: uint(2000 + i), UDPPort: uint(2000 + i),
TCPPort: uint(3000 + i), TCPPort: uint(3000 + i),
QUICPort: uint(3000 + i), QUICPort: uint(3000 + i),
PingInterval: testPingInterval,
DisableLivenessCheck: true,
}) })
require.NoError(t, err) require.NoError(t, err)
@@ -133,6 +139,8 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
cfg := &Config{ cfg := &Config{
Discv5BootStrapAddrs: []string{bootNodeENR}, Discv5BootStrapAddrs: []string{bootNodeENR},
PingInterval: testPingInterval,
DisableLivenessCheck: true,
MaxPeers: 30, MaxPeers: 30,
UDPPort: 2010, UDPPort: 2010,
TCPPort: 3010, TCPPort: 3010,

3
beacon-chain/rpc/eth/beacon/handlers.go
View File

@@ -1229,7 +1229,8 @@ func (s *Server) validateBlobSidecars(blk interfaces.SignedBeaconBlock, blobs []
return errors.New("number of blobs, proofs, and commitments do not match") return errors.New("number of blobs, proofs, and commitments do not match")
} }
for i, blob := range blobs { for i, blob := range blobs {
if err := kzg4844.VerifyBlobProof(kzg4844.Blob(blob), kzg4844.Commitment(kzgs[i]), kzg4844.Proof(proofs[i])); err != nil { b := kzg4844.Blob(blob)
if err := kzg4844.VerifyBlobProof(&b, kzg4844.Commitment(kzgs[i]), kzg4844.Proof(proofs[i])); err != nil {
return errors.Wrap(err, "could not verify blob proof") return errors.Wrap(err, "could not verify blob proof")
} }
} }

4
beacon-chain/rpc/prysm/v1alpha1/debug/server.go
View File

@@ -56,9 +56,7 @@ func (_ *Server) SetLoggingLevel(_ context.Context, req *pbrpc.LoggingLevelReque
// Libp2p specific logging. // Libp2p specific logging.
golog.SetAllLoggers(golog.LevelDebug) golog.SetAllLoggers(golog.LevelDebug)
// Geth specific logging. // Geth specific logging.
glogger := gethlog.NewGlogHandler(gethlog.StreamHandler(os.Stderr, gethlog.TerminalFormat(true))) gethlog.SetDefault(gethlog.NewLogger(gethlog.NewTerminalHandlerWithLevel(os.Stderr, gethlog.LvlTrace, true)))
glogger.Verbosity(gethlog.LvlTrace)
gethlog.Root().SetHandler(glogger)
} }
return &empty.Empty{}, nil return &empty.Empty{}, nil
} }

4
cmd/beacon-chain/main.go
View File

@@ -283,9 +283,7 @@ func startNode(ctx *cli.Context, cancel context.CancelFunc) error {
// libp2p specific logging. // libp2p specific logging.
golog.SetAllLoggers(golog.LevelDebug) golog.SetAllLoggers(golog.LevelDebug)
// Geth specific logging. // Geth specific logging.
glogger := gethlog.NewGlogHandler(gethlog.StreamHandler(os.Stderr, gethlog.TerminalFormat(true))) gethlog.SetDefault(gethlog.NewLogger(gethlog.NewTerminalHandlerWithLevel(os.Stderr, gethlog.LvlTrace, true)))
glogger.Verbosity(gethlog.LvlTrace)
gethlog.Root().SetHandler(glogger)
} }
blockchainFlagOpts, err := blockchaincmd.FlagOptions(ctx) blockchainFlagOpts, err := blockchaincmd.FlagOptions(ctx)

1
cmd/prysmctl/testnet/generate_genesis.go
View File

@@ -278,7 +278,6 @@ func generateGenesis(ctx context.Context) (state.BeaconState, error) {
if v > version.Altair { if v > version.Altair {
// set ttd to zero so EL goes post-merge immediately // set ttd to zero so EL goes post-merge immediately
gen.Config.TerminalTotalDifficulty = big.NewInt(0) gen.Config.TerminalTotalDifficulty = big.NewInt(0)
gen.Config.TerminalTotalDifficultyPassed = true
} }
} else { } else {
gen = interop.GethTestnetGenesis(f.GenesisTime, params.BeaconConfig()) gen = interop.GethTestnetGenesis(f.GenesisTime, params.BeaconConfig())

2
contracts/deposit/contract_test.go
View File

@@ -67,7 +67,7 @@ func TestValidatorRegister_OK(t *testing.T) {
}, },
} }
logs, err := testAccount.Backend.FilterLogs(context.Background(), query) logs, err := testAccount.Backend.Client().FilterLogs(context.Background(), query)
assert.NoError(t, err, "Unable to get logs of deposit contract") assert.NoError(t, err, "Unable to get logs of deposit contract")
merkleTreeIndex := make([]uint64, 5) merkleTreeIndex := make([]uint64, 5)

3
contracts/deposit/mock/BUILD.bazel
View File

@@ -10,10 +10,9 @@ go_library(
"//contracts/deposit:go_default_library", "//contracts/deposit:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi:go_default_library", "@com_github_ethereum_go_ethereum//accounts/abi:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library", "@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
"@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_ethereum_go_ethereum//core:go_default_library",
"@com_github_ethereum_go_ethereum//core/types:go_default_library", "@com_github_ethereum_go_ethereum//core/types:go_default_library",
"@com_github_ethereum_go_ethereum//crypto:go_default_library", "@com_github_ethereum_go_ethereum//crypto:go_default_library",
"@com_github_ethereum_go_ethereum//ethclient/simulated:go_default_library",
], ],
) )

13
contracts/deposit/mock/mock.go
View File

@@ -8,11 +8,10 @@ import (
"github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethclient/simulated"
"github.com/prysmaticlabs/prysm/v5/contracts/deposit" "github.com/prysmaticlabs/prysm/v5/contracts/deposit"
) )
@@ -28,13 +27,13 @@ type TestAccount struct {
Addr common.Address Addr common.Address
ContractAddr common.Address ContractAddr common.Address
Contract *deposit.DepositContract Contract *deposit.DepositContract
Backend *backends.SimulatedBackend Backend *simulated.Backend
TxOpts *bind.TransactOpts TxOpts *bind.TransactOpts
} }
// Setup creates the simulated backend with the deposit contract deployed // Setup creates the simulated backend with the deposit contract deployed
func Setup() (*TestAccount, error) { func Setup() (*TestAccount, error) {
genesis := make(core.GenesisAlloc) genesis := make(types.GenesisAlloc)
privKey, err := crypto.GenerateKey() privKey, err := crypto.GenerateKey()
if err != nil { if err != nil {
return nil, err return nil, err
@@ -55,10 +54,10 @@ func Setup() (*TestAccount, error) {
return nil, err return nil, err
} }
startingBalance, _ := new(big.Int).SetString("100000000000000000000000000000000000000", 10) startingBalance, _ := new(big.Int).SetString("100000000000000000000000000000000000000", 10)
genesis[addr] = core.GenesisAccount{Balance: startingBalance} genesis[addr] = types.Account{Balance: startingBalance}
backend := backends.NewSimulatedBackend(genesis, 210000000000) backend := simulated.NewBackend(genesis, simulated.WithBlockGasLimit(210000000000))
contractAddr, _, contract, err := DeployDepositContract(txOpts, backend) contractAddr, _, contract, err := DeployDepositContract(txOpts, backend.Client())
if err != nil { if err != nil {
return nil, err return nil, err
} }

201
deps.bzl
View File

@@ -295,8 +295,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_bits_and_blooms_bitset", name = "com_github_bits_and_blooms_bitset",
importpath = "github.com/bits-and-blooms/bitset", importpath = "github.com/bits-and-blooms/bitset",
sum = "h1:RMyy2mBBShArUAhfVRZJ2xyBO58KCBCtZFShw3umo6k=", sum = "h1:1X2TS7aHz1ELcC0yU1y2stUs/0ig5oMU6STFZGrhvHI=",
version = "v1.11.0", version = "v1.17.0",
) )
go_repository( go_repository(
name = "com_github_bradfitz_go_smtpd", name = "com_github_bradfitz_go_smtpd",
@@ -313,8 +313,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_btcsuite_btcd_btcec_v2", name = "com_github_btcsuite_btcd_btcec_v2",
importpath = "github.com/btcsuite/btcd/btcec/v2", importpath = "github.com/btcsuite/btcd/btcec/v2",
sum = "h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=", sum = "h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ=",
version = "v2.3.2", version = "v2.3.4",
) )
go_repository( go_repository(
name = "com_github_btcsuite_btcd_chaincfg_chainhash", name = "com_github_btcsuite_btcd_chaincfg_chainhash",
@@ -452,8 +452,14 @@ def prysm_deps():
name = "com_github_cockroachdb_errors", name = "com_github_cockroachdb_errors",
build_file_proto_mode = "disable_global", build_file_proto_mode = "disable_global",
importpath = "github.com/cockroachdb/errors", importpath = "github.com/cockroachdb/errors",
sum = "h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8=", sum = "h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I=",
version = "v1.11.1", version = "v1.11.3",
)
go_repository(
name = "com_github_cockroachdb_fifo",
importpath = "github.com/cockroachdb/fifo",
sum = "h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4=",
version = "v0.0.0-20240606204812-0bbfbd93a7ce",
) )
go_repository( go_repository(
name = "com_github_cockroachdb_logtags", name = "com_github_cockroachdb_logtags",
@@ -464,8 +470,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_cockroachdb_pebble", name = "com_github_cockroachdb_pebble",
importpath = "github.com/cockroachdb/pebble", importpath = "github.com/cockroachdb/pebble",
sum = "h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A=", sum = "h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA=",
version = "v0.0.0-20230928194634-aa077af62593", version = "v1.1.2",
) )
go_repository( go_repository(
name = "com_github_cockroachdb_redact", name = "com_github_cockroachdb_redact",
@@ -473,12 +479,6 @@ def prysm_deps():
sum = "h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=", sum = "h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=",
version = "v1.1.5", version = "v1.1.5",
) )
go_repository(
name = "com_github_cockroachdb_sentry_go",
importpath = "github.com/cockroachdb/sentry-go",
sum = "h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM=",
version = "v0.6.1-cockroachdb.2",
)
go_repository( go_repository(
name = "com_github_cockroachdb_tokenbucket", name = "com_github_cockroachdb_tokenbucket",
importpath = "github.com/cockroachdb/tokenbucket", importpath = "github.com/cockroachdb/tokenbucket",
@@ -500,14 +500,14 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_consensys_bavard", name = "com_github_consensys_bavard",
importpath = "github.com/consensys/bavard", importpath = "github.com/consensys/bavard",
sum = "h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ=", sum = "h1:Uw2CGvbXSZWhqK59X0VG/zOjpTFuOMcPLStrp1ihI0A=",
version = "v0.1.13", version = "v0.1.22",
) )
go_repository( go_repository(
name = "com_github_consensys_gnark_crypto", name = "com_github_consensys_gnark_crypto",
importpath = "github.com/consensys/gnark-crypto", importpath = "github.com/consensys/gnark-crypto",
sum = "h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M=", sum = "h1:DDBdl4HaBtdQsq/wfMwJvZNE80sHidrK3Nfrefatm0E=",
version = "v0.12.1", version = "v0.14.0",
) )
go_repository( go_repository(
name = "com_github_containerd_cgroups", name = "com_github_containerd_cgroups",
@@ -549,14 +549,14 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_crate_crypto_go_ipa", name = "com_github_crate_crypto_go_ipa",
importpath = "github.com/crate-crypto/go-ipa", importpath = "github.com/crate-crypto/go-ipa",
sum = "h1:DuBDHVjgGMPki7bAyh91+3cF1Vh34sAEdH8JQgbc2R0=", sum = "h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg=",
version = "v0.0.0-20230601170251-1830d0757c80", version = "v0.0.0-20240724233137-53bbb0ceb27a",
) )
go_repository( go_repository(
name = "com_github_crate_crypto_go_kzg_4844", name = "com_github_crate_crypto_go_kzg_4844",
importpath = "github.com/crate-crypto/go-kzg-4844", importpath = "github.com/crate-crypto/go-kzg-4844",
sum = "h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA=", sum = "h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=",
version = "v0.7.0", version = "v1.1.0",
) )
go_repository( go_repository(
name = "com_github_creack_pty", name = "com_github_creack_pty",
@@ -597,8 +597,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_deckarep_golang_set_v2", name = "com_github_deckarep_golang_set_v2",
importpath = "github.com/deckarep/golang-set/v2", importpath = "github.com/deckarep/golang-set/v2",
sum = "h1:hn6cEZtQ0h3J8kFrHR/NrzyOoTnjgW1+FmNJzQ7y/sA=", sum = "h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM=",
version = "v2.5.0", version = "v2.6.0",
) )
go_repository( go_repository(
name = "com_github_decred_dcrd_crypto_blake256", name = "com_github_decred_dcrd_crypto_blake256",
@@ -654,6 +654,12 @@ def prysm_deps():
sum = "h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=", sum = "h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=",
version = "v0.5.0", version = "v0.5.0",
) )
go_repository(
name = "com_github_donovanhide_eventsource",
importpath = "github.com/donovanhide/eventsource",
sum = "h1:C7t6eeMaEQVy6e8CarIhscYQlNmw5e3G36y7l7Y21Ao=",
version = "v0.0.0-20210830082556-c59027999da0",
)
go_repository( go_repository(
name = "com_github_dop251_goja", name = "com_github_dop251_goja",
importpath = "github.com/dop251/goja", importpath = "github.com/dop251/goja",
@@ -740,21 +746,28 @@ def prysm_deps():
importpath = "github.com/ethereum/c-kzg-4844", importpath = "github.com/ethereum/c-kzg-4844",
patch_args = ["-p1"], patch_args = ["-p1"],
patches = ["//third_party:com_github_ethereum_c_kzg_4844.patch"], patches = ["//third_party:com_github_ethereum_c_kzg_4844.patch"],
sum = "h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY=", sum = "h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA=",
version = "v0.4.0", version = "v1.0.0",
) )
go_repository( go_repository(
name = "com_github_ethereum_go_ethereum", name = "com_github_ethereum_go_ethereum",
build_directives = [ build_directives = [
"gazelle:resolve go github.com/karalabe/usb @prysm//third_party/usb:go_default_library", "gazelle:resolve go github.com/karalabe/usb @prysm//third_party/usb:go_default_library",
"gazelle:resolve go github.com/karalabe/hid @prysm//third_party/hid:go_default_library",
], ],
importpath = "github.com/ethereum/go-ethereum", importpath = "github.com/ethereum/go-ethereum",
patch_args = ["-p1"], patch_args = ["-p1"],
patches = [ patches = [
"//third_party:com_github_ethereum_go_ethereum_secp256k1.patch", "//third_party:com_github_ethereum_go_ethereum_secp256k1.patch",
], ],
sum = "h1:U6TCRciCqZRe4FPXmy1sMGxTfuk8P7u2UoinF3VbaFk=", sum = "h1:8hl57x77HSUo+cXExrURjU/w1VhL+ShCTJrTwcCQSe4=",
version = "v1.13.5", version = "v1.14.12",
)
go_repository(
name = "com_github_ethereum_go_verkle",
importpath = "github.com/ethereum/go-verkle",
sum = "h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8=",
version = "v0.2.2",
) )
go_repository( go_repository(
name = "com_github_evanphx_json_patch", name = "com_github_evanphx_json_patch",
@@ -765,8 +778,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_fatih_color", name = "com_github_fatih_color",
importpath = "github.com/fatih/color", importpath = "github.com/fatih/color",
sum = "h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=", sum = "h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=",
version = "v1.13.0", version = "v1.16.0",
) )
go_repository( go_repository(
name = "com_github_fatih_structs", name = "com_github_fatih_structs",
@@ -783,8 +796,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_ferranbt_fastssz", name = "com_github_ferranbt_fastssz",
importpath = "github.com/ferranbt/fastssz", importpath = "github.com/ferranbt/fastssz",
sum = "h1:9VDpsWq096+oGMDTT/SgBD/VgZYf4pTF+KTPmZ+OaKM=", sum = "h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo=",
version = "v0.0.0-20210120143747-11b9eff30ea9", version = "v0.1.3",
) )
go_repository( go_repository(
name = "com_github_fjl_gencodec", name = "com_github_fjl_gencodec",
@@ -792,12 +805,6 @@ def prysm_deps():
sum = "h1:bBLctRc7kr01YGvaDfgLbTwjFNW5jdp5y5rj8XXBHfY=", sum = "h1:bBLctRc7kr01YGvaDfgLbTwjFNW5jdp5y5rj8XXBHfY=",
version = "v0.0.0-20230517082657-f9840df7b83e", version = "v0.0.0-20230517082657-f9840df7b83e",
) )
go_repository(
name = "com_github_fjl_memsize",
importpath = "github.com/fjl/memsize",
sum = "h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=",
version = "v0.0.0-20190710130421-bcb5799ab5e5",
)
go_repository( go_repository(
name = "com_github_flosch_pongo2_v4", name = "com_github_flosch_pongo2_v4",
importpath = "github.com/flosch/pongo2/v4", importpath = "github.com/flosch/pongo2/v4",
@@ -879,20 +886,20 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_gballet_go_verkle", name = "com_github_gballet_go_verkle",
importpath = "github.com/gballet/go-verkle", importpath = "github.com/gballet/go-verkle",
sum = "h1:vMT47RYsrftsHSTQhqXwC3BYflo38OLC3Y4LtXtLyU0=", sum = "h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE=",
version = "v0.0.0-20230607174250-df487255f46b", version = "v0.1.1-0.20231031103413-a67434b50f46",
) )
go_repository( go_repository(
name = "com_github_gdamore_encoding", name = "com_github_gdamore_encoding",
importpath = "github.com/gdamore/encoding", importpath = "github.com/gdamore/encoding",
sum = "h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=", sum = "h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw=",
version = "v1.0.0", version = "v1.0.1",
) )
go_repository( go_repository(
name = "com_github_gdamore_tcell_v2", name = "com_github_gdamore_tcell_v2",
importpath = "github.com/gdamore/tcell/v2", importpath = "github.com/gdamore/tcell/v2",
sum = "h1:OKbluoP9VYmJwZwq/iLb4BxwKcwGthaa1YNBJIyCySg=", sum = "h1:sg6/UnTM9jGpZU+oFYAsDahfchWAFW8Xx2yFinNSAYU=",
version = "v2.6.0", version = "v2.7.4",
) )
go_repository( go_repository(
name = "com_github_getkin_kin_openapi", name = "com_github_getkin_kin_openapi",
@@ -903,8 +910,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_getsentry_sentry_go", name = "com_github_getsentry_sentry_go",
importpath = "github.com/getsentry/sentry-go", importpath = "github.com/getsentry/sentry-go",
sum = "h1:q6Eo+hS+yoJlTO3uu/azhQadsD8V+jQn2D8VvX1eOyI=", sum = "h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=",
version = "v0.25.0", version = "v0.27.0",
) )
go_repository( go_repository(
name = "com_github_ghemawat_stream", name = "com_github_ghemawat_stream",
@@ -1137,8 +1144,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_golang_jwt_jwt_v4", name = "com_github_golang_jwt_jwt_v4",
importpath = "github.com/golang-jwt/jwt/v4", importpath = "github.com/golang-jwt/jwt/v4",
sum = "h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=", sum = "h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo=",
version = "v4.5.0", version = "v4.5.1",
) )
go_repository( go_repository(
name = "com_github_golang_lint", name = "com_github_golang_lint",
@@ -1163,8 +1170,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_golang_snappy", name = "com_github_golang_snappy",
importpath = "github.com/golang/snappy", importpath = "github.com/golang/snappy",
sum = "h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=", sum = "h1:4bw4WeyTYPp0smaXiJZCNnLrvVBqirQVreixayXezGc=",
version = "v0.0.5-0.20220116011046-fa5810519dcb", version = "v0.0.5-0.20231225225746-43d5d4cd4e0e",
) )
go_repository( go_repository(
name = "com_github_golangci_lint_1", name = "com_github_golangci_lint_1",
@@ -1493,14 +1500,14 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_herumi_bls_eth_go_binary", name = "com_github_herumi_bls_eth_go_binary",
importpath = "github.com/herumi/bls-eth-go-binary", importpath = "github.com/herumi/bls-eth-go-binary",
sum = "h1:wCMygKUQhmcQAjlk2Gquzq6dLmyMv2kF+llRspoRgrk=", sum = "h1:9eeW3EA4epCb7FIHt2luENpAW69MvKGL5jieHlBiP+w=",
version = "v0.0.0-20210917013441-d37c07cfda4e", version = "v1.31.0",
) )
go_repository( go_repository(
name = "com_github_holiman_billy", name = "com_github_holiman_billy",
importpath = "github.com/holiman/billy", importpath = "github.com/holiman/billy",
sum = "h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw=", sum = "h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4=",
version = "v0.0.0-20230718173358-1c7e68d277a7", version = "v0.0.0-20240216141850-2abb0c79d3c4",
) )
go_repository( go_repository(
name = "com_github_holiman_bloomfilter_v2", name = "com_github_holiman_bloomfilter_v2",
@@ -1511,14 +1518,14 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_holiman_goevmlab", name = "com_github_holiman_goevmlab",
importpath = "github.com/holiman/goevmlab", importpath = "github.com/holiman/goevmlab",
sum = "h1:J973NLskKmFIj3EGfpQ1ztUQKdwyJ+fG34638ief0eA=", sum = "h1:JHZ8k9n9G9KXIo1qrvK5Cxah6ax5BR0qVTA9bFYl1oM=",
version = "v0.0.0-20231201084119-c73b3c97929c", version = "v0.0.0-20241121133100-cfa6b078c8c4",
) )
go_repository( go_repository(
name = "com_github_holiman_uint256", name = "com_github_holiman_uint256",
importpath = "github.com/holiman/uint256", importpath = "github.com/holiman/uint256",
sum = "h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU=", sum = "h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA=",
version = "v1.2.4", version = "v1.3.2",
) )
go_repository( go_repository(
name = "com_github_hpcloud_tail", name = "com_github_hpcloud_tail",
@@ -1571,8 +1578,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_inconshreveable_mousetrap", name = "com_github_inconshreveable_mousetrap",
importpath = "github.com/inconshreveable/mousetrap", importpath = "github.com/inconshreveable/mousetrap",
sum = "h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=", sum = "h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=",
version = "v1.0.0", version = "v1.1.0",
) )
go_repository( go_repository(
name = "com_github_influxdata_influxdb1_client", name = "com_github_influxdata_influxdb1_client",
@@ -1745,10 +1752,10 @@ def prysm_deps():
version = "v0.0.0-20180517002512-3bf9e2903213", version = "v0.0.0-20180517002512-3bf9e2903213",
) )
go_repository( go_repository(
name = "com_github_karalabe_usb", name = "com_github_karalabe_hid",
importpath = "github.com/karalabe/usb", importpath = "github.com/karalabe/hid",
sum = "h1:AqsttAyEyIEsNz5WLRwuRwjiT5CMDUfLk6cFJDVPebs=", sum = "h1:msKODTL1m0wigztaqILOtla9HeW1ciscYG4xjLtvk5I=",
version = "v0.0.3-0.20230711191512-61db3e06439c", version = "v1.0.1-0.20240306101548-573246063e52",
) )
go_repository( go_repository(
name = "com_github_kataras_blocks", name = "com_github_kataras_blocks",
@@ -1903,8 +1910,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_leanovate_gopter", name = "com_github_leanovate_gopter",
importpath = "github.com/leanovate/gopter", importpath = "github.com/leanovate/gopter",
sum = "h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=", sum = "h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4=",
version = "v0.2.9", version = "v0.2.11",
) )
go_repository( go_repository(
name = "com_github_leodido_go_urn", name = "com_github_leodido_go_urn",
@@ -2064,14 +2071,14 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_mariusvanderwijden_fuzzyvm", name = "com_github_mariusvanderwijden_fuzzyvm",
importpath = "github.com/MariusVanDerWijden/FuzzyVM", importpath = "github.com/MariusVanDerWijden/FuzzyVM",
sum = "h1:BwEuC3xavrv4HTUDH2fUrKgKooiH3Q/nSVnFGtnzpN0=", sum = "h1:RQtzNvriR3Yu5CvVBTJPwDmfItBT90TWZ3fFondhc08=",
version = "v0.0.0-20240209103030-ec53fa766bf8", version = "v0.0.0-20240516070431-7828990cad7d",
) )
go_repository( go_repository(
name = "com_github_mariusvanderwijden_tx_fuzz", name = "com_github_mariusvanderwijden_tx_fuzz",
importpath = "github.com/MariusVanDerWijden/tx-fuzz", importpath = "github.com/MariusVanDerWijden/tx-fuzz",
sum = "h1:QDTh0xHorSykJ4+2VccBADMeRAVUbnHaWrCPIMtN+Vc=", sum = "h1:Tq4lXivsR8mtoP4RpasUDIUpDLHfN1YhFge/kzrzK78=",
version = "v1.3.3-0.20240227085032-f70dd7c85c97", version = "v1.4.0",
) )
go_repository( go_repository(
name = "com_github_marten_seemann_tcp", name = "com_github_marten_seemann_tcp",
@@ -2130,8 +2137,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_microsoft_go_winio", name = "com_github_microsoft_go_winio",
importpath = "github.com/Microsoft/go-winio", importpath = "github.com/Microsoft/go-winio",
sum = "h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=", sum = "h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=",
version = "v0.6.1", version = "v0.6.2",
) )
go_repository( go_repository(
name = "com_github_miekg_dns", name = "com_github_miekg_dns",
@@ -2775,8 +2782,20 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_protolambda_bls12_381_util", name = "com_github_protolambda_bls12_381_util",
importpath = "github.com/protolambda/bls12-381-util", importpath = "github.com/protolambda/bls12-381-util",
sum = "h1:cZC+usqsYgHtlBaGulVnZ1hfKAi8iWtujBnRLQE698c=", sum = "h1:05DU2wJN7DTU7z28+Q+zejXkIsA/MF8JZQGhtBZZiWk=",
version = "v0.0.0-20220416220906-d8552aa452c7", version = "v0.1.0",
)
go_repository(
name = "com_github_protolambda_zrnt",
importpath = "github.com/protolambda/zrnt",
sum = "h1:KZ48T+3UhsPXNdtE/5QEvGc9DGjUaRI17nJaoznoIaM=",
version = "v0.32.2",
)
go_repository(
name = "com_github_protolambda_ztyp",
importpath = "github.com/protolambda/ztyp",
sum = "h1:rVcL3vBu9W/aV646zF6caLS/dyn9BN8NYiuJzicLNyY=",
version = "v0.2.2",
) )
go_repository( go_repository(
name = "com_github_prysmaticlabs_fastssz", name = "com_github_prysmaticlabs_fastssz",
@@ -2854,8 +2873,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_rivo_tview", name = "com_github_rivo_tview",
importpath = "github.com/rivo/tview", importpath = "github.com/rivo/tview",
sum = "h1:7UMY2qN9VlcY+x9jlhpYe5Bf1zrdhvmfZyLMk2u65BM=", sum = "h1:HxvWMyQ3vKQBlYZq9wfFtjbUeA6UUYZoLJmmwWee43s=",
version = "v0.0.0-20231126152417-33a1d271f2b6", version = "v0.0.0-20240519200218-0ac5f73025a8",
) )
go_repository( go_repository(
name = "com_github_rivo_uniseg", name = "com_github_rivo_uniseg",
@@ -2864,8 +2883,8 @@ def prysm_deps():
"gazelle:exclude gen_properties.go", "gazelle:exclude gen_properties.go",
], ],
importpath = "github.com/rivo/uniseg", importpath = "github.com/rivo/uniseg",
sum = "h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=", sum = "h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=",
version = "v0.4.4", version = "v0.4.7",
) )
go_repository( go_repository(
name = "com_github_rogpeppe_fastuuid", name = "com_github_rogpeppe_fastuuid",
@@ -3104,8 +3123,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_sirupsen_logrus", name = "com_github_sirupsen_logrus",
importpath = "github.com/sirupsen/logrus", importpath = "github.com/sirupsen/logrus",
sum = "h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=", sum = "h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=",
version = "v1.9.0", version = "v1.9.3",
) )
go_repository( go_repository(
name = "com_github_smartystreets_assertions", name = "com_github_smartystreets_assertions",
@@ -3164,8 +3183,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_spf13_cobra", name = "com_github_spf13_cobra",
importpath = "github.com/spf13/cobra", importpath = "github.com/spf13/cobra",
sum = "h1:X+jTBEBqF0bHN+9cSMgmfuvv2VHJ9ezmFNf9Y/XstYU=", sum = "h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=",
version = "v1.5.0", version = "v1.8.1",
) )
go_repository( go_repository(
name = "com_github_spf13_jwalterweatherman", name = "com_github_spf13_jwalterweatherman",
@@ -3317,6 +3336,12 @@ def prysm_deps():
sum = "h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=", sum = "h1:YPXUKf7fYbp/y8xloBqZOw2qaVggbfwMlI8WM3wZUJ0=",
version = "v1.2.7", version = "v1.2.7",
) )
go_repository(
name = "com_github_umbracle_gohashtree",
importpath = "github.com/umbracle/gohashtree",
sum = "h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg=",
version = "v0.0.2-alpha.0.20230207094856-5b775a815c10",
)
go_repository( go_repository(
name = "com_github_urfave_cli", name = "com_github_urfave_cli",
importpath = "github.com/urfave/cli", importpath = "github.com/urfave/cli",
@@ -3326,8 +3351,8 @@ def prysm_deps():
go_repository( go_repository(
name = "com_github_urfave_cli_v2", name = "com_github_urfave_cli_v2",
importpath = "github.com/urfave/cli/v2", importpath = "github.com/urfave/cli/v2",
sum = "h1:3f3AMg3HpThFNT4I++TKOejZO8yU55t3JnnSr4S4QEI=", sum = "h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=",
version = "v2.26.0", version = "v2.27.1",
) )
go_repository( go_repository(
name = "com_github_urfave_negroni", name = "com_github_urfave_negroni",
@@ -3407,8 +3432,8 @@ def prysm_deps():
"gazelle:resolve go github.com/herumi/bls-eth-go-binary/bls @herumi_bls_eth_go_binary//:go_default_library", "gazelle:resolve go github.com/herumi/bls-eth-go-binary/bls @herumi_bls_eth_go_binary//:go_default_library",
], ],
importpath = "github.com/wealdtech/go-eth2-types/v2", importpath = "github.com/wealdtech/go-eth2-types/v2",
sum = "h1:tiA6T88M6XQIbrV5Zz53l1G5HtRERcxQfmET225V4Ls=", sum = "h1:b5aXlNBLKgjAg/Fft9VvGlqAUCQMP5LzYhlHRrr4yPg=",
version = "v2.5.2", version = "v2.8.2",
) )
go_repository( go_repository(
name = "com_github_wealdtech_go_eth2_util", name = "com_github_wealdtech_go_eth2_util",
@@ -4397,8 +4422,8 @@ def prysm_deps():
go_repository( go_repository(
name = "in_gopkg_natefinch_lumberjack_v2", name = "in_gopkg_natefinch_lumberjack_v2",
importpath = "gopkg.in/natefinch/lumberjack.v2", importpath = "gopkg.in/natefinch/lumberjack.v2",
sum = "h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=", sum = "h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=",
version = "v2.0.0", version = "v2.2.1",
) )
go_repository( go_repository(
name = "in_gopkg_redis_v4", name = "in_gopkg_redis_v4",

62
go.mod
View File

@@ -5,27 +5,26 @@ go 1.22.0
toolchain go1.22.10 toolchain go1.22.10
require ( require (
github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240209103030-ec53fa766bf8 github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240516070431-7828990cad7d
github.com/MariusVanDerWijden/tx-fuzz v1.3.3-0.20240227085032-f70dd7c85c97 github.com/MariusVanDerWijden/tx-fuzz v1.4.0
github.com/aristanetworks/goarista v0.0.0-20200805130819-fd197cf57d96 github.com/aristanetworks/goarista v0.0.0-20200805130819-fd197cf57d96
github.com/bazelbuild/rules_go v0.23.2 github.com/bazelbuild/rules_go v0.23.2
github.com/btcsuite/btcd/btcec/v2 v2.3.2 github.com/btcsuite/btcd/btcec/v2 v2.3.4
github.com/consensys/gnark-crypto v0.12.1 github.com/consensys/gnark-crypto v0.14.0
github.com/crate-crypto/go-kzg-4844 v0.7.0 github.com/crate-crypto/go-kzg-4844 v1.1.0
github.com/d4l3k/messagediff v1.2.1 github.com/d4l3k/messagediff v1.2.1
github.com/dgraph-io/ristretto v0.0.4-0.20210318174700-74754f61e018 github.com/dgraph-io/ristretto v0.0.4-0.20210318174700-74754f61e018
github.com/dustin/go-humanize v1.0.0 github.com/dustin/go-humanize v1.0.0
github.com/emicklei/dot v0.11.0 github.com/emicklei/dot v0.11.0
github.com/ethereum/go-ethereum v1.13.5 github.com/ethereum/go-ethereum v1.14.12
github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5
github.com/fsnotify/fsnotify v1.6.0 github.com/fsnotify/fsnotify v1.6.0
github.com/ghodss/yaml v1.0.0 github.com/ghodss/yaml v1.0.0
github.com/go-yaml/yaml v2.1.0+incompatible github.com/go-yaml/yaml v2.1.0+incompatible
github.com/gogo/protobuf v1.3.2 github.com/gogo/protobuf v1.3.2
github.com/golang-jwt/jwt/v4 v4.5.0 github.com/golang-jwt/jwt/v4 v4.5.1
github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c
github.com/golang/protobuf v1.5.4 github.com/golang/protobuf v1.5.4
github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb github.com/golang/snappy v0.0.5-0.20231225225746-43d5d4cd4e0e
github.com/google/go-cmp v0.6.0 github.com/google/go-cmp v0.6.0
github.com/google/gofuzz v1.2.0 github.com/google/gofuzz v1.2.0
github.com/google/uuid v1.6.0 github.com/google/uuid v1.6.0
@@ -33,8 +32,8 @@ require (
github.com/grpc-ecosystem/go-grpc-middleware v1.2.2 github.com/grpc-ecosystem/go-grpc-middleware v1.2.2
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d
github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e github.com/herumi/bls-eth-go-binary v1.31.0
github.com/holiman/uint256 v1.2.4 github.com/holiman/uint256 v1.3.2
github.com/ianlancetaylor/cgosymbolizer v0.0.0-20200424224625-be1b05b0b279 github.com/ianlancetaylor/cgosymbolizer v0.0.0-20200424224625-be1b05b0b279
github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-log/v2 v2.5.1
github.com/jedib0t/go-pretty/v6 v6.5.4 github.com/jedib0t/go-pretty/v6 v6.5.4
@@ -69,15 +68,15 @@ require (
github.com/r3labs/sse/v2 v2.10.0 github.com/r3labs/sse/v2 v2.10.0
github.com/rs/cors v1.7.0 github.com/rs/cors v1.7.0
github.com/schollz/progressbar/v3 v3.3.4 github.com/schollz/progressbar/v3 v3.3.4
github.com/sirupsen/logrus v1.9.0 github.com/sirupsen/logrus v1.9.3
github.com/spf13/afero v1.10.0 github.com/spf13/afero v1.10.0
github.com/status-im/keycard-go v0.2.0 github.com/status-im/keycard-go v0.2.0
github.com/stretchr/testify v1.9.0 github.com/stretchr/testify v1.9.0
github.com/supranational/blst v0.3.11 github.com/supranational/blst v0.3.13
github.com/thomaso-mirodin/intmath v0.0.0-20160323211736-5dc6d854e46e github.com/thomaso-mirodin/intmath v0.0.0-20160323211736-5dc6d854e46e
github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279 github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279
github.com/tyler-smith/go-bip39 v1.1.0 github.com/tyler-smith/go-bip39 v1.1.0
github.com/urfave/cli/v2 v2.26.0 github.com/urfave/cli/v2 v2.27.1
github.com/uudashr/gocognit v1.0.5 github.com/uudashr/gocognit v1.0.5
github.com/wealdtech/go-bytesutil v1.1.1 github.com/wealdtech/go-bytesutil v1.1.1
github.com/wealdtech/go-eth2-util v1.6.3 github.com/wealdtech/go-eth2-util v1.6.3
@@ -109,43 +108,45 @@ require (
require ( require (
github.com/BurntSushi/toml v1.3.2 // indirect github.com/BurntSushi/toml v1.3.2 // indirect
github.com/DataDog/zstd v1.5.5 // indirect github.com/DataDog/zstd v1.5.5 // indirect
github.com/Microsoft/go-winio v0.6.1 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect
github.com/VictoriaMetrics/fastcache v1.12.2 // indirect github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
github.com/benbjohnson/clock v1.3.5 // indirect github.com/benbjohnson/clock v1.3.5 // indirect
github.com/beorn7/perks v1.0.1 // indirect github.com/beorn7/perks v1.0.1 // indirect
github.com/bits-and-blooms/bitset v1.11.0 // indirect github.com/bits-and-blooms/bitset v1.17.0 // indirect
github.com/cespare/cp v1.1.1 // indirect github.com/cespare/cp v1.1.1 // indirect
github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash v1.1.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/chzyer/readline v1.5.1 // indirect github.com/chzyer/readline v1.5.1 // indirect
github.com/cockroachdb/errors v1.11.1 // indirect github.com/cockroachdb/errors v1.11.3 // indirect
github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect
github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 // indirect github.com/cockroachdb/pebble v1.1.2 // indirect
github.com/cockroachdb/redact v1.1.5 // indirect github.com/cockroachdb/redact v1.1.5 // indirect
github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
github.com/consensys/bavard v0.1.13 // indirect github.com/consensys/bavard v0.1.22 // indirect
github.com/containerd/cgroups v1.1.0 // indirect github.com/containerd/cgroups v1.1.0 // indirect
github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/coreos/go-systemd/v22 v22.5.0 // indirect
github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect
github.com/davecgh/go-spew v1.1.1 // indirect github.com/davecgh/go-spew v1.1.1 // indirect
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c // indirect github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c // indirect
github.com/deckarep/golang-set/v2 v2.5.0 // indirect github.com/deckarep/golang-set/v2 v2.6.0 // indirect
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect
github.com/deepmap/oapi-codegen v1.8.2 // indirect github.com/deepmap/oapi-codegen v1.8.2 // indirect
github.com/dlclark/regexp2 v1.7.0 // indirect github.com/dlclark/regexp2 v1.7.0 // indirect
github.com/docker/go-units v0.5.0 // indirect github.com/docker/go-units v0.5.0 // indirect
github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127 // indirect github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127 // indirect
github.com/elastic/gosigar v0.14.3 // indirect github.com/elastic/gosigar v0.14.3 // indirect
github.com/ethereum/c-kzg-4844 v0.4.0 // indirect github.com/ethereum/c-kzg-4844 v1.0.0 // indirect
github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9 // indirect github.com/ethereum/go-verkle v0.2.2 // indirect
github.com/ferranbt/fastssz v0.1.3 // indirect
github.com/flynn/noise v1.1.0 // indirect github.com/flynn/noise v1.1.0 // indirect
github.com/francoispqt/gojay v1.2.13 // indirect github.com/francoispqt/gojay v1.2.13 // indirect
github.com/getsentry/sentry-go v0.25.0 // indirect github.com/getsentry/sentry-go v0.27.0 // indirect
github.com/go-logr/stdr v1.2.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
github.com/go-stack/stack v1.8.1 // indirect
github.com/go-task/slim-sprig/v3 v3.0.0 // indirect github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
github.com/godbus/dbus/v5 v5.1.0 // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect
github.com/gofrs/flock v0.8.1 // indirect github.com/gofrs/flock v0.8.1 // indirect
@@ -156,9 +157,9 @@ require (
github.com/graph-gophers/graphql-go v1.3.0 // indirect github.com/graph-gophers/graphql-go v1.3.0 // indirect
github.com/hashicorp/go-bexpr v0.1.10 // indirect github.com/hashicorp/go-bexpr v0.1.10 // indirect
github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 // indirect github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 // indirect
github.com/holiman/bloomfilter/v2 v2.0.3 // indirect github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
github.com/holiman/goevmlab v0.0.0-20231201084119-c73b3c97929c // indirect github.com/holiman/goevmlab v0.0.0-20241121133100-cfa6b078c8c4 // indirect
github.com/huin/goupnp v1.3.0 // indirect github.com/huin/goupnp v1.3.0 // indirect
github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
@@ -167,7 +168,6 @@ require (
github.com/jackpal/go-nat-pmp v1.0.2 // indirect github.com/jackpal/go-nat-pmp v1.0.2 // indirect
github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a // indirect github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a // indirect
github.com/karalabe/usb v0.0.3-0.20230711191512-61db3e06439c // indirect
github.com/klauspost/compress v1.17.9 // indirect github.com/klauspost/compress v1.17.9 // indirect
github.com/klauspost/cpuid/v2 v2.2.8 // indirect github.com/klauspost/cpuid/v2 v2.2.8 // indirect
github.com/koron/go-ssdp v0.0.4 // indirect github.com/koron/go-ssdp v0.0.4 // indirect
@@ -236,7 +236,7 @@ require (
github.com/quic-go/quic-go v0.48.2 // indirect github.com/quic-go/quic-go v0.48.2 // indirect
github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66 // indirect github.com/quic-go/webtransport-go v0.8.1-0.20241018022711-4ac2c9250e66 // indirect
github.com/raulk/go-watchdog v1.3.0 // indirect github.com/raulk/go-watchdog v1.3.0 // indirect
github.com/rivo/uniseg v0.4.4 // indirect github.com/rivo/uniseg v0.4.7 // indirect
github.com/rogpeppe/go-internal v1.12.0 // indirect github.com/rogpeppe/go-internal v1.12.0 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect
github.com/shirou/gopsutil v3.21.11+incompatible // indirect github.com/shirou/gopsutil v3.21.11+incompatible // indirect
@@ -245,7 +245,7 @@ require (
github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
github.com/tklauser/go-sysconf v0.3.13 // indirect github.com/tklauser/go-sysconf v0.3.13 // indirect
github.com/tklauser/numcpus v0.7.0 // indirect github.com/tklauser/numcpus v0.7.0 // indirect
github.com/wealdtech/go-eth2-types/v2 v2.5.2 // indirect github.com/wealdtech/go-eth2-types/v2 v2.8.2 // indirect
github.com/wlynxg/anet v0.0.4 // indirect github.com/wlynxg/anet v0.0.4 // indirect
github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
github.com/yusufpapurcu/wmi v1.2.3 // indirect github.com/yusufpapurcu/wmi v1.2.3 // indirect
@@ -262,7 +262,7 @@ require (
golang.org/x/time v0.5.0 // indirect golang.org/x/time v0.5.0 // indirect
gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
lukechampine.com/blake3 v1.3.0 // indirect lukechampine.com/blake3 v1.3.0 // indirect
rsc.io/tmplfunc v0.0.3 // indirect rsc.io/tmplfunc v0.0.3 // indirect
@@ -273,7 +273,7 @@ require (
require ( require (
github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf
github.com/fatih/color v1.13.0 // indirect github.com/fatih/color v1.16.0 // indirect
github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect
github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/logr v1.4.2 // indirect
github.com/go-ole/go-ole v1.3.0 // indirect github.com/go-ole/go-ole v1.3.0 // indirect

132
go.sum
View File

@@ -51,12 +51,12 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym
github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ= github.com/DataDog/zstd v1.5.5 h1:oWf5W7GtOLgp6bciQYDmhHHjdhYkALu6S/5Ni9ZgSvQ=
github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= github.com/DataDog/zstd v1.5.5/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240209103030-ec53fa766bf8 h1:BwEuC3xavrv4HTUDH2fUrKgKooiH3Q/nSVnFGtnzpN0= github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240516070431-7828990cad7d h1:RQtzNvriR3Yu5CvVBTJPwDmfItBT90TWZ3fFondhc08=
github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240209103030-ec53fa766bf8/go.mod h1:L1QpLBqXlboJMOC2hndG95d1eiElzKsBhjzcuy8pxeM= github.com/MariusVanDerWijden/FuzzyVM v0.0.0-20240516070431-7828990cad7d/go.mod h1:gWTykV/ZinShgltWofTEJY4TsletuvGhB6l4+Ai2F+E=
github.com/MariusVanDerWijden/tx-fuzz v1.3.3-0.20240227085032-f70dd7c85c97 h1:QDTh0xHorSykJ4+2VccBADMeRAVUbnHaWrCPIMtN+Vc= github.com/MariusVanDerWijden/tx-fuzz v1.4.0 h1:Tq4lXivsR8mtoP4RpasUDIUpDLHfN1YhFge/kzrzK78=
github.com/MariusVanDerWijden/tx-fuzz v1.3.3-0.20240227085032-f70dd7c85c97/go.mod h1:xcjGtET6+7KeDHcwLQp3sIfyFALtoTjzZgY8Y+RUozM= github.com/MariusVanDerWijden/tx-fuzz v1.4.0/go.mod h1:gmOVECg7o5FY5VU3DQ/fY0zTk/ExBdMkUGz0vA8qqms=
github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
@@ -100,14 +100,12 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/bits-and-blooms/bitset v1.11.0 h1:RMyy2mBBShArUAhfVRZJ2xyBO58KCBCtZFShw3umo6k= github.com/bits-and-blooms/bitset v1.17.0 h1:1X2TS7aHz1ELcC0yU1y2stUs/0ig5oMU6STFZGrhvHI=
github.com/bits-and-blooms/bitset v1.11.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/bits-and-blooms/bitset v1.17.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g= github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
github.com/bradfitz/gomemcache v0.0.0-20170208213004-1952afaa557d/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60= github.com/bradfitz/gomemcache v0.0.0-20170208213004-1952afaa557d/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ=
github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
@@ -141,21 +139,23 @@ github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnht
github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
github.com/cockroachdb/errors v1.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8= github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I=
github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw= github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8=
github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4=
github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE=
github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= github.com/cockroachdb/pebble v1.1.2 h1:CUh2IPtR4swHlEj48Rhfzw6l/d0qA31fItcIszQVIsA=
github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= github.com/cockroachdb/pebble v1.1.2/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU=
github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=
github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo=
github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= github.com/consensys/bavard v0.1.22 h1:Uw2CGvbXSZWhqK59X0VG/zOjpTFuOMcPLStrp1ihI0A=
github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= github.com/consensys/bavard v0.1.22/go.mod h1:k/zVjHHC4B+PQy1Pg7fgvG3ALicQw540Crag8qx+dZs=
github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= github.com/consensys/gnark-crypto v0.14.0 h1:DDBdl4HaBtdQsq/wfMwJvZNE80sHidrK3Nfrefatm0E=
github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= github.com/consensys/gnark-crypto v0.14.0/go.mod h1:CU4UijNPsHawiVGNxe9co07FkzCeWHHrb1li/n1XoU0=
github.com/containerd/cgroups v0.0.0-20201119153540-4cbc285b3327/go.mod h1:ZJeTFisyysqgcCdecO57Dj79RfL0LNeGiFUqLYQRYLE= github.com/containerd/cgroups v0.0.0-20201119153540-4cbc285b3327/go.mod h1:ZJeTFisyysqgcCdecO57Dj79RfL0LNeGiFUqLYQRYLE=
github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM= github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw= github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
@@ -172,8 +172,10 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM= github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg=
github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM=
github.com/crate-crypto/go-kzg-4844 v1.1.0 h1:EN/u9k2TF6OWSHrCCDBBU6GLNMq88OspHHlMnHfoyU4=
github.com/crate-crypto/go-kzg-4844 v1.1.0/go.mod h1:JolLjpSff1tCCJKaJx4psrlEdlXuJEC996PL3tTAFks=
github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4= github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
@@ -184,8 +186,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c h1:pFUpOrbxDR6AkioZ1ySsx5yxlDQZ8stG2b88gTPxgJU= github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c h1:pFUpOrbxDR6AkioZ1ySsx5yxlDQZ8stG2b88gTPxgJU=
github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c/go.mod h1:6UhI8N9EjYm1c2odKpFpAYeR8dsBeM7PtzQhRgxRr9U= github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c/go.mod h1:6UhI8N9EjYm1c2odKpFpAYeR8dsBeM7PtzQhRgxRr9U=
github.com/deckarep/golang-set/v2 v2.5.0 h1:hn6cEZtQ0h3J8kFrHR/NrzyOoTnjgW1+FmNJzQ7y/sA= github.com/deckarep/golang-set/v2 v2.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM=
github.com/deckarep/golang-set/v2 v2.5.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
@@ -231,17 +233,18 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA=
github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
github.com/ethereum/go-ethereum v1.13.5 h1:U6TCRciCqZRe4FPXmy1sMGxTfuk8P7u2UoinF3VbaFk= github.com/ethereum/go-ethereum v1.14.12 h1:8hl57x77HSUo+cXExrURjU/w1VhL+ShCTJrTwcCQSe4=
github.com/ethereum/go-ethereum v1.13.5/go.mod h1:yMTu38GSuyxaYzQMViqNmQ1s3cE84abZexQmTgenWk0= github.com/ethereum/go-ethereum v1.14.12/go.mod h1:RAC2gVMWJ6FkxSPESfbshrcKpIokgQKsVKmAuqdekDY=
github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8=
github.com/ethereum/go-verkle v0.2.2/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9 h1:9VDpsWq096+oGMDTT/SgBD/VgZYf4pTF+KTPmZ+OaKM=
github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM= github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c= github.com/ferranbt/fastssz v0.1.3 h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo=
github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= github.com/ferranbt/fastssz v0.1.3/go.mod h1:0Y9TEd/9XuFlh7mskMPfXiI2Dkw4Ddg9EyXt1W7MRvE=
github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc= github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg= github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg=
github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag= github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag=
@@ -262,8 +265,8 @@ github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 h1:f6D9Hr8x
github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4=
github.com/getsentry/sentry-go v0.25.0 h1:q6Eo+hS+yoJlTO3uu/azhQadsD8V+jQn2D8VvX1eOyI= github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=
github.com/getsentry/sentry-go v0.25.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0= github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
@@ -309,8 +312,6 @@ github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5Nq
github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
github.com/go-stack/stack v1.6.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-stack/stack v1.6.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
@@ -329,8 +330,8 @@ github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zV
github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= github.com/golang-jwt/jwt/v4 v4.5.1 h1:JdqV9zKUdtaa9gdPlywC3aeoEsR681PlKC+4F5gQgeo=
github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-jwt/jwt/v4 v4.5.1/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c h1:HoqgYR60VYu5+0BuG6pjeGp7LKEPZnHt+dUClx9PeIs= github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c h1:HoqgYR60VYu5+0BuG6pjeGp7LKEPZnHt+dUClx9PeIs=
github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c/go.mod h1:sam69Hju0uq+5uvLJUMDlsKlQ21Vrs1Kd/1YFPNYdOU= github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c/go.mod h1:sam69Hju0uq+5uvLJUMDlsKlQ21Vrs1Kd/1YFPNYdOU=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -370,8 +371,8 @@ github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8l
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= github.com/golang/snappy v0.0.5-0.20231225225746-43d5d4cd4e0e h1:4bw4WeyTYPp0smaXiJZCNnLrvVBqirQVreixayXezGc=
github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.5-0.20231225225746-43d5d4cd4e0e/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y= github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
@@ -480,16 +481,16 @@ github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0m
github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
github.com/herumi/bls-eth-go-binary v0.0.0-20210130185500-57372fb27371/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U= github.com/herumi/bls-eth-go-binary v0.0.0-20210130185500-57372fb27371/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e h1:wCMygKUQhmcQAjlk2Gquzq6dLmyMv2kF+llRspoRgrk= github.com/herumi/bls-eth-go-binary v1.31.0 h1:9eeW3EA4epCb7FIHt2luENpAW69MvKGL5jieHlBiP+w=
github.com/herumi/bls-eth-go-binary v0.0.0-20210917013441-d37c07cfda4e/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U= github.com/herumi/bls-eth-go-binary v1.31.0/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw= github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4=
github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc=
github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
github.com/holiman/goevmlab v0.0.0-20231201084119-c73b3c97929c h1:J973NLskKmFIj3EGfpQ1ztUQKdwyJ+fG34638ief0eA= github.com/holiman/goevmlab v0.0.0-20241121133100-cfa6b078c8c4 h1:JHZ8k9n9G9KXIo1qrvK5Cxah6ax5BR0qVTA9bFYl1oM=
github.com/holiman/goevmlab v0.0.0-20231201084119-c73b3c97929c/go.mod h1:K6KFgcQq1U9ksldcRyLYcwtj4nUTPn4rEaZtX4Gjofc= github.com/holiman/goevmlab v0.0.0-20241121133100-cfa6b078c8c4/go.mod h1:+DBd7lup47uusCYWbkJPfHRG4LYjBHvyXU0c+z26/U4=
github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA=
github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc=
@@ -534,12 +535,9 @@ github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfV
github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a h1:FaWFmfWdAUKbSCtOU2QjDaorUexogfaMgbipgYATUMU= github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a h1:FaWFmfWdAUKbSCtOU2QjDaorUexogfaMgbipgYATUMU=
github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a/go.mod h1:UJSiEoRfvx3hP73CvoARgeLjaIOjybY9vj8PUPPFGeU= github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a/go.mod h1:UJSiEoRfvx3hP73CvoARgeLjaIOjybY9vj8PUPPFGeU=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213 h1:qGQQKEcAR99REcMpsXCp3lJ03zYT1PkRd3kQGPn9GVg= github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213 h1:qGQQKEcAR99REcMpsXCp3lJ03zYT1PkRd3kQGPn9GVg=
github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw= github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw=
github.com/karalabe/usb v0.0.3-0.20230711191512-61db3e06439c h1:AqsttAyEyIEsNz5WLRwuRwjiT5CMDUfLk6cFJDVPebs=
github.com/karalabe/usb v0.0.3-0.20230711191512-61db3e06439c/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -574,8 +572,8 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg= github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg=
github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4=
github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c=
github.com/leodido/go-urn v1.2.3 h1:6BE2vPT0lqoz3fmOesHZiaiFh7889ssCo2GMvLCfiuA= github.com/leodido/go-urn v1.2.3 h1:6BE2vPT0lqoz3fmOesHZiaiFh7889ssCo2GMvLCfiuA=
github.com/leodido/go-urn v1.2.3/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4= github.com/leodido/go-urn v1.2.3/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8= github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
@@ -628,7 +626,6 @@ github.com/mattn/go-colorable v0.0.10-0.20170816031813-ad5389df28cd/go.mod h1:9v
github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.2/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.2/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
@@ -918,8 +915,8 @@ github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtD
github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20190826022208-cac0b30c2563/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -968,8 +965,8 @@ github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPx
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
@@ -1014,8 +1011,8 @@ github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXl
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= github.com/supranational/blst v0.3.13 h1:AYeSxdOMacwu7FBmpfloBz5pbFXDmJL33RuwnKtmTjk=
github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/supranational/blst v0.3.13/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA= github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
@@ -1035,11 +1032,13 @@ github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279 h1:+Ly
github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279/go.mod h1:GA3+Mq3kt3tYAfM0WZCu7ofy+GW9PuGysHfhr+6JX7s= github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279/go.mod h1:GA3+Mq3kt3tYAfM0WZCu7ofy+GW9PuGysHfhr+6JX7s=
github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10 h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg=
github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10/go.mod h1:x/Pa0FF5Te9kdrlZKJK82YmAkvL8+f989USgz6Jiw7M=
github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/urfave/cli/v2 v2.26.0 h1:3f3AMg3HpThFNT4I++TKOejZO8yU55t3JnnSr4S4QEI= github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
github.com/urfave/cli/v2 v2.26.0/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
github.com/uudashr/gocognit v1.0.5 h1:rrSex7oHr3/pPLQ0xoWq108XMU8s678FJcQ+aSfOHa4= github.com/uudashr/gocognit v1.0.5 h1:rrSex7oHr3/pPLQ0xoWq108XMU8s678FJcQ+aSfOHa4=
github.com/uudashr/gocognit v1.0.5/go.mod h1:wgYz0mitoKOTysqxTDMOUXg+Jb5SvtihkfmugIZYpEA= github.com/uudashr/gocognit v1.0.5/go.mod h1:wgYz0mitoKOTysqxTDMOUXg+Jb5SvtihkfmugIZYpEA=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
@@ -1049,8 +1048,9 @@ github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49u
github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM= github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
github.com/wealdtech/go-bytesutil v1.1.1 h1:ocEg3Ke2GkZ4vQw5lp46rmO+pfqCCTgq35gqOy8JKVc= github.com/wealdtech/go-bytesutil v1.1.1 h1:ocEg3Ke2GkZ4vQw5lp46rmO+pfqCCTgq35gqOy8JKVc=
github.com/wealdtech/go-bytesutil v1.1.1/go.mod h1:jENeMqeTEU8FNZyDFRVc7KqBdRKSnJ9CCh26TcuNb9s= github.com/wealdtech/go-bytesutil v1.1.1/go.mod h1:jENeMqeTEU8FNZyDFRVc7KqBdRKSnJ9CCh26TcuNb9s=
github.com/wealdtech/go-eth2-types/v2 v2.5.2 h1:tiA6T88M6XQIbrV5Zz53l1G5HtRERcxQfmET225V4Ls=
github.com/wealdtech/go-eth2-types/v2 v2.5.2/go.mod h1:8lkNUbgklSQ4LZ2oMSuxSdR7WwJW3L9ge1dcoCVyzws= github.com/wealdtech/go-eth2-types/v2 v2.5.2/go.mod h1:8lkNUbgklSQ4LZ2oMSuxSdR7WwJW3L9ge1dcoCVyzws=
github.com/wealdtech/go-eth2-types/v2 v2.8.2 h1:b5aXlNBLKgjAg/Fft9VvGlqAUCQMP5LzYhlHRrr4yPg=
github.com/wealdtech/go-eth2-types/v2 v2.8.2/go.mod h1:IAz9Lz1NVTaHabQa+4zjk2QDKMv8LVYo0n46M9o/TXw=
github.com/wealdtech/go-eth2-util v1.6.3 h1:2INPeOR35x5LdFFpSzyw954WzTD+DFyHe3yKlJnG5As= github.com/wealdtech/go-eth2-util v1.6.3 h1:2INPeOR35x5LdFFpSzyw954WzTD+DFyHe3yKlJnG5As=
github.com/wealdtech/go-eth2-util v1.6.3/go.mod h1:0hFMj/qtio288oZFHmAbCnPQ9OB3c4WFzs5NVPKTY4k= github.com/wealdtech/go-eth2-util v1.6.3/go.mod h1:0hFMj/qtio288oZFHmAbCnPQ9OB3c4WFzs5NVPKTY4k=
github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.3 h1:SxrDVSr+oXuT1x8kZt4uWqNCvv5xXEGV9zd7cuSrZS8= github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.3 h1:SxrDVSr+oXuT1x8kZt4uWqNCvv5xXEGV9zd7cuSrZS8=
@@ -1626,8 +1626,8 @@ gopkg.in/jcmturner/dnsutils.v1 v1.0.1/go.mod h1:m3v+5svpVOhtFAP/wSz+yzh4Mc0Fg7eR
gopkg.in/jcmturner/goidentity.v3 v3.0.0/go.mod h1:oG2kH0IvSYNIu80dVAyu/yoefjq1mNfM5bm88whjWx4= gopkg.in/jcmturner/goidentity.v3 v3.0.0/go.mod h1:oG2kH0IvSYNIu80dVAyu/yoefjq1mNfM5bm88whjWx4=
gopkg.in/jcmturner/gokrb5.v7 v7.5.0/go.mod h1:l8VISx+WGYp+Fp7KRbsiUuXTTOnxIc3Tuvyavf11/WM= gopkg.in/jcmturner/gokrb5.v7 v7.5.0/go.mod h1:l8VISx+WGYp+Fp7KRbsiUuXTTOnxIc3Tuvyavf11/WM=
gopkg.in/jcmturner/rpc.v1 v1.1.0/go.mod h1:YIdkC4XfD6GXbzje11McwsDuOlZQSb9W4vfLvuNnlv8= gopkg.in/jcmturner/rpc.v1 v1.1.0/go.mod h1:YIdkC4XfD6GXbzje11McwsDuOlZQSb9W4vfLvuNnlv8=
gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
gopkg.in/redis.v4 v4.2.4/go.mod h1:8KREHdypkCEojGKQcjMqAODMICIVwZAONWq8RowTITA= gopkg.in/redis.v4 v4.2.4/go.mod h1:8KREHdypkCEojGKQcjMqAODMICIVwZAONWq8RowTITA=
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

6
nogo_config.json
View File

@@ -208,5 +208,11 @@
"external/.*": "Third party code", "external/.*": "Third party code",
"rules_go_work-.*": "Third party code" "rules_go_work-.*": "Third party code"
} }
},
"loopclosure": {
"exclude_files": {
"external/com_github_ethereum_go_ethereum/.*": "Unsafe third party code",
"rules_go_work-.*": "Third party code"
}
} }
} }

1
runtime/debug/BUILD.bazel
View File

@@ -18,7 +18,6 @@ go_library(
importpath = "github.com/prysmaticlabs/prysm/v5/runtime/debug", importpath = "github.com/prysmaticlabs/prysm/v5/runtime/debug",
visibility = ["//visibility:public"], visibility = ["//visibility:public"],
deps = [ deps = [
"@com_github_fjl_memsize//memsizeui:go_default_library",
"@com_github_prometheus_client_golang//prometheus:go_default_library", "@com_github_prometheus_client_golang//prometheus:go_default_library",
"@com_github_prometheus_client_golang//prometheus/promauto:go_default_library", "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
"@com_github_sirupsen_logrus//:go_default_library", "@com_github_sirupsen_logrus//:go_default_library",

4
runtime/debug/debug.go
View File

@@ -37,7 +37,6 @@ import (
"sync" "sync"
"time" "time"
"github.com/fjl/memsize/memsizeui"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
"github.com/urfave/cli/v2" "github.com/urfave/cli/v2"
) )
@@ -45,8 +44,6 @@ import (
// Handler is the global debugging handler. // Handler is the global debugging handler.
var Handler = new(HandlerT) var Handler = new(HandlerT)
// Memsize is the memsizeui Handler(?).
var Memsize memsizeui.Handler
var ( var (
// PProfFlag to enable pprof HTTP server. // PProfFlag to enable pprof HTTP server.
PProfFlag = &cli.BoolFlag{ PProfFlag = &cli.BoolFlag{
@@ -351,7 +348,6 @@ func Setup(ctx *cli.Context) error {
} }
func startPProf(address string) { func startPProf(address string) {
http.Handle("/memsize/", http.StripPrefix("/memsize", &Memsize))
log.WithField("addr", fmt.Sprintf("http://%s/debug/pprof", address)).Info("Starting pprof server") log.WithField("addr", fmt.Sprintf("http://%s/debug/pprof", address)).Info("Starting pprof server")
go func() { go func() {
srv := &http.Server{ srv := &http.Server{

74
runtime/interop/genesis.go
View File

@@ -1,13 +1,13 @@
package interop package interop
import ( import (
"fmt"
"math" "math"
"math/big" "math/big"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
clparams "github.com/prysmaticlabs/prysm/v5/config/params" clparams "github.com/prysmaticlabs/prysm/v5/config/params"
"github.com/prysmaticlabs/prysm/v5/time/slots" "github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -126,57 +126,51 @@ func GethPragueTime(genesisTime uint64, cfg *clparams.BeaconChainConfig) *uint64
// like in an e2e test. The parameters are minimal but the full value is returned unmarshaled so that it can be // like in an e2e test. The parameters are minimal but the full value is returned unmarshaled so that it can be
// customized as desired. // customized as desired.
func GethTestnetGenesis(genesisTime uint64, cfg *clparams.BeaconChainConfig) *core.Genesis { func GethTestnetGenesis(genesisTime uint64, cfg *clparams.BeaconChainConfig) *core.Genesis {
ttd, ok := big.NewInt(0).SetString(clparams.BeaconConfig().TerminalTotalDifficulty, 10)
if !ok {
panic(fmt.Sprintf("unable to parse TerminalTotalDifficulty as an integer = %s", clparams.BeaconConfig().TerminalTotalDifficulty))
}
shanghaiTime := GethShanghaiTime(genesisTime, cfg) shanghaiTime := GethShanghaiTime(genesisTime, cfg)
if cfg.CapellaForkEpoch == 0 {
shanghaiTime = &genesisTime
}
cancunTime := GethCancunTime(genesisTime, cfg) cancunTime := GethCancunTime(genesisTime, cfg)
if cfg.DenebForkEpoch == 0 {
cancunTime = &genesisTime
}
pragueTime := GethPragueTime(genesisTime, cfg) pragueTime := GethPragueTime(genesisTime, cfg)
if cfg.ElectraForkEpoch == 0 {
pragueTime = &genesisTime
}
cc := &params.ChainConfig{ cc := &params.ChainConfig{
ChainID: big.NewInt(defaultTestChainId), ChainID: big.NewInt(defaultTestChainId),
HomesteadBlock: bigz, HomesteadBlock: bigz,
DAOForkBlock: bigz, DAOForkBlock: bigz,
EIP150Block: bigz, EIP150Block: bigz,
EIP155Block: bigz, EIP155Block: bigz,
EIP158Block: bigz, EIP158Block: bigz,
ByzantiumBlock: bigz, ByzantiumBlock: bigz,
ConstantinopleBlock: bigz, ConstantinopleBlock: bigz,
PetersburgBlock: bigz, PetersburgBlock: bigz,
IstanbulBlock: bigz, IstanbulBlock: bigz,
MuirGlacierBlock: bigz, MuirGlacierBlock: bigz,
BerlinBlock: bigz, BerlinBlock: bigz,
LondonBlock: bigz, LondonBlock: bigz,
ArrowGlacierBlock: bigz, ArrowGlacierBlock: bigz,
GrayGlacierBlock: bigz, GrayGlacierBlock: bigz,
MergeNetsplitBlock: bigz, MergeNetsplitBlock: bigz,
TerminalTotalDifficulty: ttd, TerminalTotalDifficulty: bigz,
TerminalTotalDifficultyPassed: false, ShanghaiTime: shanghaiTime,
Clique: &params.CliqueConfig{ CancunTime: cancunTime,
Period: cfg.SecondsPerETH1Block, PragueTime: pragueTime,
Epoch: 20000,
},
ShanghaiTime: shanghaiTime,
CancunTime: cancunTime,
PragueTime: pragueTime,
} }
da := defaultDepositContractAllocation(cfg.DepositContractAddress) da := defaultDepositContractAllocation(cfg.DepositContractAddress)
ma := minerAllocation() ma := minerAllocation()
extra, err := hexutil.Decode(DefaultCliqueSigner)
if err != nil {
panic(fmt.Sprintf("unable to decode DefaultCliqueSigner, with error %v", err.Error()))
}
return &core.Genesis{ return &core.Genesis{
Config: cc, Config: cc,
Nonce: 0, // overridden for authorized signer votes in clique, so we should leave it empty? Nonce: 0, // overridden for authorized signer votes in clique, so we should leave it empty?
Timestamp: genesisTime, Timestamp: genesisTime,
ExtraData: extra,
GasLimit: cfg.DefaultBuilderGasLimit, GasLimit: cfg.DefaultBuilderGasLimit,
Difficulty: common.HexToHash(defaultDifficulty).Big(), Difficulty: common.HexToHash(defaultDifficulty).Big(),
Mixhash: common.HexToHash(defaultMixhash), Mixhash: common.HexToHash(defaultMixhash),
Coinbase: common.HexToAddress(defaultCoinbase), Coinbase: common.HexToAddress(defaultCoinbase),
Alloc: core.GenesisAlloc{ Alloc: types.GenesisAlloc{
da.Address: da.Account, da.Address: da.Account,
ma.Address: ma.Account, ma.Address: ma.Account,
}, },
@@ -186,13 +180,13 @@ func GethTestnetGenesis(genesisTime uint64, cfg *clparams.BeaconChainConfig) *co
type depositAllocation struct { type depositAllocation struct {
Address common.Address Address common.Address
Account core.GenesisAccount Account types.Account
} }
func minerAllocation() depositAllocation { func minerAllocation() depositAllocation {
return depositAllocation{ return depositAllocation{
Address: common.HexToAddress(defaultMinerAddress), Address: common.HexToAddress(defaultMinerAddress),
Account: core.GenesisAccount{ Account: types.Account{
Balance: minerBalance, Balance: minerBalance,
}, },
} }
@@ -209,7 +203,7 @@ func defaultDepositContractAllocation(contractAddress string) depositAllocation
} }
return depositAllocation{ return depositAllocation{
Address: common.HexToAddress(contractAddress), Address: common.HexToAddress(contractAddress),
Account: core.GenesisAccount{ Account: types.Account{
Code: codeBytes, Code: codeBytes,
Storage: s, Storage: s,
Balance: bigz, Balance: bigz,

7
runtime/interop/premine-state.go
View File

@@ -634,7 +634,7 @@ func (s *PremineGenesisConfig) setExecutionPayload(g state.BeaconState) error {
GasLimit: gb.GasLimit(), GasLimit: gb.GasLimit(),
GasUsed: gb.GasUsed(), GasUsed: gb.GasUsed(),
Timestamp: gb.Time(), Timestamp: gb.Time(),
ExtraData: gb.Extra()[:32], ExtraData: gb.Extra(),
BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength), BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength),
BlockHash: gb.Hash().Bytes(), BlockHash: gb.Hash().Bytes(),
Transactions: make([][]byte, 0), Transactions: make([][]byte, 0),
@@ -673,7 +673,7 @@ func (s *PremineGenesisConfig) setExecutionPayload(g state.BeaconState) error {
GasLimit: gb.GasLimit(), GasLimit: gb.GasLimit(),
GasUsed: gb.GasUsed(), GasUsed: gb.GasUsed(),
Timestamp: gb.Time(), Timestamp: gb.Time(),
ExtraData: gb.Extra()[:32], ExtraData: gb.Extra(),
BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength), BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength),
BlockHash: gb.Hash().Bytes(), BlockHash: gb.Hash().Bytes(),
Transactions: make([][]byte, 0), Transactions: make([][]byte, 0),
@@ -689,7 +689,6 @@ func (s *PremineGenesisConfig) setExecutionPayload(g state.BeaconState) error {
if err != nil { if err != nil {
return err return err
} }
ed, err := blocks.WrappedExecutionPayloadHeaderCapella(eph) ed, err := blocks.WrappedExecutionPayloadHeaderCapella(eph)
if err != nil { if err != nil {
return err return err
@@ -710,7 +709,7 @@ func (s *PremineGenesisConfig) setExecutionPayload(g state.BeaconState) error {
GasLimit: gb.GasLimit(), GasLimit: gb.GasLimit(),
GasUsed: gb.GasUsed(), GasUsed: gb.GasUsed(),
Timestamp: gb.Time(), Timestamp: gb.Time(),
ExtraData: gb.Extra()[:32], ExtraData: gb.Extra(),
BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength), BaseFeePerGas: bytesutil.PadTo(bytesutil.ReverseByteOrder(gb.BaseFee().Bytes()), fieldparams.RootLength),
BlockHash: gb.Hash().Bytes(), BlockHash: gb.Hash().Bytes(),
Transactions: make([][]byte, 0), Transactions: make([][]byte, 0),

2
testing/endtoend/components/eth1/BUILD.bazel
View File

@@ -28,12 +28,14 @@ go_library(
"//testing/endtoend/types:go_default_library", "//testing/endtoend/types:go_default_library",
"//testing/middleware/engine-api-proxy:go_default_library", "//testing/middleware/engine-api-proxy:go_default_library",
"//testing/util:go_default_library", "//testing/util:go_default_library",
"@com_github_ethereum_go_ethereum//:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library", "@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library",
"@com_github_ethereum_go_ethereum//accounts/keystore:go_default_library", "@com_github_ethereum_go_ethereum//accounts/keystore:go_default_library",
"@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library",
"@com_github_ethereum_go_ethereum//core/types:go_default_library", "@com_github_ethereum_go_ethereum//core/types:go_default_library",
"@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library", "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
"@com_github_ethereum_go_ethereum//ethclient:go_default_library", "@com_github_ethereum_go_ethereum//ethclient:go_default_library",
"@com_github_ethereum_go_ethereum//ethclient/gethclient:go_default_library",
"@com_github_ethereum_go_ethereum//rpc:go_default_library", "@com_github_ethereum_go_ethereum//rpc:go_default_library",
"@com_github_holiman_uint256//:go_default_library", "@com_github_holiman_uint256//:go_default_library",
"@com_github_mariusvanderwijden_fuzzyvm//filler:go_default_library", "@com_github_mariusvanderwijden_fuzzyvm//filler:go_default_library",

2
testing/endtoend/components/eth1/miner.go
View File

@@ -143,11 +143,9 @@ func (m *Miner) initAttempt(ctx context.Context, attempt int) (*os.File, error)
"--ws.origins=\"*\"", "--ws.origins=\"*\"",
"--ipcdisable", "--ipcdisable",
"--verbosity=4", "--verbosity=4",
"--mine",
fmt.Sprintf("--unlock=%s", EthAddress), fmt.Sprintf("--unlock=%s", EthAddress),
"--allow-insecure-unlock", "--allow-insecure-unlock",
"--syncmode=full", "--syncmode=full",
fmt.Sprintf("--miner.etherbase=%s", EthAddress),
fmt.Sprintf("--txpool.locals=%s", EthAddress), fmt.Sprintf("--txpool.locals=%s", EthAddress),
fmt.Sprintf("--password=%s", pwFile), fmt.Sprintf("--password=%s", pwFile),
} }

8
testing/endtoend/components/eth1/node.go
View File

@@ -127,12 +127,16 @@ func (node *Node) Start(ctx context.Context) error {
if err = runCmd.Start(); err != nil { if err = runCmd.Start(); err != nil {
return fmt.Errorf("failed to start eth1 chain: %w", err) return fmt.Errorf("failed to start eth1 chain: %w", err)
} }
if err = helpers.WaitForTextInFile(errLog, "Started P2P networking"); err != nil { // TODO: the log is not very descriptive but it's always the first log where the chain has
// - a peer
// - http server started
// - genesis synced
if err = helpers.WaitForTextInFile(errLog, "Node revalidated"); err != nil {
kerr := runCmd.Process.Kill() kerr := runCmd.Process.Kill()
if kerr != nil { if kerr != nil {
log.WithError(kerr).Error("error sending kill to failed node command process") log.WithError(kerr).Error("error sending kill to failed node command process")
} }
retryErr = fmt.Errorf("P2P log not found, this means the eth1 chain had issues starting: %w", err) retryErr = fmt.Errorf("the first node revalidated log not found, this means the eth1 chain had issues starting: %w", err)
continue continue
} }
node.cmd = runCmd node.cmd = runCmd

45
testing/endtoend/components/eth1/transactions.go
View File

@@ -12,11 +12,13 @@ import (
"github.com/MariusVanDerWijden/FuzzyVM/filler" "github.com/MariusVanDerWijden/FuzzyVM/filler"
txfuzz "github.com/MariusVanDerWijden/tx-fuzz" txfuzz "github.com/MariusVanDerWijden/tx-fuzz"
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/accounts/keystore"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto/kzg4844" "github.com/ethereum/go-ethereum/crypto/kzg4844"
"github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/ethclient/gethclient"
"github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/rpc"
"github.com/holiman/uint256" "github.com/holiman/uint256"
"github.com/pkg/errors" "github.com/pkg/errors"
@@ -257,27 +259,47 @@ func RandomBlobTx(rpc *rpc.Client, f *filler.Filler, sender common.Address, nonc
// 4844 transaction without AL // 4844 transaction without AL
tip, feecap, err := getCaps(rpc, gasPrice) tip, feecap, err := getCaps(rpc, gasPrice)
if err != nil { if err != nil {
return nil, err return nil, errors.Wrap(err, "getCaps")
} }
data, err := randomBlobData() data, err := randomBlobData()
if err != nil { if err != nil {
return nil, err return nil, errors.Wrap(err, "randomBlobData")
} }
return New4844Tx(nonce, &to, gas, chainID, tip, feecap, value, code, big.NewInt(1000000), data, make(types.AccessList, 0)), nil return New4844Tx(nonce, &to, gas, chainID, tip, feecap, value, code, big.NewInt(1000000), data, make(types.AccessList, 0)), nil
case 1: case 1:
// 4844 transaction with AL // 4844 transaction with AL nonce, to, value, gas, gasPrice, code
tx := types.NewTransaction(nonce, to, value, gas, gasPrice, code) tx := types.NewTx(&types.LegacyTx{
al, err := txfuzz.CreateAccessList(rpc, tx, sender) Nonce: nonce,
To: &to,
Value: value,
Gas: gas,
GasPrice: gasPrice,
Data: code,
})
// TODO: replace call with al, err := txfuzz.CreateAccessList(rpc, tx, sender) when txfuzz is fixed in new release
// an error occurs mentioning error="CreateAccessList: both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified"
msg := ethereum.CallMsg{
From: sender,
To: tx.To(),
Gas: tx.Gas(),
GasPrice: tx.GasPrice(),
Value: tx.Value(),
Data: tx.Data(),
AccessList: nil,
}
geth := gethclient.New(rpc)
al, _, _, err := geth.CreateAccessList(context.Background(), msg)
if err != nil { if err != nil {
return nil, err return nil, errors.Wrap(err, "CreateAccessList")
} }
tip, feecap, err := getCaps(rpc, gasPrice) tip, feecap, err := getCaps(rpc, gasPrice)
if err != nil { if err != nil {
return nil, err return nil, errors.Wrap(err, "getCaps")
} }
data, err := randomBlobData() data, err := randomBlobData()
if err != nil { if err != nil {
return nil, err return nil, errors.Wrap(err, "randomBlobData")
} }
return New4844Tx(nonce, &to, gas, chainID, tip, feecap, value, code, big.NewInt(1000000), data, *al), nil return New4844Tx(nonce, &to, gas, chainID, tip, feecap, value, code, big.NewInt(1000000), data, *al), nil
} }
@@ -342,17 +364,18 @@ func EncodeBlobs(data []byte) ([]kzg4844.Blob, []kzg4844.Commitment, []kzg4844.P
versionedHashes []common.Hash versionedHashes []common.Hash
) )
for _, blob := range blobs { for _, blob := range blobs {
commit, err := kzg4844.BlobToCommitment(blob) b := blob
commit, err := kzg4844.BlobToCommitment(&b)
if err != nil { if err != nil {
return nil, nil, nil, nil, err return nil, nil, nil, nil, err
} }
commits = append(commits, commit) commits = append(commits, commit)
proof, err := kzg4844.ComputeBlobProof(blob, commit) proof, err := kzg4844.ComputeBlobProof(&b, commit)
if err != nil { if err != nil {
return nil, nil, nil, nil, err return nil, nil, nil, nil, err
} }
if err := kzg4844.VerifyBlobProof(blob, commit, proof); err != nil { if err := kzg4844.VerifyBlobProof(&b, commit, proof); err != nil {
return nil, nil, nil, nil, err return nil, nil, nil, nil, err
} }
proofs = append(proofs, proof) proofs = append(proofs, proof)

31
testing/endtoend/endtoend_setup_test.go
View File

@@ -7,6 +7,7 @@ import (
"testing" "testing"
"github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/config/params"
"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
ev "github.com/prysmaticlabs/prysm/v5/testing/endtoend/evaluators" ev "github.com/prysmaticlabs/prysm/v5/testing/endtoend/evaluators"
"github.com/prysmaticlabs/prysm/v5/testing/endtoend/evaluators/beaconapi" "github.com/prysmaticlabs/prysm/v5/testing/endtoend/evaluators/beaconapi"
e2eParams "github.com/prysmaticlabs/prysm/v5/testing/endtoend/params" e2eParams "github.com/prysmaticlabs/prysm/v5/testing/endtoend/params"
@@ -53,16 +54,17 @@ func e2eMinimal(t *testing.T, cfg *params.BeaconChainConfig, cfgo ...types.E2ECo
ev.DepositedValidatorsAreActive, ev.DepositedValidatorsAreActive,
ev.ValidatorsVoteWithTheMajority, ev.ValidatorsVoteWithTheMajority,
ev.ColdStateCheckpoint, ev.ColdStateCheckpoint,
ev.AltairForkTransition,
ev.BellatrixForkTransition,
ev.CapellaForkTransition,
ev.DenebForkTransition,
ev.FinishedSyncing, ev.FinishedSyncing,
ev.AllNodesHaveSameHead, ev.AllNodesHaveSameHead,
ev.ValidatorSyncParticipation, ev.ValidatorSyncParticipation,
ev.FeeRecipientIsPresent, ev.FeeRecipientIsPresent,
//ev.TransactionsPresent, TODO: Re-enable Transaction evaluator once it tx pool issues are fixed. //ev.TransactionsPresent, TODO: Re-enable Transaction evaluator once it tx pool issues are fixed.
} }
evals = addIfForkSet(evals, cfg.AltairForkEpoch, ev.AltairForkTransition)
evals = addIfForkSet(evals, cfg.BellatrixForkEpoch, ev.BellatrixForkTransition)
evals = addIfForkSet(evals, cfg.CapellaForkEpoch, ev.CapellaForkTransition)
evals = addIfForkSet(evals, cfg.DenebForkEpoch, ev.DenebForkTransition)
testConfig := &types.E2EConfig{ testConfig := &types.E2EConfig{
BeaconFlags: []string{ BeaconFlags: []string{
fmt.Sprintf("--slots-per-archive-point=%d", params.BeaconConfig().SlotsPerEpoch*16), fmt.Sprintf("--slots-per-archive-point=%d", params.BeaconConfig().SlotsPerEpoch*16),
@@ -128,15 +130,16 @@ func e2eMainnet(t *testing.T, usePrysmSh, useMultiClient bool, cfg *params.Beaco
ev.ValidatorsHaveWithdrawn, ev.ValidatorsHaveWithdrawn,
ev.DepositedValidatorsAreActive, ev.DepositedValidatorsAreActive,
ev.ColdStateCheckpoint, ev.ColdStateCheckpoint,
ev.AltairForkTransition,
ev.BellatrixForkTransition,
ev.CapellaForkTransition,
ev.DenebForkTransition,
ev.FinishedSyncing, ev.FinishedSyncing,
ev.AllNodesHaveSameHead, ev.AllNodesHaveSameHead,
ev.FeeRecipientIsPresent, ev.FeeRecipientIsPresent,
//ev.TransactionsPresent, TODO: Re-enable Transaction evaluator once it tx pool issues are fixed. //ev.TransactionsPresent, TODO: Re-enable Transaction evaluator once it tx pool issues are fixed.
} }
evals = addIfForkSet(evals, cfg.AltairForkEpoch, ev.AltairForkTransition)
evals = addIfForkSet(evals, cfg.BellatrixForkEpoch, ev.BellatrixForkTransition)
evals = addIfForkSet(evals, cfg.CapellaForkEpoch, ev.CapellaForkTransition)
evals = addIfForkSet(evals, cfg.DenebForkEpoch, ev.DenebForkTransition)
testConfig := &types.E2EConfig{ testConfig := &types.E2EConfig{
BeaconFlags: []string{ BeaconFlags: []string{
fmt.Sprintf("--slots-per-archive-point=%d", params.BeaconConfig().SlotsPerEpoch*16), fmt.Sprintf("--slots-per-archive-point=%d", params.BeaconConfig().SlotsPerEpoch*16),
@@ -172,6 +175,18 @@ func e2eMainnet(t *testing.T, usePrysmSh, useMultiClient bool, cfg *params.Beaco
return newTestRunner(t, testConfig) return newTestRunner(t, testConfig)
} }
// addIfForkSet appends the specified transition if epoch is valid.
func addIfForkSet(
evals []types.Evaluator,
fork primitives.Epoch,
transition types.Evaluator,
) []types.Evaluator {
if fork != 0 && fork != params.BeaconConfig().FarFutureEpoch {
evals = append(evals, transition)
}
return evals
}
func scenarioEvals() []types.Evaluator { func scenarioEvals() []types.Evaluator {
return []types.Evaluator{ return []types.Evaluator{
ev.PeersConnect, ev.PeersConnect,

14
testing/endtoend/evaluators/builder.go
View File

@@ -3,11 +3,13 @@ package evaluators
import ( import (
"context" "context"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/pkg/errors" "github.com/pkg/errors"
"github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/config/params"
"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives" "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
"github.com/prysmaticlabs/prysm/v5/encoding/ssz" "github.com/prysmaticlabs/prysm/v5/encoding/ssz"
ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1" ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
"github.com/prysmaticlabs/prysm/v5/runtime/version"
"github.com/prysmaticlabs/prysm/v5/testing/endtoend/policies" "github.com/prysmaticlabs/prysm/v5/testing/endtoend/policies"
e2etypes "github.com/prysmaticlabs/prysm/v5/testing/endtoend/types" e2etypes "github.com/prysmaticlabs/prysm/v5/testing/endtoend/types"
"github.com/prysmaticlabs/prysm/v5/time/slots" "github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -64,7 +66,7 @@ func builderActive(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) err
if err != nil { if err != nil {
return err return err
} }
if forkStartSlot == b.Block().Slot() || forkStartSlot+1 == b.Block().Slot() { if forkStartSlot == b.Block().Slot() || forkStartSlot+1 == b.Block().Slot() || lowestBound <= 1 {
// Skip fork slot and the next one, as we don't send FCUs yet. // Skip fork slot and the next one, as we don't send FCUs yet.
continue continue
} }
@@ -82,10 +84,10 @@ func builderActive(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) err
continue continue
} }
if string(execPayload.ExtraData()) != "prysm-builder" { if string(execPayload.ExtraData()) != "prysm-builder" {
return errors.Errorf("block with slot %d was not built by the builder. It has an extra data of %s", b.Block().Slot(), string(execPayload.ExtraData())) return errors.Errorf("%s block with slot %d was not built by the builder. It has an extra data of %s and txRoot of %s", version.String(b.Version()), b.Block().Slot(), string(execPayload.ExtraData()), hexutil.Encode(txRoot))
} }
if execPayload.GasLimit() == 0 { if execPayload.GasLimit() == 0 {
return errors.Errorf("block with slot %d has a gas limit of 0, when it should be in the 30M range", b.Block().Slot()) return errors.Errorf("%s block with slot %d has a gas limit of 0, when it should be in the 30M range", version.String(b.Version()), b.Block().Slot())
} }
} }
if lowestBound == currEpoch { if lowestBound == currEpoch {
@@ -107,7 +109,7 @@ func builderActive(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) err
if err != nil { if err != nil {
return err return err
} }
if forkStartSlot == b.Block().Slot() || forkStartSlot+1 == b.Block().Slot() { if forkStartSlot == b.Block().Slot() || forkStartSlot+1 == b.Block().Slot() || lowestBound <= 1 {
// Skip fork slot and the next one, as we don't send FCUs yet. // Skip fork slot and the next one, as we don't send FCUs yet.
continue continue
} }
@@ -125,10 +127,10 @@ func builderActive(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) err
continue continue
} }
if string(execPayload.ExtraData()) != "prysm-builder" { if string(execPayload.ExtraData()) != "prysm-builder" {
return errors.Errorf("block with slot %d was not built by the builder. It has an extra data of %s", b.Block().Slot(), string(execPayload.ExtraData())) return errors.Errorf("%s block with slot %d was not built by the builder. It has an extra data of %s and txRoot of %s", version.String(b.Version()), b.Block().Slot(), string(execPayload.ExtraData()), hexutil.Encode(txRoot))
} }
if execPayload.GasLimit() == 0 { if execPayload.GasLimit() == 0 {
return errors.Errorf("block with slot %d has a gas limit of 0, when it should be in the 30M range", b.Block().Slot()) return errors.Errorf("%s block with slot %d has a gas limit of 0, when it should be in the 30M range", version.String(b.Version()), b.Block().Slot())
} }
} }
return nil return nil

1
testing/endtoend/geth_deps.go
View File

@@ -12,7 +12,6 @@ import (
_ "github.com/ethereum/go-ethereum/eth" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/eth" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/eth/downloader" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/eth/downloader" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/ethclient" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/ethclient" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/les" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/log" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/log" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/metrics" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/metrics" // Required for go-ethereum e2e.
_ "github.com/ethereum/go-ethereum/node" // Required for go-ethereum e2e. _ "github.com/ethereum/go-ethereum/node" // Required for go-ethereum e2e.

4
testing/endtoend/mainnet_e2e_test.go
View File

@@ -10,10 +10,10 @@ import (
// Run mainnet e2e config with the current release validator against latest beacon node. // Run mainnet e2e config with the current release validator against latest beacon node.
func TestEndToEnd_MainnetConfig_ValidatorAtCurrentRelease(t *testing.T) { func TestEndToEnd_MainnetConfig_ValidatorAtCurrentRelease(t *testing.T) {
r := e2eMainnet(t, true, false, types.InitForkCfg(version.Phase0, version.Deneb, params.E2EMainnetTestConfig())) r := e2eMainnet(t, true, false, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2EMainnetTestConfig()))
r.run() r.run()
} }
func TestEndToEnd_MainnetConfig_MultiClient(t *testing.T) { func TestEndToEnd_MainnetConfig_MultiClient(t *testing.T) {
e2eMainnet(t, false, true, types.InitForkCfg(version.Phase0, version.Deneb, params.E2EMainnetTestConfig()), types.WithValidatorCrossClient()).run() e2eMainnet(t, false, true, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2EMainnetTestConfig()), types.WithValidatorCrossClient()).run()
} }

2
testing/endtoend/mainnet_scenario_e2e_test.go
View File

@@ -9,7 +9,7 @@ import (
) )
func TestEndToEnd_MultiScenarioRun_Multiclient(t *testing.T) { func TestEndToEnd_MultiScenarioRun_Multiclient(t *testing.T) {
runner := e2eMainnet(t, false, true, types.InitForkCfg(version.Phase0, version.Deneb, params.E2EMainnetTestConfig()), types.WithEpochs(24)) runner := e2eMainnet(t, false, true, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2EMainnetTestConfig()), types.WithEpochs(24))
runner.config.Evaluators = scenarioEvalsMulti() runner.config.Evaluators = scenarioEvalsMulti()
runner.config.EvalInterceptor = runner.multiScenarioMulticlient runner.config.EvalInterceptor = runner.multiScenarioMulticlient
runner.scenarioRunner() runner.scenarioRunner()

4
testing/endtoend/minimal_builder_e2e_test.go
View File

@@ -9,11 +9,11 @@ import (
) )
func TestEndToEnd_MinimalConfig_WithBuilder(t *testing.T) { func TestEndToEnd_MinimalConfig_WithBuilder(t *testing.T) {
r := e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder()) r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder())
r.run() r.run()
} }
func TestEndToEnd_MinimalConfig_WithBuilder_ValidatorRESTApi(t *testing.T) { func TestEndToEnd_MinimalConfig_WithBuilder_ValidatorRESTApi(t *testing.T) {
r := e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi()) r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi())
r.run() r.run()
} }

2
testing/endtoend/minimal_e2e_test.go
View File

@@ -9,6 +9,6 @@ import (
) )
func TestEndToEnd_MinimalConfig(t *testing.T) { func TestEndToEnd_MinimalConfig(t *testing.T) {
r := e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync()) r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync())
r.run() r.run()
} }

10
testing/endtoend/minimal_scenario_e2e_test.go
View File

@@ -9,7 +9,7 @@ import (
) )
func TestEndToEnd_MultiScenarioRun(t *testing.T) { func TestEndToEnd_MultiScenarioRun(t *testing.T) {
runner := e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithEpochs(26)) runner := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithEpochs(26))
runner.config.Evaluators = scenarioEvals() runner.config.Evaluators = scenarioEvals()
runner.config.EvalInterceptor = runner.multiScenario runner.config.EvalInterceptor = runner.multiScenario
@@ -17,20 +17,20 @@ func TestEndToEnd_MultiScenarioRun(t *testing.T) {
} }
func TestEndToEnd_MinimalConfig_Web3Signer(t *testing.T) { func TestEndToEnd_MinimalConfig_Web3Signer(t *testing.T) {
e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithRemoteSigner()).run() e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithRemoteSigner()).run()
} }
func TestEndToEnd_MinimalConfig_Web3Signer_PersistentKeys(t *testing.T) { func TestEndToEnd_MinimalConfig_Web3Signer_PersistentKeys(t *testing.T) {
e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithRemoteSignerAndPersistentKeysFile()).run() e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithRemoteSignerAndPersistentKeysFile()).run()
} }
func TestEndToEnd_MinimalConfig_ValidatorRESTApi(t *testing.T) { func TestEndToEnd_MinimalConfig_ValidatorRESTApi(t *testing.T) {
e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithValidatorRESTApi()).run() e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithValidatorRESTApi()).run()
} }
func TestEndToEnd_ScenarioRun_EEOffline(t *testing.T) { func TestEndToEnd_ScenarioRun_EEOffline(t *testing.T) {
t.Skip("TODO(#10242) Prysm is current unable to handle an offline e2e") t.Skip("TODO(#10242) Prysm is current unable to handle an offline e2e")
runner := e2eMinimal(t, types.InitForkCfg(version.Phase0, version.Deneb, params.E2ETestConfig())) runner := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Deneb, params.E2ETestConfig()))
runner.config.Evaluators = scenarioEvals() runner.config.Evaluators = scenarioEvals()
runner.config.EvalInterceptor = runner.eeOffline runner.config.EvalInterceptor = runner.eeOffline

11
testing/middleware/builder/builder.go
View File

@@ -757,7 +757,8 @@ func modifyExecutionPayload(execPayload engine.ExecutableData, fees *big.Int, pr
if err != nil { if err != nil {
return &engine.ExecutionPayloadEnvelope{}, err return &engine.ExecutionPayloadEnvelope{}, err
} }
return engine.BlockToExecutableData(modifiedBlock, fees, nil /*blobs*/), nil // TODO: update to include requests for electra
return engine.BlockToExecutableData(modifiedBlock, fees, nil /*blobs*/, nil /*requests*/), nil
} }
// This modifies the provided payload to imprint the builder's extra data // This modifies the provided payload to imprint the builder's extra data
@@ -798,7 +799,13 @@ func executableDataToBlock(params engine.ExecutableData, prevBeaconRoot []byte)
pRoot := common.Hash(prevBeaconRoot) pRoot := common.Hash(prevBeaconRoot)
header.ParentBeaconRoot = &pRoot header.ParentBeaconRoot = &pRoot
} }
block := gethTypes.NewBlockWithHeader(header).WithBody(txs, nil /* uncles */).WithWithdrawals(params.Withdrawals) // TODO: update requests with requests for electra
body := gethTypes.Body{
Transactions: txs,
Uncles: nil,
Withdrawals: params.Withdrawals,
}
block := gethTypes.NewBlockWithHeader(header).WithBody(body)
return block, nil return block, nil
} }

77
third_party/com_github_karalabe_hid.patch vendored Normal file
View File

@@ -0,0 +1,77 @@
diff --git a/BUILD.bazel b/BUILD.bazel
index 9be80a1..0e78457 100755
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -8,58 +8,7 @@ go_library(
srcs = [
"hid.go",
"hid_disabled.go",
- "hid_enabled.go",
- "wchar.go",
],
- cgo = True,
- clinkopts = select({
- "@io_bazel_rules_go//go/platform:darwin": [
- "-framework CoreFoundation -framework IOKit -lobjc",
- ],
- "@io_bazel_rules_go//go/platform:freebsd": [
- "-lusb",
- ],
- "@io_bazel_rules_go//go/platform:linux": [
- "-lrt",
- ],
- "@io_bazel_rules_go//go/platform:windows": [
- "-lsetupapi",
- ],
- "//conditions:default": [],
- }),
- copts = select({
- "@io_bazel_rules_go//go/platform:android": [
- "-DDEFAULT_VISIBILITY=",
- "-DPOLL_NFDS_TYPE=int",
- "-Ihidapi/hidapi",
- "-Ilibusb/libusb -DOS_LINUX -D_GNU_SOURCE -DHAVE_SYS_TIME_H -DHAVE_CLOCK_GETTIME",
- ],
- "@io_bazel_rules_go//go/platform:darwin": [
- "-DDEFAULT_VISIBILITY=",
- "-DOS_DARWIN -DHAVE_SYS_TIME_H",
- "-DPOLL_NFDS_TYPE=int",
- "-Ihidapi/hidapi",
- ],
- "@io_bazel_rules_go//go/platform:freebsd": [
- "-DDEFAULT_VISIBILITY=",
- "-DOS_FREEBSD",
- "-DPOLL_NFDS_TYPE=int",
- "-Ihidapi/hidapi",
- ],
- "@io_bazel_rules_go//go/platform:linux": [
- "-DDEFAULT_VISIBILITY=",
- "-DPOLL_NFDS_TYPE=int",
- "-Ihidapi/hidapi",
- "-Ilibusb/libusb -DOS_LINUX -D_GNU_SOURCE -DHAVE_SYS_TIME_H -DHAVE_CLOCK_GETTIME",
- ],
- "@io_bazel_rules_go//go/platform:windows": [
- "-DDEFAULT_VISIBILITY=",
- "-DOS_WINDOWS",
- "-DPOLL_NFDS_TYPE=int",
- "-Ihidapi/hidapi",
- ],
- "//conditions:default": [],
- }),
importpath = "github.com/karalabe/hid",
visibility = ["//visibility:public"],
)
diff --git a/hid_disabled.go b/hid_disabled.go
index fa2c504..0091853 100644
--- a/hid_disabled.go
+++ b/hid_disabled.go
@@ -4,9 +4,6 @@
// This file is released under the 3-clause BSD license. Note however that Linux
// support depends on libusb, released under GNU LGPL 2.1 or later.
-//go:build (!freebsd && !linux && !darwin && !windows) || ios || !cgo
-// +build !freebsd,!linux,!darwin,!windows ios !cgo
-
package hid
// Supported returns whether this platform is supported by the HID library or not.

0
third_party/usb/AUTHORS → third_party/hid/AUTHORS vendored
View File

4
third_party/usb/BUILD.bazel → third_party/hid/BUILD.bazel vendored
View File

@@ -1,6 +1,6 @@
load("@prysm//tools/go:def.bzl", "go_library", "go_test") load("@prysm//tools/go:def.bzl", "go_library", "go_test")
# gazelle:prefix github.com/karalabe/usb # gazelle:prefix github.com/karalabe/hid
go_library( go_library(
name = "go_default_library", name = "go_default_library",
@@ -10,7 +10,7 @@ go_library(
"usb.go", "usb.go",
"usb_disabled.go", "usb_disabled.go",
], ],
importpath = "github.com/karalabe/usb", importpath = "github.com/karalabe/hid",
visibility = ["@com_github_ethereum_go_ethereum//:__subpackages__"], visibility = ["@com_github_ethereum_go_ethereum//:__subpackages__"],
) )

0
third_party/usb/LICENSE → third_party/hid/LICENSE vendored
View File

0
third_party/usb/README.md → third_party/hid/README.md vendored
View File

2
third_party/usb/hid_disabled.go → third_party/hid/hid_disabled.go vendored
View File

@@ -13,7 +13,7 @@
// You should have received a copy of the GNU Lesser General Public License along // You should have received a copy of the GNU Lesser General Public License along
// with the library. If not, see <http://www.gnu.org/licenses/>. // with the library. If not, see <http://www.gnu.org/licenses/>.
package usb package hid
// HidDevice is a live HID USB connected device handle. On platforms that this file // HidDevice is a live HID USB connected device handle. On platforms that this file
// implements, the type lacks the actual HID device and all methods are noop. // implements, the type lacks the actual HID device and all methods are noop.

2
third_party/usb/raw_disabled.go → third_party/hid/raw_disabled.go vendored
View File

@@ -13,7 +13,7 @@
// You should have received a copy of the GNU Lesser General Public License along // You should have received a copy of the GNU Lesser General Public License along
// with the library. If not, see <http://www.gnu.org/licenses/>. // with the library. If not, see <http://www.gnu.org/licenses/>.
package usb package hid
// RawDevice is a live raw USB connected device handle. On platforms that this file // RawDevice is a live raw USB connected device handle. On platforms that this file
// implements, the type lacks the actual USB device and all methods are noop. // implements, the type lacks the actual USB device and all methods are noop.

4
third_party/usb/usb.go → third_party/hid/usb.go vendored
View File

@@ -13,8 +13,8 @@
// You should have received a copy of the GNU Lesser General Public License along // You should have received a copy of the GNU Lesser General Public License along
// with the library. If not, see <http://www.gnu.org/licenses/>. // with the library. If not, see <http://www.gnu.org/licenses/>.
// Package usb provide interfaces for generic USB devices. // Package hid provide interfaces for generic USB devices.
package usb package hid
import "errors" import "errors"

2
third_party/usb/usb_disabled.go → third_party/hid/usb_disabled.go vendored
View File

@@ -13,7 +13,7 @@
// You should have received a copy of the GNU Lesser General Public License along // You should have received a copy of the GNU Lesser General Public License along
// with the library. If not, see <http://www.gnu.org/licenses/>. // with the library. If not, see <http://www.gnu.org/licenses/>.
package usb package hid
// Supported returns whether this platform is supported by the USB library or not. // Supported returns whether this platform is supported by the USB library or not.
// The goal of this method is to allow programmatically handling platforms that do // The goal of this method is to allow programmatically handling platforms that do

2
third_party/usb/usb_test.go → third_party/hid/usb_test.go vendored
View File

@@ -13,7 +13,7 @@
// You should have received a copy of the GNU Lesser General Public License along // You should have received a copy of the GNU Lesser General Public License along
// with the library. If not, see <http://www.gnu.org/licenses/>. // with the library. If not, see <http://www.gnu.org/licenses/>.
package usb package hid
import ( import (
"os" "os"

5
time/slots/slottime.go
View File

@@ -286,8 +286,9 @@ func SyncCommitteePeriodStartEpoch(e primitives.Epoch) (primitives.Epoch, error)
// SecondsSinceSlotStart returns the number of seconds elapsed since the // SecondsSinceSlotStart returns the number of seconds elapsed since the
// given slot start time // given slot start time
func SecondsSinceSlotStart(s primitives.Slot, genesisTime, timeStamp uint64) (uint64, error) { func SecondsSinceSlotStart(s primitives.Slot, genesisTime, timeStamp uint64) (uint64, error) {
if timeStamp < genesisTime+uint64(s)*params.BeaconConfig().SecondsPerSlot { limit := genesisTime + uint64(s)*params.BeaconConfig().SecondsPerSlot
return 0, errors.New("could not compute seconds since slot start: invalid timestamp") if timeStamp < limit {
return 0, fmt.Errorf("could not compute seconds since slot %d start: invalid timestamp, got %d < want %d", s, timeStamp, limit)
} }
return timeStamp - genesisTime - uint64(s)*params.BeaconConfig().SecondsPerSlot, nil return timeStamp - genesisTime - uint64(s)*params.BeaconConfig().SecondsPerSlot, nil
} }

4
tools/bootnode/bootnode.go
View File

@@ -81,9 +81,7 @@ func main() {
logrus.SetLevel(logrus.DebugLevel) logrus.SetLevel(logrus.DebugLevel)
// Geth specific logging. // Geth specific logging.
glogger := gethlog.NewGlogHandler(gethlog.StreamHandler(os.Stderr, gethlog.TerminalFormat(false))) gethlog.SetDefault(gethlog.NewLogger(gethlog.NewTerminalHandlerWithLevel(os.Stderr, gethlog.LvlTrace, true)))
glogger.Verbosity(gethlog.LvlTrace)
gethlog.Root().SetHandler(glogger)
log.Debug("Debug logging enabled.") log.Debug("Debug logging enabled.")
} }

5
tools/bootnode/bootnode_test.go
View File

@@ -31,10 +31,13 @@ func TestBootnode_OK(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
privKey := extractPrivateKey() privKey := extractPrivateKey()
cfg := discover.Config{ cfg := discover.Config{
PrivateKey: privKey, PrivateKey: privKey,
PingInterval: 100 * time.Millisecond,
NoFindnodeLivenessCheck: true,
} }
listener := createListener(ipAddr, 4000, cfg) listener := createListener(ipAddr, 4000, cfg)
defer listener.Close() defer listener.Close()
time.Sleep(5 * time.Second)
cfg.PrivateKey = extractPrivateKey() cfg.PrivateKey = extractPrivateKey()
bootNode, err := enode.Parse(enode.ValidSchemes, listener.Self().String()) bootNode, err := enode.Parse(enode.ValidSchemes, listener.Self().String())