From 50892383b16522a4927ed70dac89055ced9f1543 Mon Sep 17 00:00:00 2001 From: Manu NALEPA Date: Wed, 24 Apr 2024 14:08:56 +0200 Subject: [PATCH] Peer das core (#13877) * Bump `c-kzg-4844` lib to the `das` branch. * Implement `MerkleProofKZGCommitments`. * Implement `das-core.md`. * Use `peerdas.CustodyColumnSubnets` and `peerdas.CustodyColumns`. * `CustodyColumnSubnets`: Include `i` in the for loop. * Remove `computeSubscribedColumnSubnet`. * Remove `peerdas.CustodyColumns` out of the for loop. --- beacon-chain/core/peerdas/BUILD.bazel | 21 ++ beacon-chain/core/peerdas/helpers.go | 245 ++++++++++++++++++ beacon-chain/p2p/BUILD.bazel | 2 +- beacon-chain/p2p/subnets.go | 60 +---- beacon-chain/sync/BUILD.bazel | 1 + .../sync/rpc_data_column_sidecars_by_root.go | 24 +- consensus-types/blocks/kzg.go | 26 ++ deps.bzl | 4 +- go.mod | 2 +- go.sum | 4 +- 10 files changed, 318 insertions(+), 71 deletions(-) create mode 100644 beacon-chain/core/peerdas/BUILD.bazel create mode 100644 beacon-chain/core/peerdas/helpers.go diff --git a/beacon-chain/core/peerdas/BUILD.bazel b/beacon-chain/core/peerdas/BUILD.bazel new file mode 100644 index 000000000000..92f86751c4ea --- /dev/null +++ b/beacon-chain/core/peerdas/BUILD.bazel @@ -0,0 +1,21 @@ +load("@prysm//tools/go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = ["helpers.go"], + importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas", + visibility = ["//visibility:public"], + deps = [ + "//config/fieldparams:go_default_library", + "//config/params:go_default_library", + "//consensus-types/blocks:go_default_library", + "//consensus-types/interfaces:go_default_library", + "//crypto/hash:go_default_library", + "//encoding/bytesutil:go_default_library", + "//proto/prysm/v1alpha1:go_default_library", + "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", + "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library", + "@com_github_holiman_uint256//:go_default_library", + "@com_github_pkg_errors//:go_default_library", + ], +) diff --git a/beacon-chain/core/peerdas/helpers.go b/beacon-chain/core/peerdas/helpers.go new file mode 100644 index 000000000000..5c5f31810c1d --- /dev/null +++ b/beacon-chain/core/peerdas/helpers.go @@ -0,0 +1,245 @@ +package peerdas + +import ( + "encoding/binary" + + cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" + "github.com/holiman/uint256" + + "github.com/ethereum/go-ethereum/p2p/enode" + errors "github.com/pkg/errors" + fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams" + "github.com/prysmaticlabs/prysm/v5/config/params" + "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks" + "github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces" + "github.com/prysmaticlabs/prysm/v5/crypto/hash" + "github.com/prysmaticlabs/prysm/v5/encoding/bytesutil" + ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1" +) + +const ( + // Number of field elements per extended blob + fieldElementsPerExtBlob = 2 * cKzg4844.FieldElementsPerBlob + + // Bytes per cell + bytesPerCell = cKzg4844.FieldElementsPerCell * cKzg4844.BytesPerFieldElement + + // Number of cells in the extended matrix + extendedMatrixSize = fieldparams.MaxBlobsPerBlock * cKzg4844.CellsPerExtBlob +) + +type ( + extendedMatrix []cKzg4844.Cell + + cellCoordinate struct { + blobIndex uint64 + cellID uint64 + } +) + +var ( + errCustodySubnetCountTooLarge = errors.New("custody subnet count larger than data column sidecar subnet count") + errCellNotFound = errors.New("cell not found (should never happen)") + errCurveOrder = errors.New("could not set bls curve order as big int") + errBlsFieldElementNil = errors.New("bls field element is nil") + errBlsFieldElementBiggerThanCurveOrder = errors.New("bls field element higher than curve order") + errBlsFieldElementDoesNotFit = errors.New("bls field element does not fit in BytesPerFieldElement") +) + +// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#helper-functions +func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) { + dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount + + // Compute the custodied subnets. + subnetIds, err := CustodyColumnSubnets(nodeId, custodySubnetCount) + if err != nil { + return nil, errors.Wrap(err, "custody subnets") + } + + columnsPerSubnet := cKzg4844.CellsPerExtBlob / dataColumnSidecarSubnetCount + + // Knowing the subnet ID and the number of columns per subnet, select all the columns the node should custody. + // Columns belonging to the same subnet are contiguous. + columnIndices := make(map[uint64]bool, custodySubnetCount*columnsPerSubnet) + for i := uint64(0); i < columnsPerSubnet; i++ { + for subnetId := range subnetIds { + columnIndex := dataColumnSidecarSubnetCount*i + subnetId + columnIndices[columnIndex] = true + } + } + + return columnIndices, nil +} + +func CustodyColumnSubnets(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) { + dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount + + // Check if the custody subnet count is larger than the data column sidecar subnet count. + if custodySubnetCount > dataColumnSidecarSubnetCount { + return nil, errCustodySubnetCountTooLarge + } + + // First, compute the subnet IDs that the node should participate in. + subnetIds := make(map[uint64]bool, custodySubnetCount) + + for i := uint64(0); uint64(len(subnetIds)) < custodySubnetCount; i++ { + nodeIdUInt256, nextNodeIdUInt256 := new(uint256.Int), new(uint256.Int) + nodeIdUInt256.SetBytes(nodeId.Bytes()) + nextNodeIdUInt256.Add(nodeIdUInt256, uint256.NewInt(i)) + nextNodeIdUInt64 := nextNodeIdUInt256.Uint64() + nextNodeId := bytesutil.Uint64ToBytesLittleEndian(nextNodeIdUInt64) + + hashedNextNodeId := hash.Hash(nextNodeId) + subnetId := binary.LittleEndian.Uint64(hashedNextNodeId[:8]) % dataColumnSidecarSubnetCount + + if _, exists := subnetIds[subnetId]; !exists { + subnetIds[subnetId] = true + } + } + + return subnetIds, nil +} + +// computeExtendedMatrix computes the extended matrix from the blobs. +// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#compute_extended_matrix +func computeExtendedMatrix(blobs []cKzg4844.Blob) (extendedMatrix, error) { + matrix := make(extendedMatrix, 0, extendedMatrixSize) + + for i := range blobs { + // Chunk a non-extended blob into cells representing the corresponding extended blob. + blob := &blobs[i] + cells, err := cKzg4844.ComputeCells(blob) + if err != nil { + return nil, errors.Wrap(err, "compute cells for blob") + } + + matrix = append(matrix, cells[:]...) + } + + return matrix, nil +} + +// recoverMatrix recovers the extended matrix from some cells. +// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix +func recoverMatrix(cellFromCoordinate map[cellCoordinate]cKzg4844.Cell, blobCount uint64) (extendedMatrix, error) { + matrix := make(extendedMatrix, 0, extendedMatrixSize) + + for blobIndex := uint64(0); blobIndex < blobCount; blobIndex++ { + // Filter all cells that belong to the current blob. + cellIds := make([]uint64, 0, cKzg4844.CellsPerExtBlob) + for coordinate := range cellFromCoordinate { + if coordinate.blobIndex == blobIndex { + cellIds = append(cellIds, coordinate.cellID) + } + } + + // Retrieve cells corresponding to all `cellIds`. + cellIdsCount := len(cellIds) + + cells := make([]cKzg4844.Cell, 0, cellIdsCount) + for _, cellId := range cellIds { + coordinate := cellCoordinate{blobIndex: blobIndex, cellID: cellId} + cell, ok := cellFromCoordinate[coordinate] + if !ok { + return matrix, errCellNotFound + } + + cells = append(cells, cell) + } + + // Recover all cells. + allCellsForRow, err := cKzg4844.RecoverAllCells(cellIds, cells) + if err != nil { + return matrix, errors.Wrap(err, "recover all cells") + } + + matrix = append(matrix, allCellsForRow[:]...) + } + + return matrix, nil +} + +// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix +func dataColumnSidecars(signedBlock interfaces.SignedBeaconBlock, blobs []cKzg4844.Blob) ([]ethpb.DataColumnSidecar, error) { + blobsCount := len(blobs) + + // Get the signed block header. + signedBlockHeader, err := signedBlock.Header() + if err != nil { + return nil, errors.Wrap(err, "signed block header") + } + + // Get the block body. + block := signedBlock.Block() + blockBody := block.Body() + + // Get the blob KZG commitments. + blobKzgCommitments, err := blockBody.BlobKzgCommitments() + if err != nil { + return nil, errors.Wrap(err, "blob KZG commitments") + } + + // Compute the KZG commitments inclusion proof. + kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody) + if err != nil { + return nil, errors.Wrap(err, "merkle proof ZKG commitments") + } + + // Compute cells and proofs. + cells := make([][cKzg4844.CellsPerExtBlob]cKzg4844.Cell, 0, blobsCount) + proofs := make([][cKzg4844.CellsPerExtBlob]cKzg4844.KZGProof, 0, blobsCount) + + for i := range blobs { + blob := &blobs[i] + blobCells, blobProofs, err := cKzg4844.ComputeCellsAndProofs(blob) + if err != nil { + return nil, errors.Wrap(err, "compute cells and proofs") + } + + cells = append(cells, blobCells) + proofs = append(proofs, blobProofs) + } + + // Get the column sidecars. + sidecars := make([]ethpb.DataColumnSidecar, cKzg4844.CellsPerExtBlob) + for columnIndex := uint64(0); columnIndex < cKzg4844.CellsPerExtBlob; columnIndex++ { + column := make([]cKzg4844.Cell, 0, blobsCount) + kzgProofOfColumn := make([]cKzg4844.KZGProof, 0, blobsCount) + + for rowIndex := 0; rowIndex < blobsCount; rowIndex++ { + cell := cells[rowIndex][columnIndex] + column = append(column, cell) + + kzgProof := proofs[rowIndex][columnIndex] + kzgProofOfColumn = append(kzgProofOfColumn, kzgProof) + } + + columnBytes := make([][]byte, 0, blobsCount) + for i := range column { + cell := column[i] + + cellBytes := make([]byte, 0, bytesPerCell) + for _, fieldElement := range cell { + cellBytes = append(cellBytes, fieldElement[:]...) + } + + columnBytes = append(columnBytes, cellBytes) + } + + kzgProofOfColumnBytes := make([][]byte, 0, blobsCount) + for _, kzgProof := range kzgProofOfColumn { + kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, kzgProof[:]) + } + + sidecars = append(sidecars, ethpb.DataColumnSidecar{ + ColumnIndex: columnIndex, + DataColumn: columnBytes, + KzgCommitments: blobKzgCommitments, + KzgProof: kzgProofOfColumnBytes, + SignedBlockHeader: signedBlockHeader, + KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof, + }) + } + + return sidecars, nil +} diff --git a/beacon-chain/p2p/BUILD.bazel b/beacon-chain/p2p/BUILD.bazel index 62f44e3265b0..462ca92717be 100644 --- a/beacon-chain/p2p/BUILD.bazel +++ b/beacon-chain/p2p/BUILD.bazel @@ -46,6 +46,7 @@ go_library( "//beacon-chain/core/altair:go_default_library", "//beacon-chain/core/feed/state:go_default_library", "//beacon-chain/core/helpers:go_default_library", + "//beacon-chain/core/peerdas:go_default_library", "//beacon-chain/core/time:go_default_library", "//beacon-chain/db:go_default_library", "//beacon-chain/p2p/encoder:go_default_library", @@ -60,7 +61,6 @@ go_library( "//consensus-types/primitives:go_default_library", "//consensus-types/wrapper:go_default_library", "//container/leaky-bucket:go_default_library", - "//container/slice:go_default_library", "//crypto/ecdsa:go_default_library", "//crypto/hash:go_default_library", "//encoding/bytesutil:go_default_library", diff --git a/beacon-chain/p2p/subnets.go b/beacon-chain/p2p/subnets.go index 0002b1376829..7be7fc1e7110 100644 --- a/beacon-chain/p2p/subnets.go +++ b/beacon-chain/p2p/subnets.go @@ -13,11 +13,11 @@ import ( "github.com/prysmaticlabs/go-bitfield" "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas" "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags" "github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives" "github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper" - "github.com/prysmaticlabs/prysm/v5/container/slice" "github.com/prysmaticlabs/prysm/v5/crypto/hash" "github.com/prysmaticlabs/prysm/v5/encoding/bytesutil" mathutil "github.com/prysmaticlabs/prysm/v5/math" @@ -212,10 +212,16 @@ func initializePersistentColumnSubnets(id enode.ID) error { if ok && expTime.After(time.Now()) { return nil } - subs, err := computeSubscribedColumnSubnets(id) + subsMap, err := peerdas.CustodyColumnSubnets(id, params.BeaconConfig().CustodyRequirement) if err != nil { return err } + + subs := make([]uint64, 0, len(subsMap)) + for sub := range subsMap { + subs = append(subs, sub) + } + cache.ColumnSubnetIDs.AddColumnSubnets(subs) return nil } @@ -239,46 +245,6 @@ func computeSubscribedSubnets(nodeID enode.ID, epoch primitives.Epoch) ([]uint64 return subs, nil } -func ComputeCustodyColumns(nodeID enode.ID) ([]uint64, error) { - subs, err := computeSubscribedColumnSubnets(nodeID) - if err != nil { - return nil, err - } - colsPerSub := params.BeaconConfig().NumberOfColumns / params.BeaconConfig().DataColumnSidecarSubnetCount - colIdxs := []uint64{} - for _, sub := range subs { - for i := uint64(0); i < colsPerSub; i++ { - colId := params.BeaconConfig().DataColumnSidecarSubnetCount*i + sub - colIdxs = append(colIdxs, colId) - } - } - return colIdxs, nil -} - -func computeSubscribedColumnSubnets(nodeID enode.ID) ([]uint64, error) { - subnetsPerNode := params.BeaconConfig().CustodyRequirement - subs := make([]uint64, 0, subnetsPerNode) - - for i := uint64(0); i < subnetsPerNode; i++ { - sub, err := computeSubscribedColumnSubnet(nodeID, i) - if err != nil { - return nil, err - } - if slice.IsInUint64(sub, subs) { - continue - } - subs = append(subs, sub) - } - isubnetsPerNode, err := mathutil.Int(subnetsPerNode) - if err != nil { - return nil, err - } - if len(subs) != isubnetsPerNode { - return nil, errors.Errorf("inconsistent subnet assignment: %d vs %d", len(subs), isubnetsPerNode) - } - return subs, nil -} - // Spec pseudocode definition: // // def compute_subscribed_subnet(node_id: NodeID, epoch: Epoch, index: int) -> SubnetID: @@ -304,16 +270,6 @@ func computeSubscribedSubnet(nodeID enode.ID, epoch primitives.Epoch, index uint return subnet, nil } -func computeSubscribedColumnSubnet(nodeID enode.ID, index uint64) (uint64, error) { - num := uint256.NewInt(0).SetBytes(nodeID.Bytes()) - num = num.Add(num, uint256.NewInt(index)) - num64bit := num.Uint64() - byteNum := bytesutil.Uint64ToBytesLittleEndian(num64bit) - hashedObj := hash.Hash(byteNum) - subnetID := bytesutil.FromBytes8(hashedObj[:8]) % params.BeaconConfig().DataColumnSidecarSubnetCount - return subnetID, nil -} - func computeSubscriptionExpirationTime(nodeID enode.ID, epoch primitives.Epoch) time.Duration { nodeOffset, _ := computeOffsetAndPrefix(nodeID) pastEpochs := (nodeOffset + uint64(epoch)) % params.BeaconConfig().EpochsPerSubnetSubscription diff --git a/beacon-chain/sync/BUILD.bazel b/beacon-chain/sync/BUILD.bazel index ee9123729713..824effc86edc 100644 --- a/beacon-chain/sync/BUILD.bazel +++ b/beacon-chain/sync/BUILD.bazel @@ -75,6 +75,7 @@ go_library( "//beacon-chain/core/feed/operation:go_default_library", "//beacon-chain/core/feed/state:go_default_library", "//beacon-chain/core/helpers:go_default_library", + "//beacon-chain/core/peerdas:go_default_library", "//beacon-chain/core/signing:go_default_library", "//beacon-chain/core/transition:go_default_library", "//beacon-chain/core/transition/interop:go_default_library", diff --git a/beacon-chain/sync/rpc_data_column_sidecars_by_root.go b/beacon-chain/sync/rpc_data_column_sidecars_by_root.go index 9f4e6e0d6090..15522ac60afc 100644 --- a/beacon-chain/sync/rpc_data_column_sidecars_by_root.go +++ b/beacon-chain/sync/rpc_data_column_sidecars_by_root.go @@ -9,6 +9,7 @@ import ( libp2pcore "github.com/libp2p/go-libp2p/core" "github.com/pkg/errors" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas" "github.com/prysmaticlabs/prysm/v5/beacon-chain/db" "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p" "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types" @@ -60,6 +61,14 @@ func (s *Service) dataColumnSidecarByRootRPCHandler(ctx context.Context, msg int return errors.Wrapf(err, "unexpected error computing min valid blob request slot, current_slot=%d", cs) } + // Compute all custodied columns. + custodiedColumns, err := peerdas.CustodyColumns(s.cfg.p2p.NodeID(), params.BeaconConfig().CustodyRequirement) + if err != nil { + log.WithError(err).Errorf("unexpected error retrieving the node id") + s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream) + return err + } + for i := range columnIdents { if err := ctx.Err(); err != nil { closeStream(stream, log) @@ -72,19 +81,8 @@ func (s *Service) dataColumnSidecarByRootRPCHandler(ctx context.Context, msg int } s.rateLimiter.add(stream, 1) root, idx := bytesutil.ToBytes32(columnIdents[i].BlockRoot), columnIdents[i].Index - custodiedColumns, err := p2p.ComputeCustodyColumns(s.cfg.p2p.NodeID()) - if err != nil { - log.WithError(err).Errorf("unexpected error retrieving the node id") - s.writeErrorResponseToStream(responseCodeServerError, types.ErrGeneric.Error(), stream) - return err - } - isCustodied := false - for _, col := range custodiedColumns { - if col == idx { - isCustodied = true - break - } - } + + isCustodied := custodiedColumns[idx] if !isCustodied { s.cfg.p2p.Peers().Scorers().BadResponsesScorer().Increment(stream.Conn().RemotePeer()) s.writeErrorResponseToStream(responseCodeInvalidRequest, types.ErrInvalidColumnIndex.Error(), stream) diff --git a/consensus-types/blocks/kzg.go b/consensus-types/blocks/kzg.go index b5e2800bf702..9999b79634b4 100644 --- a/consensus-types/blocks/kzg.go +++ b/consensus-types/blocks/kzg.go @@ -80,6 +80,32 @@ func MerkleProofKZGCommitment(body interfaces.ReadOnlyBeaconBlockBody, index int return proof, nil } +// MerkleProofKZGCommitments constructs a Merkle proof of inclusion of the KZG +// commitments into the Beacon Block with the given `body` +func MerkleProofKZGCommitments(body interfaces.ReadOnlyBeaconBlockBody) ([][]byte, error) { + bodyVersion := body.Version() + if bodyVersion < version.Deneb { + return nil, errUnsupportedBeaconBlockBody + } + + membersRoots, err := topLevelRoots(body) + if err != nil { + return nil, errors.Wrap(err, "top level roots") + } + + sparse, err := trie.GenerateTrieFromItems(membersRoots, logBodyLength) + if err != nil { + return nil, errors.Wrap(err, "generate trie from items") + } + + proof, err := sparse.MerkleProof(kzgPosition) + if err != nil { + return nil, errors.Wrap(err, "merkle proof") + } + + return proof, nil +} + // leavesFromCommitments hashes each commitment to construct a slice of roots func leavesFromCommitments(commitments [][]byte) [][]byte { leaves := make([][]byte, len(commitments)) diff --git a/deps.bzl b/deps.bzl index da7c8c7d02ff..3858e04d3dd4 100644 --- a/deps.bzl +++ b/deps.bzl @@ -860,8 +860,8 @@ def prysm_deps(): importpath = "github.com/ethereum/c-kzg-4844", patch_args = ["-p1"], patches = ["//third_party:com_github_ethereum_c_kzg_4844.patch"], - sum = "h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY=", - version = "v0.4.0", + sum = "h1:ffWmm0RUR2+VqJsCkf94HqgEwZi2fgbm2iq+O/GdJNI=", + version = "v1.0.1-0.20240422190800-13be436f5927", ) go_repository( name = "com_github_ethereum_go_ethereum", diff --git a/go.mod b/go.mod index 482659fb5423..f19d8b23c8e6 100644 --- a/go.mod +++ b/go.mod @@ -17,6 +17,7 @@ require ( github.com/dgraph-io/ristretto v0.0.4-0.20210318174700-74754f61e018 github.com/dustin/go-humanize v1.0.0 github.com/emicklei/dot v0.11.0 + github.com/ethereum/c-kzg-4844 v1.0.1-0.20240422190800-13be436f5927 github.com/ethereum/go-ethereum v1.13.5 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 github.com/fsnotify/fsnotify v1.6.0 @@ -134,7 +135,6 @@ require ( github.com/docker/go-units v0.5.0 // indirect github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127 // indirect github.com/elastic/gosigar v0.14.2 // indirect - github.com/ethereum/c-kzg-4844 v0.4.0 // indirect github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9 // indirect github.com/flynn/noise v1.1.0 // indirect github.com/francoispqt/gojay v1.2.13 // indirect diff --git a/go.sum b/go.sum index c15dec2fca65..b04a4c2c9a4c 100644 --- a/go.sum +++ b/go.sum @@ -262,8 +262,8 @@ github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5y 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.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= 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 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/c-kzg-4844 v1.0.1-0.20240422190800-13be436f5927 h1:ffWmm0RUR2+VqJsCkf94HqgEwZi2fgbm2iq+O/GdJNI= +github.com/ethereum/c-kzg-4844 v1.0.1-0.20240422190800-13be436f5927/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= github.com/ethereum/go-ethereum v1.13.5 h1:U6TCRciCqZRe4FPXmy1sMGxTfuk8P7u2UoinF3VbaFk= github.com/ethereum/go-ethereum v1.13.5/go.mod h1:yMTu38GSuyxaYzQMViqNmQ1s3cE84abZexQmTgenWk0= github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=