From b8f43c052200c9e110f63f59fa8e63c7ea8b58e5 Mon Sep 17 00:00:00 2001 From: kevaundray Date: Wed, 3 Jul 2024 13:17:47 +0100 Subject: [PATCH] chore: Encapsulate all kzg functionality for PeerDAS into the kzg package (#14136) * chore: move all ckzg related functionality into kzg package * refactor code to match * run: bazel run //:gazelle -- fix * chore: add some docs and stop copying large objects when converting between types * fixes * manually add kzg.go dep to Build.Hazel * move kzg methods to kzg.go * chore: add RecoverCellsAndProofs method * bazel run //:gazelle -- fix * use BytesPerBlob constant * chore: fix some deepsource issues * one declaration for commans and blobs --- beacon-chain/blockchain/kzg/BUILD.bazel | 2 + beacon-chain/blockchain/kzg/kzg.go | 156 ++++++++++++++++++ beacon-chain/core/peerdas/BUILD.bazel | 3 +- beacon-chain/core/peerdas/helpers.go | 61 ++++--- beacon-chain/core/peerdas/helpers_test.go | 21 +-- beacon-chain/p2p/BUILD.bazel | 1 - beacon-chain/p2p/broadcaster_test.go | 3 +- .../rpc/prysm/v1alpha1/validator/BUILD.bazel | 2 +- .../rpc/prysm/v1alpha1/validator/proposer.go | 10 +- .../rpc/prysm/v1alpha1/validator/unblinder.go | 11 +- beacon-chain/sync/BUILD.bazel | 2 +- beacon-chain/sync/data_columns_reconstruct.go | 16 +- 12 files changed, 220 insertions(+), 68 deletions(-) create mode 100644 beacon-chain/blockchain/kzg/kzg.go diff --git a/beacon-chain/blockchain/kzg/BUILD.bazel b/beacon-chain/blockchain/kzg/BUILD.bazel index 52279c006cc..3593503d7e2 100644 --- a/beacon-chain/blockchain/kzg/BUILD.bazel +++ b/beacon-chain/blockchain/kzg/BUILD.bazel @@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test") go_library( name = "go_default_library", srcs = [ + "kzg.go", "trusted_setup.go", "validation.go", ], @@ -14,6 +15,7 @@ go_library( "@com_github_crate_crypto_go_kzg_4844//:go_default_library", "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", + "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library", "@com_github_pkg_errors//:go_default_library", ], ) diff --git a/beacon-chain/blockchain/kzg/kzg.go b/beacon-chain/blockchain/kzg/kzg.go new file mode 100644 index 00000000000..aa348a79d15 --- /dev/null +++ b/beacon-chain/blockchain/kzg/kzg.go @@ -0,0 +1,156 @@ +package kzg + +import ( + "errors" + + ckzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" + "github.com/ethereum/go-ethereum/crypto/kzg4844" +) + +// Blob represents a serialized chunk of data. +type Blob [BytesPerBlob]byte + +// Commitment represent a KZG commitment to a Blob. +type Commitment [48]byte + +// Proof represents a KZG proof that attests to the validity of a Blob or parts of it. +type Proof [48]byte + +// Bytes48 is a 48-byte array. +type Bytes48 = ckzg4844.Bytes48 + +// Bytes32 is a 32-byte array. +type Bytes32 = ckzg4844.Bytes32 + +// BytesPerCell is the number of bytes in a single cell. +const BytesPerCell = ckzg4844.FieldElementsPerCell * ckzg4844.BytesPerFieldElement + +// BytesPerBlob is the number of bytes in a single blob. +const BytesPerBlob = ckzg4844.BytesPerBlob + +// FieldElementsPerCell is the number of field elements in a single cell. +// TODO: This should not be exposed. +const FieldElementsPerCell = ckzg4844.FieldElementsPerCell + +// CellsPerExtBlob is the number of cells that we generate for a single blob. +// This is equivalent to the number of columns in the data matrix. +const CellsPerExtBlob = ckzg4844.CellsPerExtBlob + +// Cell represents a chunk of an encoded Blob. +// TODO: This is not correctly sized in c-kzg +// TODO: It should be a vector of bytes +// TODO: Note that callers of this package rely on `BytesPerCell` +type Cell ckzg4844.Cell + +func BlobToKZGCommitment(blob *Blob) (Commitment, error) { + comm, err := kzg4844.BlobToCommitment(kzg4844.Blob(*blob)) + if err != nil { + return Commitment{}, err + } + return Commitment(comm), nil +} + +func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) { + proof, err := kzg4844.ComputeBlobProof(kzg4844.Blob(*blob), kzg4844.Commitment(commitment)) + if err != nil { + return [48]byte{}, err + } + return Proof(proof), nil +} + +func ComputeCellsAndKZGProofs(blob *Blob) ([ckzg4844.CellsPerExtBlob]Cell, [ckzg4844.CellsPerExtBlob]Proof, error) { + ckzgBlob := ckzg4844.Blob(*blob) + _cells, _proofs, err := ckzg4844.ComputeCellsAndKZGProofs(&ckzgBlob) + if err != nil { + return [ckzg4844.CellsPerExtBlob]Cell{}, [ckzg4844.CellsPerExtBlob]Proof{}, err + } + + // Convert Cells and Proofs to types defined in this package + var cells [ckzg4844.CellsPerExtBlob]Cell + for i := range _cells { + cells[i] = Cell(_cells[i]) + } + + var proofs [ckzg4844.CellsPerExtBlob]Proof + for i := range _proofs { + proofs[i] = Proof(_proofs[i]) + } + + return cells, proofs, nil +} + +// VerifyCellKZGProof is unused. TODO: We can check when the batch size for `VerifyCellKZGProofBatch` is 1 +// and call this, though I think its better if the cryptography library handles this. +func VerifyCellKZGProof(commitmentBytes Bytes48, cellId uint64, cell *Cell, proofBytes Bytes48) (bool, error) { + return ckzg4844.VerifyCellKZGProof(commitmentBytes, cellId, ckzg4844.Cell(*cell), proofBytes) +} + +func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, rowIndices, columnIndices []uint64, _cells []Cell, proofsBytes []Bytes48) (bool, error) { + // Convert `Cell` type to `ckzg4844.Cell` + ckzgCells := make([]ckzg4844.Cell, len(_cells)) + for i := range _cells { + ckzgCells[i] = ckzg4844.Cell(_cells[i]) + } + + return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, rowIndices, columnIndices, ckzgCells, proofsBytes) +} + +func RecoverAllCells(cellIds []uint64, _cells []Cell) ([ckzg4844.CellsPerExtBlob]Cell, error) { + // Convert `Cell` type to `ckzg4844.Cell` + ckzgCells := make([]ckzg4844.Cell, len(_cells)) + for i := range _cells { + ckzgCells[i] = ckzg4844.Cell(_cells[i]) + } + + recoveredCells, err := ckzg4844.RecoverAllCells(cellIds, ckzgCells) + if err != nil { + return [ckzg4844.CellsPerExtBlob]Cell{}, err + } + + // This should never happen, we return an error instead of panicking. + if len(recoveredCells) != ckzg4844.CellsPerExtBlob { + return [ckzg4844.CellsPerExtBlob]Cell{}, errors.New("recovered cells length is not equal to CellsPerExtBlob") + } + + // Convert `ckzg4844.Cell` type to `Cell` + var ret [ckzg4844.CellsPerExtBlob]Cell + for i := range recoveredCells { + ret[i] = Cell(recoveredCells[i]) + } + return ret, nil +} + +// RecoverCellsAndKZGProofs recovers the cells and compute the KZG Proofs associated with the cells. +// +// This method will supersede the `RecoverAllCells` and `CellsToBlob` methods. +func RecoverCellsAndKZGProofs(cellIds []uint64, _cells []Cell) ([ckzg4844.CellsPerExtBlob]Cell, [ckzg4844.CellsPerExtBlob]Proof, error) { + // First recover all of the cells + recoveredCells, err := RecoverAllCells(cellIds, _cells) + if err != nil { + return [ckzg4844.CellsPerExtBlob]Cell{}, [ckzg4844.CellsPerExtBlob]Proof{}, err + } + + // Extract the Blob from all of the Cells + blob, err := CellsToBlob(&recoveredCells) + if err != nil { + return [ckzg4844.CellsPerExtBlob]Cell{}, [ckzg4844.CellsPerExtBlob]Proof{}, err + } + + // Compute all of the cells and KZG proofs + return ComputeCellsAndKZGProofs(&blob) +} + +func CellsToBlob(_cells *[ckzg4844.CellsPerExtBlob]Cell) (Blob, error) { + // Convert `Cell` type to `ckzg4844.Cell` + var ckzgCells [ckzg4844.CellsPerExtBlob]ckzg4844.Cell + for i := range _cells { + ckzgCells[i] = ckzg4844.Cell(_cells[i]) + } + + blob, err := ckzg4844.CellsToBlob(ckzgCells) + if err != nil { + return Blob{}, err + } + + return Blob(blob), nil +} diff --git a/beacon-chain/core/peerdas/BUILD.bazel b/beacon-chain/core/peerdas/BUILD.bazel index 62b82f5fa83..05bd9c49ad1 100644 --- a/beacon-chain/core/peerdas/BUILD.bazel +++ b/beacon-chain/core/peerdas/BUILD.bazel @@ -6,6 +6,7 @@ go_library( importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas", visibility = ["//visibility:public"], deps = [ + "//beacon-chain/blockchain/kzg:go_default_library", "//cmd/beacon-chain/flags:go_default_library", "//config/params:go_default_library", "//consensus-types/blocks:go_default_library", @@ -13,7 +14,6 @@ go_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_ethereum_go_ethereum//p2p/enr:go_default_library", "@com_github_holiman_uint256//:go_default_library", @@ -32,7 +32,6 @@ go_test( "//testing/util:go_default_library", "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library", "@com_github_crate_crypto_go_kzg_4844//:go_default_library", - "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", "@com_github_sirupsen_logrus//:go_default_library", ], ) diff --git a/beacon-chain/core/peerdas/helpers.go b/beacon-chain/core/peerdas/helpers.go index 743ff8bd926..379391e71f8 100644 --- a/beacon-chain/core/peerdas/helpers.go +++ b/beacon-chain/core/peerdas/helpers.go @@ -5,12 +5,12 @@ import ( "math" "math/big" - cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/enr" "github.com/holiman/uint256" errors "github.com/pkg/errors" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg" "github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags" "github.com/prysmaticlabs/prysm/v5/config/params" "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks" @@ -20,11 +20,8 @@ import ( ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1" ) -// Bytes per cell const ( CustodySubnetCountEnrKey = "csc" - - bytesPerCell = cKzg4844.FieldElementsPerCell * cKzg4844.BytesPerFieldElement ) // https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/p2p-interface.md#the-discovery-domain-discv5 @@ -94,7 +91,7 @@ func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool return nil, errors.Wrap(err, "custody subnets") } - columnsPerSubnet := cKzg4844.CellsPerExtBlob / dataColumnSidecarSubnetCount + columnsPerSubnet := kzg.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. @@ -111,7 +108,7 @@ func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool // DataColumnSidecars computes the data column sidecars from the signed block and blobs. // https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix -func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []cKzg4844.Blob) ([]*ethpb.DataColumnSidecar, error) { +func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []kzg.Blob) ([]*ethpb.DataColumnSidecar, error) { blobsCount := len(blobs) if blobsCount == 0 { return nil, nil @@ -140,12 +137,12 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs } // Compute cells and proofs. - cells := make([][cKzg4844.CellsPerExtBlob]cKzg4844.Cell, 0, blobsCount) - proofs := make([][cKzg4844.CellsPerExtBlob]cKzg4844.KZGProof, 0, blobsCount) + cells := make([][kzg.CellsPerExtBlob]kzg.Cell, 0, blobsCount) + proofs := make([][kzg.CellsPerExtBlob]kzg.Proof, 0, blobsCount) for i := range blobs { blob := &blobs[i] - blobCells, blobProofs, err := cKzg4844.ComputeCellsAndKZGProofs(blob) + blobCells, blobProofs, err := kzg.ComputeCellsAndKZGProofs(blob) if err != nil { return nil, errors.Wrap(err, "compute cells and KZG proofs") } @@ -155,10 +152,10 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs } // Get the column sidecars. - sidecars := make([]*ethpb.DataColumnSidecar, 0, cKzg4844.CellsPerExtBlob) - for columnIndex := uint64(0); columnIndex < cKzg4844.CellsPerExtBlob; columnIndex++ { - column := make([]cKzg4844.Cell, 0, blobsCount) - kzgProofOfColumn := make([]cKzg4844.KZGProof, 0, blobsCount) + sidecars := make([]*ethpb.DataColumnSidecar, 0, kzg.CellsPerExtBlob) + for columnIndex := uint64(0); columnIndex < kzg.CellsPerExtBlob; columnIndex++ { + column := make([]kzg.Cell, 0, blobsCount) + kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount) for rowIndex := 0; rowIndex < blobsCount; rowIndex++ { cell := cells[rowIndex][columnIndex] @@ -172,7 +169,7 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs for i := range column { cell := column[i] - cellBytes := make([]byte, 0, bytesPerCell) + cellBytes := make([]byte, 0, kzg.BytesPerCell) for _, fieldElement := range cell { copiedElem := fieldElement cellBytes = append(cellBytes, copiedElem[:]...) @@ -208,7 +205,7 @@ func DataColumnSidecarsForReconstruct( blobKzgCommitments [][]byte, signedBlockHeader *ethpb.SignedBeaconBlockHeader, kzgCommitmentsInclusionProof [][]byte, - blobs []cKzg4844.Blob, + blobs []kzg.Blob, ) ([]*ethpb.DataColumnSidecar, error) { blobsCount := len(blobs) if blobsCount == 0 { @@ -216,12 +213,12 @@ func DataColumnSidecarsForReconstruct( } // Compute cells and proofs. - cells := make([][cKzg4844.CellsPerExtBlob]cKzg4844.Cell, 0, blobsCount) - proofs := make([][cKzg4844.CellsPerExtBlob]cKzg4844.KZGProof, 0, blobsCount) + cells := make([][kzg.CellsPerExtBlob]kzg.Cell, 0, blobsCount) + proofs := make([][kzg.CellsPerExtBlob]kzg.Proof, 0, blobsCount) for i := range blobs { blob := &blobs[i] - blobCells, blobProofs, err := cKzg4844.ComputeCellsAndKZGProofs(blob) + blobCells, blobProofs, err := kzg.ComputeCellsAndKZGProofs(blob) if err != nil { return nil, errors.Wrap(err, "compute cells and KZG proofs") } @@ -231,10 +228,10 @@ func DataColumnSidecarsForReconstruct( } // Get the column sidecars. - sidecars := make([]*ethpb.DataColumnSidecar, 0, cKzg4844.CellsPerExtBlob) - for columnIndex := uint64(0); columnIndex < cKzg4844.CellsPerExtBlob; columnIndex++ { - column := make([]cKzg4844.Cell, 0, blobsCount) - kzgProofOfColumn := make([]cKzg4844.KZGProof, 0, blobsCount) + sidecars := make([]*ethpb.DataColumnSidecar, 0, kzg.CellsPerExtBlob) + for columnIndex := uint64(0); columnIndex < kzg.CellsPerExtBlob; columnIndex++ { + column := make([]kzg.Cell, 0, blobsCount) + kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount) for rowIndex := 0; rowIndex < blobsCount; rowIndex++ { cell := cells[rowIndex][columnIndex] @@ -248,7 +245,7 @@ func DataColumnSidecarsForReconstruct( for i := range column { cell := column[i] - cellBytes := make([]byte, 0, bytesPerCell) + cellBytes := make([]byte, 0, kzg.BytesPerCell) for _, fieldElement := range cell { copiedElem := fieldElement cellBytes = append(cellBytes, copiedElem[:]...) @@ -297,23 +294,23 @@ func VerifyDataColumnSidecarKZGProofs(sc *ethpb.DataColumnSidecar) (bool, error) colI := sc.ColumnIndex colIdx = append(colIdx, colI) } - ckzgComms := make([]cKzg4844.Bytes48, 0, len(sc.KzgCommitments)) + ckzgComms := make([]kzg.Bytes48, 0, len(sc.KzgCommitments)) for _, com := range sc.KzgCommitments { - ckzgComms = append(ckzgComms, cKzg4844.Bytes48(com)) + ckzgComms = append(ckzgComms, kzg.Bytes48(com)) } - var cells []cKzg4844.Cell + var cells []kzg.Cell for _, ce := range sc.DataColumn { - var newCell []cKzg4844.Bytes32 + var newCell []kzg.Bytes32 for i := 0; i < len(ce); i += 32 { - newCell = append(newCell, cKzg4844.Bytes32(ce[i:i+32])) + newCell = append(newCell, kzg.Bytes32(ce[i:i+32])) } - cells = append(cells, cKzg4844.Cell(newCell)) + cells = append(cells, kzg.Cell(newCell)) } - var proofs []cKzg4844.Bytes48 + var proofs []kzg.Bytes48 for _, p := range sc.KzgProof { - proofs = append(proofs, cKzg4844.Bytes48(p)) + proofs = append(proofs, kzg.Bytes48(p)) } - return cKzg4844.VerifyCellKZGProofBatch(ckzgComms, rowIdx, colIdx, cells, proofs) + return kzg.VerifyCellKZGProofBatch(ckzgComms, rowIdx, colIdx, cells, proofs) } // CustodySubnetCount returns the number of subnets the node should participate in for custody. diff --git a/beacon-chain/core/peerdas/helpers_test.go b/beacon-chain/core/peerdas/helpers_test.go index 401fb9c0033..73572db9287 100644 --- a/beacon-chain/core/peerdas/helpers_test.go +++ b/beacon-chain/core/peerdas/helpers_test.go @@ -9,7 +9,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bls12-381/fr" GoKZG "github.com/crate-crypto/go-kzg-4844" - ckzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas" "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks" @@ -41,8 +40,8 @@ func GetRandFieldElement(seed int64) [32]byte { } // Returns a random blob using the passed seed as entropy -func GetRandBlob(seed int64) ckzg4844.Blob { - var blob ckzg4844.Blob +func GetRandBlob(seed int64) kzg.Blob { + var blob kzg.Blob bytesPerBlob := GoKZG.ScalarsPerBlob * GoKZG.SerializedScalarSize for i := 0; i < bytesPerBlob; i += GoKZG.SerializedScalarSize { fieldElementBytes := GetRandFieldElement(seed + int64(i)) @@ -51,14 +50,14 @@ func GetRandBlob(seed int64) ckzg4844.Blob { return blob } -func GenerateCommitmentAndProof(blob ckzg4844.Blob) (ckzg4844.KZGCommitment, ckzg4844.KZGProof, error) { - commitment, err := ckzg4844.BlobToKZGCommitment(&blob) +func GenerateCommitmentAndProof(blob kzg.Blob) (kzg.Commitment, kzg.Proof, error) { + commitment, err := kzg.BlobToKZGCommitment(&blob) if err != nil { - return ckzg4844.KZGCommitment{}, ckzg4844.KZGProof{}, err + return kzg.Commitment{}, kzg.Proof{}, err } - proof, err := ckzg4844.ComputeBlobKZGProof(&blob, ckzg4844.Bytes48(commitment)) + proof, err := kzg.ComputeBlobKZGProof(&blob, commitment) if err != nil { - return ckzg4844.KZGCommitment{}, ckzg4844.KZGProof{}, err + return kzg.Commitment{}, kzg.Proof{}, err } return commitment, proof, err } @@ -67,8 +66,10 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) { dbBlock := util.NewBeaconBlockDeneb() require.NoError(t, kzg.Start()) - comms := [][]byte{} - blobs := []ckzg4844.Blob{} + var ( + comms [][]byte + blobs []kzg.Blob + ) for i := int64(0); i < 6; i++ { blob := GetRandBlob(i) commitment, _, err := GenerateCommitmentAndProof(blob) diff --git a/beacon-chain/p2p/BUILD.bazel b/beacon-chain/p2p/BUILD.bazel index 864ffe1f067..bd0b49be5c3 100644 --- a/beacon-chain/p2p/BUILD.bazel +++ b/beacon-chain/p2p/BUILD.bazel @@ -178,7 +178,6 @@ go_test( "//testing/util:go_default_library", "//time:go_default_library", "//time/slots:go_default_library", - "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", "@com_github_ethereum_go_ethereum//crypto:go_default_library", "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library", "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library", diff --git a/beacon-chain/p2p/broadcaster_test.go b/beacon-chain/p2p/broadcaster_test.go index 6fffc9641fa..f514d9a16e8 100644 --- a/beacon-chain/p2p/broadcaster_test.go +++ b/beacon-chain/p2p/broadcaster_test.go @@ -9,7 +9,6 @@ import ( "testing" "time" - cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" "github.com/ethereum/go-ethereum/p2p/discover" pubsub "github.com/libp2p/go-libp2p-pubsub" "github.com/libp2p/go-libp2p/core/host" @@ -549,7 +548,7 @@ func TestService_BroadcastDataColumn(t *testing.T) { b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockElectra()) require.NoError(t, err) - blobs := make([]cKzg4844.Blob, fieldparams.MaxBlobsPerBlock) + blobs := make([]kzg.Blob, fieldparams.MaxBlobsPerBlock) sidecars, err := peerdas.DataColumnSidecars(b, blobs) require.NoError(t, err) diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel b/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel index 70922398fc9..9a9b560fb3e 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel @@ -37,6 +37,7 @@ go_library( "//api/client/builder:go_default_library", "//async/event:go_default_library", "//beacon-chain/blockchain:go_default_library", + "//beacon-chain/blockchain/kzg:go_default_library", "//beacon-chain/builder:go_default_library", "//beacon-chain/cache:go_default_library", "//beacon-chain/cache/depositsnapshot:go_default_library", @@ -91,7 +92,6 @@ go_library( "//runtime/version:go_default_library", "//time:go_default_library", "//time/slots:go_default_library", - "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", "@com_github_ethereum_go_ethereum//common:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", "@com_github_golang_protobuf//ptypes/empty", diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go index 8abadab13ba..d336c02d5f9 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go @@ -7,13 +7,13 @@ import ( "sync" "time" - cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/pkg/errors" builderapi "github.com/prysmaticlabs/prysm/v5/api/client/builder" "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg" "github.com/prysmaticlabs/prysm/v5/beacon-chain/builder" "github.com/prysmaticlabs/prysm/v5/beacon-chain/cache" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed" @@ -385,13 +385,13 @@ func handleUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.Generic if isPeerDASEnabled { // Convert blobs from slices to array. - blobs := make([]cKzg4844.Blob, 0, len(dbBlockContents.Blobs)) + blobs := make([]kzg.Blob, 0, len(dbBlockContents.Blobs)) for _, blob := range dbBlockContents.Blobs { - if len(blob) != cKzg4844.BytesPerBlob { - return nil, nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", cKzg4844.BytesPerBlob, len(blob)) + if len(blob) != kzg.BytesPerBlob { + return nil, nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", kzg.BytesPerBlob, len(blob)) } - blobs = append(blobs, cKzg4844.Blob(blob)) + blobs = append(blobs, kzg.Blob(blob)) } dataColumnSideCars, err := peerdas.DataColumnSidecars(block, blobs) diff --git a/beacon-chain/rpc/prysm/v1alpha1/validator/unblinder.go b/beacon-chain/rpc/prysm/v1alpha1/validator/unblinder.go index da9582059e1..01e6c4ac33d 100644 --- a/beacon-chain/rpc/prysm/v1alpha1/validator/unblinder.go +++ b/beacon-chain/rpc/prysm/v1alpha1/validator/unblinder.go @@ -3,9 +3,8 @@ package validator import ( "bytes" - cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" - "github.com/pkg/errors" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas" consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks" "github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces" @@ -80,13 +79,13 @@ func unblindDataColumnsSidecars(block interfaces.SignedBeaconBlock, bundle *engi } // Convert blobs from slices to array. - blobs := make([]cKzg4844.Blob, 0, len(bundle.Blobs)) + blobs := make([]kzg.Blob, 0, len(bundle.Blobs)) for _, blob := range bundle.Blobs { - if len(blob) != cKzg4844.BytesPerBlob { - return nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", cKzg4844.BytesPerBlob, len(blob)) + if len(blob) != kzg.BytesPerBlob { + return nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", kzg.BytesPerBlob, len(blob)) } - blobs = append(blobs, cKzg4844.Blob(blob)) + blobs = append(blobs, kzg.Blob(blob)) } // Retrieve data columns from blobs. diff --git a/beacon-chain/sync/BUILD.bazel b/beacon-chain/sync/BUILD.bazel index 611a1c13005..28f7a7ece7a 100644 --- a/beacon-chain/sync/BUILD.bazel +++ b/beacon-chain/sync/BUILD.bazel @@ -69,6 +69,7 @@ go_library( "//async/abool:go_default_library", "//async/event:go_default_library", "//beacon-chain/blockchain:go_default_library", + "//beacon-chain/blockchain/kzg:go_default_library", "//beacon-chain/cache:go_default_library", "//beacon-chain/core/altair:go_default_library", "//beacon-chain/core/blocks:go_default_library", @@ -126,7 +127,6 @@ go_library( "//runtime/version:go_default_library", "//time:go_default_library", "//time/slots:go_default_library", - "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library", "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library", "@com_github_hashicorp_golang_lru//:go_default_library", "@com_github_libp2p_go_libp2p//core:go_default_library", diff --git a/beacon-chain/sync/data_columns_reconstruct.go b/beacon-chain/sync/data_columns_reconstruct.go index 1e7b6044496..842f37448fc 100644 --- a/beacon-chain/sync/data_columns_reconstruct.go +++ b/beacon-chain/sync/data_columns_reconstruct.go @@ -6,10 +6,10 @@ import ( "sort" "time" - cKzg4844 "github.com/ethereum/c-kzg-4844/bindings/go" "github.com/pkg/errors" "github.com/sirupsen/logrus" + "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg" "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas" fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams" "github.com/prysmaticlabs/prysm/v5/config/params" @@ -25,7 +25,7 @@ func recoverBlobs( dataColumnSideCars []*ethpb.DataColumnSidecar, columnsCount int, blockRoot [fieldparams.RootLength]byte, -) ([]cKzg4844.Blob, error) { +) ([]kzg.Blob, error) { if len(dataColumnSideCars) == 0 { return nil, errors.New("no data column sidecars") } @@ -40,13 +40,13 @@ func recoverBlobs( } } - recoveredBlobs := make([]cKzg4844.Blob, 0, blobCount) + recoveredBlobs := make([]kzg.Blob, 0, blobCount) for blobIndex := 0; blobIndex < blobCount; blobIndex++ { start := time.Now() cellsId := make([]uint64, 0, columnsCount) - cKzgCells := make([]cKzg4844.Cell, 0, columnsCount) + cKzgCells := make([]kzg.Cell, 0, columnsCount) for _, sidecar := range dataColumnSideCars { // Build the cell ids. @@ -57,8 +57,8 @@ func recoverBlobs( cell := column[blobIndex] // Transform the cell as a cKzg cell. - var ckzgCell cKzg4844.Cell - for i := 0; i < cKzg4844.FieldElementsPerCell; i++ { + var ckzgCell kzg.Cell + for i := 0; i < kzg.FieldElementsPerCell; i++ { copy(ckzgCell[i][:], cell[32*i:32*(i+1)]) } @@ -66,12 +66,12 @@ func recoverBlobs( } // Recover the blob. - recoveredCells, err := cKzg4844.RecoverAllCells(cellsId, cKzgCells) + recoveredCells, err := kzg.RecoverAllCells(cellsId, cKzgCells) if err != nil { return nil, errors.Wrapf(err, "recover all cells for blob %d", blobIndex) } - recoveredBlob, err := cKzg4844.CellsToBlob(recoveredCells) + recoveredBlob, err := kzg.CellsToBlob(&recoveredCells) if err != nil { return nil, errors.Wrapf(err, "cells to blob for blob %d", blobIndex) }