From ba5174bd46e3f68755aa071816309457c4d6492b Mon Sep 17 00:00:00 2001 From: Jim McDonald Date: Fri, 1 Mar 2024 22:56:40 +0000 Subject: [PATCH] Unified proposals using v3. --- api/proposalopts.go | 8 +- api/submitblindedproposalopts.go | 27 ++ api/submitproposalopts.go | 27 ++ api/v2/broadcastvalidation.go | 67 ++++ api/versionedproposal.go | 585 +++++++++++++++++-------------- api/versionedsignedproposal.go | 255 +++++++++++--- http/blindedproposal_test.go | 123 ------- http/http.go | 23 +- http/proposal.go | 113 ++++-- http/submitblindedproposal.go | 29 +- http/submitproposal.go | 105 +++++- http/submitproposal_test.go | 4 +- multi/blindedproposal.go | 43 --- multi/submitproposal.go | 6 +- service.go | 10 +- 15 files changed, 890 insertions(+), 535 deletions(-) create mode 100644 api/submitblindedproposalopts.go create mode 100644 api/submitproposalopts.go create mode 100644 api/v2/broadcastvalidation.go delete mode 100644 http/blindedproposal_test.go delete mode 100644 multi/blindedproposal.go diff --git a/api/proposalopts.go b/api/proposalopts.go index 27809bce..35a555f6 100644 --- a/api/proposalopts.go +++ b/api/proposalopts.go @@ -1,4 +1,4 @@ -// Copyright © 2023 Attestant Limited. +// Copyright © 2023, 2024 Attestant Limited. // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at @@ -23,9 +23,13 @@ type ProposalOpts struct { Slot phase0.Slot // RandaoReveal is the RANDAO reveal for the proposal. RandaoReveal phase0.BLSSignature - // Graffit is the graffiti to be included in the beacon block body. + // Graffiti is the graffiti to be included in the beacon block body. Graffiti [32]byte // SkipRandaoVerification is true if we do not want the server to verify our RANDAO reveal. // If this is set then the RANDAO reveal should be passed as the point at infinity (0xc0…00) SkipRandaoVerification bool + // BuilderBoostFactor is the relative weight of the builder payload versus a locally-produced + // payload, as per https://ethereum.github.io/beacon-APIs/#/Validator/produceBlockV3 + // This is optional; if not supplied it will use the default value of 100. + BuilderBoostFactor *uint64 } diff --git a/api/submitblindedproposalopts.go b/api/submitblindedproposalopts.go new file mode 100644 index 00000000..8355f47d --- /dev/null +++ b/api/submitblindedproposalopts.go @@ -0,0 +1,27 @@ +// Copyright © 2024 Attestant Limited. +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import v2 "github.com/attestantio/go-eth2-client/api/v2" + +// SubmitBlindedProposalOpts are the options for submitting proposals. +type SubmitBlindedProposalOpts struct { + Common CommonOpts + + // Proposal is the proposal to submit. + Proposal *VersionedSignedBlindedProposal + + // BroadcastValidation is the validation required of the consensus node before broadcasting the proposal. + BroadcastValidation *v2.BroadcastValidation +} diff --git a/api/submitproposalopts.go b/api/submitproposalopts.go new file mode 100644 index 00000000..48884913 --- /dev/null +++ b/api/submitproposalopts.go @@ -0,0 +1,27 @@ +// Copyright © 2024 Attestant Limited. +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package api + +import v2 "github.com/attestantio/go-eth2-client/api/v2" + +// SubmitProposalOpts are the options for submitting proposals. +type SubmitProposalOpts struct { + Common CommonOpts + + // Proposal is the proposal to submit. + Proposal *VersionedSignedProposal + + // BroadcastValidation is the validation required of the consensus node before broadcasting the proposal. + BroadcastValidation *v2.BroadcastValidation +} diff --git a/api/v2/broadcastvalidation.go b/api/v2/broadcastvalidation.go new file mode 100644 index 00000000..13cccaeb --- /dev/null +++ b/api/v2/broadcastvalidation.go @@ -0,0 +1,67 @@ +// Copyright © 2024 Attestant Limited. +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package v2 + +import ( + "fmt" + "strings" +) + +// BroadcastValidation defines the validation to carry out prior to broadcasting proposals. +type BroadcastValidation int + +const ( + // BroadcastValidationGossip means carry out lightweight gossip checks. + BroadcastValidationGossip BroadcastValidation = iota + // BroadcastValidationConsensus means carry out full consensus checks. + BroadcastValidationConsensus + // BroadcastValidationConsensusAndEquivocation means carry out consensus and equivocation checks. + BroadcastValidationConsensusAndEquivocation +) + +var broadcastValidationStrings = [...]string{ + "gossip", + "consensus", + "consensus_and_equivocation", +} + +// MarshalJSON implements json.Marshaler. +func (b *BroadcastValidation) MarshalJSON() ([]byte, error) { + return []byte(fmt.Sprintf("%q", broadcastValidationStrings[*b])), nil +} + +// UnmarshalJSON implements json.Unmarshaler. +func (b *BroadcastValidation) UnmarshalJSON(input []byte) error { + var err error + switch strings.ToLower(string(input)) { + case `"gossip"`: + *b = BroadcastValidationGossip + case `"consensus"`: + *b = BroadcastValidationConsensus + case `"consensus_and_equivocation"`: + *b = BroadcastValidationConsensusAndEquivocation + default: + err = fmt.Errorf("unrecognised broadcast validation %s", string(input)) + } + + return err +} + +func (b BroadcastValidation) String() string { + if b < 0 || int(b) >= len(broadcastValidationStrings) { + return broadcastValidationStrings[0] // unknown + } + + return broadcastValidationStrings[b] +} diff --git a/api/versionedproposal.go b/api/versionedproposal.go index 2ead375c..5d565106 100644 --- a/api/versionedproposal.go +++ b/api/versionedproposal.go @@ -14,6 +14,10 @@ package api import ( + "math/big" + + apiv1bellatrix "github.com/attestantio/go-eth2-client/api/v1/bellatrix" + apiv1capella "github.com/attestantio/go-eth2-client/api/v1/capella" apiv1deneb "github.com/attestantio/go-eth2-client/api/v1/deneb" "github.com/attestantio/go-eth2-client/spec" "github.com/attestantio/go-eth2-client/spec/altair" @@ -25,12 +29,18 @@ import ( // VersionedProposal contains a versioned proposal. type VersionedProposal struct { - Version spec.DataVersion - Phase0 *phase0.BeaconBlock - Altair *altair.BeaconBlock - Bellatrix *bellatrix.BeaconBlock - Capella *capella.BeaconBlock - Deneb *apiv1deneb.BlockContents + Version spec.DataVersion + Blinded bool + ConsensusValue *big.Int + ExecutionValue *big.Int + Phase0 *phase0.BeaconBlock + Altair *altair.BeaconBlock + Bellatrix *bellatrix.BeaconBlock + BellatrixBlinded *apiv1bellatrix.BlindedBeaconBlock + Capella *capella.BeaconBlock + CapellaBlinded *apiv1capella.BlindedBeaconBlock + Deneb *apiv1deneb.BlockContents + DenebBlinded *apiv1deneb.BlindedBeaconBlock } // IsEmpty returns true if there is no proposal. @@ -38,401 +48,340 @@ func (v *VersionedProposal) IsEmpty() bool { return v.Phase0 == nil && v.Altair == nil && v.Bellatrix == nil && + v.BellatrixBlinded == nil && v.Capella == nil && - v.Deneb == nil + v.CapellaBlinded == nil && + v.Deneb == nil && + v.DenebBlinded == nil } -// Slot returns the slot of the proposal. -func (v *VersionedProposal) Slot() (phase0.Slot, error) { +// BodyRoot returns the body root of the proposal. +func (v *VersionedProposal) BodyRoot() (phase0.Root, error) { + if !v.bodyPresent() { + return phase0.Root{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return 0, ErrDataMissing - } - - return v.Phase0.Slot, nil + return v.Phase0.Body.HashTreeRoot() case spec.DataVersionAltair: - if v.Altair == nil { - return 0, ErrDataMissing - } - - return v.Altair.Slot, nil + return v.Altair.Body.HashTreeRoot() case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.HashTreeRoot() } - return v.Bellatrix.Slot, nil + return v.Bellatrix.Body.HashTreeRoot() case spec.DataVersionCapella: - if v.Capella == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.HashTreeRoot() } - return v.Capella.Slot, nil + return v.Capella.Body.HashTreeRoot() case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.HashTreeRoot() } - return v.Deneb.Block.Slot, nil + return v.Deneb.Block.Body.HashTreeRoot() default: - return 0, ErrUnsupportedVersion + return phase0.Root{}, ErrUnsupportedVersion } } -// ProposerIndex returns the proposer index of the proposal. -func (v *VersionedProposal) ProposerIndex() (phase0.ValidatorIndex, error) { +// ParentRoot returns the parent root of the proposal. +func (v *VersionedProposal) ParentRoot() (phase0.Root, error) { + if !v.proposalPresent() { + return phase0.Root{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return 0, ErrDataMissing - } - - return v.Phase0.ProposerIndex, nil + return v.Phase0.ParentRoot, nil case spec.DataVersionAltair: - if v.Altair == nil { - return 0, ErrDataMissing - } - - return v.Altair.ProposerIndex, nil + return v.Altair.ParentRoot, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.ParentRoot, nil } - return v.Bellatrix.ProposerIndex, nil + return v.Bellatrix.ParentRoot, nil case spec.DataVersionCapella: - if v.Capella == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.ParentRoot, nil } - return v.Capella.ProposerIndex, nil + return v.Capella.ParentRoot, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.ParentRoot, nil } - return v.Deneb.Block.ProposerIndex, nil + return v.Deneb.Block.ParentRoot, nil default: - return 0, ErrUnsupportedVersion + return phase0.Root{}, ErrUnsupportedVersion } } -// RandaoReveal returns the RANDAO reveal of the proposal. -func (v *VersionedProposal) RandaoReveal() (phase0.BLSSignature, error) { +// ProposerIndex returns the proposer index of the proposal. +func (v *VersionedProposal) ProposerIndex() (phase0.ValidatorIndex, error) { + if !v.proposalPresent() { + return 0, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil || - v.Phase0.Body == nil { - return phase0.BLSSignature{}, ErrDataMissing - } - - return v.Phase0.Body.RANDAOReveal, nil + return v.Phase0.ProposerIndex, nil case spec.DataVersionAltair: - if v.Altair == nil || - v.Altair.Body == nil { - return phase0.BLSSignature{}, ErrDataMissing - } - - return v.Altair.Body.RANDAOReveal, nil + return v.Altair.ProposerIndex, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil { - return phase0.BLSSignature{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.ProposerIndex, nil } - return v.Bellatrix.Body.RANDAOReveal, nil + return v.Bellatrix.ProposerIndex, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil { - return phase0.BLSSignature{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.ProposerIndex, nil } - return v.Capella.Body.RANDAOReveal, nil + return v.Capella.ProposerIndex, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil { - return phase0.BLSSignature{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.ProposerIndex, nil } - return v.Deneb.Block.Body.RANDAOReveal, nil + return v.Deneb.Block.ProposerIndex, nil default: - return phase0.BLSSignature{}, ErrUnsupportedVersion + return 0, ErrUnsupportedVersion } } -// Graffiti returns the graffiti of the proposal. -func (v *VersionedProposal) Graffiti() ([32]byte, error) { +// Root returns the root of the proposal. +func (v *VersionedProposal) Root() (phase0.Root, error) { + if !v.proposalPresent() { + return phase0.Root{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil || - v.Phase0.Body == nil { - return [32]byte{}, ErrDataMissing - } - - return v.Phase0.Body.Graffiti, nil + return v.Phase0.HashTreeRoot() case spec.DataVersionAltair: - if v.Altair == nil || - v.Altair.Body == nil { - return [32]byte{}, ErrDataMissing - } - - return v.Altair.Body.Graffiti, nil + return v.Altair.HashTreeRoot() case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil { - return [32]byte{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.HashTreeRoot() } - return v.Bellatrix.Body.Graffiti, nil + return v.Bellatrix.HashTreeRoot() case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil { - return [32]byte{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.HashTreeRoot() } - return v.Capella.Body.Graffiti, nil + return v.Capella.HashTreeRoot() case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil { - return [32]byte{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.HashTreeRoot() } - return v.Deneb.Block.Body.Graffiti, nil + return v.Deneb.Block.HashTreeRoot() default: - return [32]byte{}, ErrUnsupportedVersion + return phase0.Root{}, ErrUnsupportedVersion } } -// Attestations returns the attestations of the proposal. -func (v *VersionedProposal) Attestations() ([]*phase0.Attestation, error) { +// Slot returns the slot of the proposal. +func (v *VersionedProposal) Slot() (phase0.Slot, error) { + if !v.proposalPresent() { + return 0, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil || - v.Phase0.Body == nil { - return nil, ErrDataMissing - } - - return v.Phase0.Body.Attestations, nil + return v.Phase0.Slot, nil case spec.DataVersionAltair: - if v.Altair == nil || - v.Altair.Body == nil { - return nil, ErrDataMissing - } - - return v.Altair.Body.Attestations, nil + return v.Altair.Slot, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil { - return nil, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Slot, nil } - return v.Bellatrix.Body.Attestations, nil + return v.Bellatrix.Slot, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil { - return nil, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Slot, nil } - return v.Capella.Body.Attestations, nil + return v.Capella.Slot, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil { - return nil, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Slot, nil } - return v.Deneb.Block.Body.Attestations, nil + return v.Deneb.Block.Slot, nil default: - return nil, ErrUnsupportedVersion + return 0, ErrUnsupportedVersion } } -// Root returns the root of the proposal. -func (v *VersionedProposal) Root() (phase0.Root, error) { +// StateRoot returns the state root of the proposal. +func (v *VersionedProposal) StateRoot() (phase0.Root, error) { + if !v.proposalPresent() { + return phase0.Root{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Phase0.HashTreeRoot() + return v.Phase0.StateRoot, nil case spec.DataVersionAltair: - if v.Altair == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Altair.HashTreeRoot() + return v.Altair.StateRoot, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.StateRoot, nil } - return v.Bellatrix.HashTreeRoot() + return v.Bellatrix.StateRoot, nil case spec.DataVersionCapella: - if v.Capella == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.StateRoot, nil } - return v.Capella.HashTreeRoot() + return v.Capella.StateRoot, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.StateRoot, nil } - return v.Deneb.Block.HashTreeRoot() + return v.Deneb.Block.StateRoot, nil default: return phase0.Root{}, ErrUnsupportedVersion } } -// BodyRoot returns the body root of the proposal. -func (v *VersionedProposal) BodyRoot() (phase0.Root, error) { +// Attestations returns the attestations of the proposal. +func (v *VersionedProposal) Attestations() ([]*phase0.Attestation, error) { + if !v.bodyPresent() { + return nil, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Phase0.Body.HashTreeRoot() + return v.Phase0.Body.Attestations, nil case spec.DataVersionAltair: - if v.Altair == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Altair.Body.HashTreeRoot() + return v.Altair.Body.Attestations, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.Attestations, nil } - return v.Bellatrix.Body.HashTreeRoot() + return v.Bellatrix.Body.Attestations, nil case spec.DataVersionCapella: - if v.Capella == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.Attestations, nil } - return v.Capella.Body.HashTreeRoot() + return v.Capella.Body.Attestations, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.Attestations, nil } - return v.Deneb.Block.Body.HashTreeRoot() + return v.Deneb.Block.Body.Attestations, nil default: - return phase0.Root{}, ErrUnsupportedVersion + return nil, ErrUnsupportedVersion } } -// ParentRoot returns the parent root of the proposal. -func (v *VersionedProposal) ParentRoot() (phase0.Root, error) { +// Graffiti returns the graffiti of the proposal. +func (v *VersionedProposal) Graffiti() ([32]byte, error) { + if !v.bodyPresent() { + return [32]byte{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Phase0.ParentRoot, nil + return v.Phase0.Body.Graffiti, nil case spec.DataVersionAltair: - if v.Altair == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Altair.ParentRoot, nil + return v.Altair.Body.Graffiti, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.Graffiti, nil } - return v.Bellatrix.ParentRoot, nil + return v.Bellatrix.Body.Graffiti, nil case spec.DataVersionCapella: - if v.Capella == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.Graffiti, nil } - return v.Capella.ParentRoot, nil + return v.Capella.Body.Graffiti, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.Graffiti, nil } - return v.Deneb.Block.ParentRoot, nil + return v.Deneb.Block.Body.Graffiti, nil default: - return phase0.Root{}, ErrUnsupportedVersion + return [32]byte{}, ErrUnsupportedVersion } } -// StateRoot returns the state root of the proposal. -func (v *VersionedProposal) StateRoot() (phase0.Root, error) { +// RandaoReveal returns the RANDAO reveal of the proposal. +func (v *VersionedProposal) RandaoReveal() (phase0.BLSSignature, error) { + if !v.bodyPresent() { + return phase0.BLSSignature{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Phase0.StateRoot, nil + return v.Phase0.Body.RANDAOReveal, nil case spec.DataVersionAltair: - if v.Altair == nil { - return phase0.Root{}, ErrDataMissing - } - - return v.Altair.StateRoot, nil + return v.Altair.Body.RANDAOReveal, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.RANDAOReveal, nil } - return v.Bellatrix.StateRoot, nil + return v.Bellatrix.Body.RANDAOReveal, nil case spec.DataVersionCapella: - if v.Capella == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.RANDAOReveal, nil } - return v.Capella.StateRoot, nil + return v.Capella.Body.RANDAOReveal, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil { - return phase0.Root{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.RANDAOReveal, nil } - return v.Deneb.Block.StateRoot, nil + return v.Deneb.Block.Body.RANDAOReveal, nil default: - return phase0.Root{}, ErrUnsupportedVersion + return phase0.BLSSignature{}, ErrUnsupportedVersion } } // Transactions returns the transactions of the proposal. func (v *VersionedProposal) Transactions() ([]bellatrix.Transaction, error) { + if v.Version >= spec.DataVersionBellatrix && !v.payloadPresent() { + return nil, ErrDataMissing + } + switch v.Version { case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil || - v.Bellatrix.Body.ExecutionPayload == nil { + if v.Blinded { return nil, ErrDataMissing } return v.Bellatrix.Body.ExecutionPayload.Transactions, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil || - v.Capella.Body.ExecutionPayload == nil { + if v.Blinded { return nil, ErrDataMissing } return v.Capella.Body.ExecutionPayload.Transactions, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil || - v.Deneb.Block.Body.ExecutionPayload == nil { + if v.Blinded { return nil, ErrDataMissing } @@ -444,29 +393,26 @@ func (v *VersionedProposal) Transactions() ([]bellatrix.Transaction, error) { // FeeRecipient returns the fee recipient of the proposal. func (v *VersionedProposal) FeeRecipient() (bellatrix.ExecutionAddress, error) { + if v.Version >= spec.DataVersionBellatrix && !v.payloadPresent() { + return bellatrix.ExecutionAddress{}, ErrDataMissing + } + switch v.Version { case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil || - v.Bellatrix.Body.ExecutionPayload == nil { - return bellatrix.ExecutionAddress{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.ExecutionPayloadHeader.FeeRecipient, nil } return v.Bellatrix.Body.ExecutionPayload.FeeRecipient, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil || - v.Capella.Body.ExecutionPayload == nil { - return bellatrix.ExecutionAddress{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.ExecutionPayloadHeader.FeeRecipient, nil } return v.Capella.Body.ExecutionPayload.FeeRecipient, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil || - v.Deneb.Block.Body.ExecutionPayload == nil { - return bellatrix.ExecutionAddress{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.ExecutionPayloadHeader.FeeRecipient, nil } return v.Deneb.Block.Body.ExecutionPayload.FeeRecipient, nil @@ -477,29 +423,26 @@ func (v *VersionedProposal) FeeRecipient() (bellatrix.ExecutionAddress, error) { // Timestamp returns the timestamp of the proposal. func (v *VersionedProposal) Timestamp() (uint64, error) { + if v.Version >= spec.DataVersionBellatrix && !v.payloadPresent() { + return 0, ErrDataMissing + } + switch v.Version { case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Body == nil || - v.Bellatrix.Body.ExecutionPayload == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Body.ExecutionPayloadHeader.Timestamp, nil } return v.Bellatrix.Body.ExecutionPayload.Timestamp, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Body == nil || - v.Capella.Body.ExecutionPayload == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Body.ExecutionPayloadHeader.Timestamp, nil } return v.Capella.Body.ExecutionPayload.Timestamp, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.Block == nil || - v.Deneb.Block.Body == nil || - v.Deneb.Block.Body.ExecutionPayload == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Body.ExecutionPayloadHeader.Timestamp, nil } return v.Deneb.Block.Body.ExecutionPayload.Timestamp, nil @@ -510,9 +453,13 @@ func (v *VersionedProposal) Timestamp() (uint64, error) { // Blobs returns the blobs of the proposal. func (v *VersionedProposal) Blobs() ([]deneb.Blob, error) { + if v.Version >= spec.DataVersionDeneb && !v.payloadPresent() { + return nil, ErrDataMissing + } + switch v.Version { case spec.DataVersionDeneb: - if v.Deneb == nil { + if v.Blinded { return nil, ErrDataMissing } @@ -524,9 +471,13 @@ func (v *VersionedProposal) Blobs() ([]deneb.Blob, error) { // KZGProofs returns the KZG proofs of the proposal. func (v *VersionedProposal) KZGProofs() ([]deneb.KZGProof, error) { + if v.Version >= spec.DataVersionDeneb && !v.payloadPresent() { + return nil, ErrDataMissing + } + switch v.Version { case spec.DataVersionDeneb: - if v.Deneb == nil { + if v.Blinded { return nil, ErrDataMissing } @@ -536,6 +487,19 @@ func (v *VersionedProposal) KZGProofs() ([]deneb.KZGProof, error) { } } +// Value returns the value of the proposal, in Wei. +func (v *VersionedProposal) Value() *big.Int { + value := big.NewInt(0) + if v.ConsensusValue != nil { + value = value.Add(value, v.ConsensusValue) + } + if v.ExecutionValue != nil { + value = value.Add(value, v.ExecutionValue) + } + + return value +} + // String returns a string version of the structure. func (v *VersionedProposal) String() string { switch v.Version { @@ -573,3 +537,90 @@ func (v *VersionedProposal) String() string { return "unknown version" } } + +func (v *VersionedProposal) proposalPresent() bool { + switch v.Version { + case spec.DataVersionPhase0: + return v.Phase0 != nil + case spec.DataVersionAltair: + return v.Altair != nil + case spec.DataVersionBellatrix: + if v.Blinded { + return v.BellatrixBlinded != nil + } + + return v.Bellatrix != nil + case spec.DataVersionCapella: + if v.Blinded { + return v.CapellaBlinded != nil + } + + return v.Capella != nil + case spec.DataVersionDeneb: + if v.Blinded { + return v.DenebBlinded != nil + } + + return v.Deneb.Block != nil + } + + return false +} + +func (v *VersionedProposal) bodyPresent() bool { + switch v.Version { + case spec.DataVersionPhase0: + return v.Phase0 != nil && v.Phase0.Body != nil + case spec.DataVersionAltair: + return v.Altair != nil && v.Altair.Body != nil + case spec.DataVersionBellatrix: + if v.Blinded { + return v.BellatrixBlinded != nil && v.BellatrixBlinded.Body != nil + } + + return v.Bellatrix != nil && v.Bellatrix.Body != nil + case spec.DataVersionCapella: + if v.Blinded { + return v.CapellaBlinded != nil && v.CapellaBlinded.Body != nil + } + + return v.Capella != nil && v.Capella.Body != nil + case spec.DataVersionDeneb: + if v.Blinded { + return v.DenebBlinded != nil && v.DenebBlinded.Body != nil + } + + return v.Deneb != nil && v.Deneb.Block != nil && v.Deneb.Block.Body != nil + } + + return false +} + +func (v *VersionedProposal) payloadPresent() bool { + switch v.Version { + case spec.DataVersionPhase0: + return false + case spec.DataVersionAltair: + return false + case spec.DataVersionBellatrix: + if v.Blinded { + return v.BellatrixBlinded != nil && v.BellatrixBlinded.Body != nil && v.BellatrixBlinded.Body.ExecutionPayloadHeader != nil + } + + return v.Bellatrix != nil && v.Bellatrix.Body != nil && v.Bellatrix.Body.ExecutionPayload != nil + case spec.DataVersionCapella: + if v.Blinded { + return v.CapellaBlinded != nil && v.CapellaBlinded.Body != nil && v.CapellaBlinded.Body.ExecutionPayloadHeader != nil + } + + return v.Capella != nil && v.Capella.Body != nil && v.Capella.Body.ExecutionPayload != nil + case spec.DataVersionDeneb: + if v.Blinded { + return v.DenebBlinded != nil && v.DenebBlinded.Body != nil && v.DenebBlinded.Body.ExecutionPayloadHeader != nil + } + + return v.Deneb != nil && v.Deneb.Block != nil && v.Deneb.Block.Body != nil && v.Deneb.Block.Body.ExecutionPayload != nil + } + + return false +} diff --git a/api/versionedsignedproposal.go b/api/versionedsignedproposal.go index 3767161d..d97d833a 100644 --- a/api/versionedsignedproposal.go +++ b/api/versionedsignedproposal.go @@ -1,4 +1,4 @@ -// Copyright © 2023 Attestant Limited. +// Copyright © 2023, 2024 Attestant Limited. // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at @@ -14,6 +14,11 @@ package api import ( + "errors" + "math/big" + + apiv1bellatrix "github.com/attestantio/go-eth2-client/api/v1/bellatrix" + apiv1capella "github.com/attestantio/go-eth2-client/api/v1/capella" apiv1deneb "github.com/attestantio/go-eth2-client/api/v1/deneb" "github.com/attestantio/go-eth2-client/spec" "github.com/attestantio/go-eth2-client/spec/altair" @@ -24,50 +29,86 @@ import ( // VersionedSignedProposal contains a versioned signed beacon node proposal. type VersionedSignedProposal struct { - Version spec.DataVersion - Phase0 *phase0.SignedBeaconBlock - Altair *altair.SignedBeaconBlock - Bellatrix *bellatrix.SignedBeaconBlock - Capella *capella.SignedBeaconBlock - Deneb *apiv1deneb.SignedBlockContents + Version spec.DataVersion + Blinded bool + ConsensusValue *big.Int + ExecutionValue *big.Int + Phase0 *phase0.SignedBeaconBlock + Altair *altair.SignedBeaconBlock + Bellatrix *bellatrix.SignedBeaconBlock + BellatrixBlinded *apiv1bellatrix.SignedBlindedBeaconBlock + Capella *capella.SignedBeaconBlock + CapellaBlinded *apiv1capella.SignedBlindedBeaconBlock + Deneb *apiv1deneb.SignedBlockContents + DenebBlinded *apiv1deneb.SignedBlindedBeaconBlock } -// Slot returns the slot of the signed proposal. -func (v *VersionedSignedProposal) Slot() (phase0.Slot, error) { +// AssertPresnet throws an error if the expected proposal +// given the version and blinded fields is not present. +func (v *VersionedSignedProposal) AssertPresent() error { switch v.Version { case spec.DataVersionPhase0: - if v.Phase0 == nil || - v.Phase0.Message == nil { - return 0, ErrDataMissing + if v.Phase0 == nil { + return errors.New("phase0 proposal not present") } - - return v.Phase0.Message.Slot, nil case spec.DataVersionAltair: - if v.Altair == nil || - v.Altair.Message == nil { - return 0, ErrDataMissing + if v.Altair == nil { + return errors.New("altair proposal not present") + } + case spec.DataVersionBellatrix: + if v.Bellatrix == nil && !v.Blinded { + return errors.New("bellatrix proposal not present") + } + if v.BellatrixBlinded == nil && v.Blinded { + return errors.New("blinded bellatrix proposal not present") + } + case spec.DataVersionCapella: + if v.Capella == nil && !v.Blinded { + return errors.New("capella proposal not present") + } + if v.CapellaBlinded == nil && v.Blinded { + return errors.New("blinded capella proposal not present") + } + case spec.DataVersionDeneb: + if v.Deneb == nil && !v.Blinded { + return errors.New("deneb proposal not present") + } + if v.DenebBlinded == nil && v.Blinded { + return errors.New("blinded deneb proposal not present") } + default: + return errors.New("unsupported version") + } + + return nil +} + +// Slot returns the slot of the signed proposal. +func (v *VersionedSignedProposal) Slot() (phase0.Slot, error) { + if err := v.assertMessagePresent(); err != nil { + return 0, err + } + switch v.Version { + case spec.DataVersionPhase0: + return v.Phase0.Message.Slot, nil + case spec.DataVersionAltair: return v.Altair.Message.Slot, nil case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Message == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Message.Slot, nil } return v.Bellatrix.Message.Slot, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Message == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Message.Slot, nil } return v.Capella.Message.Slot, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.SignedBlock == nil || - v.Deneb.SignedBlock.Message == nil { - return 0, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Message.Slot, nil } return v.Deneb.SignedBlock.Message.Slot, nil @@ -78,32 +119,26 @@ func (v *VersionedSignedProposal) Slot() (phase0.Slot, error) { // ExecutionBlockHash returns the hash of the execution payload. func (v *VersionedSignedProposal) ExecutionBlockHash() (phase0.Hash32, error) { + if err := v.assertExecutionPayloadPresent(); err != nil { + return phase0.Hash32{}, err + } + switch v.Version { case spec.DataVersionBellatrix: - if v.Bellatrix == nil || - v.Bellatrix.Message == nil || - v.Bellatrix.Message.Body == nil || - v.Bellatrix.Message.Body.ExecutionPayload == nil { - return phase0.Hash32{}, ErrDataMissing + if v.Blinded { + return v.BellatrixBlinded.Message.Body.ExecutionPayloadHeader.BlockHash, nil } return v.Bellatrix.Message.Body.ExecutionPayload.BlockHash, nil case spec.DataVersionCapella: - if v.Capella == nil || - v.Capella.Message == nil || - v.Capella.Message.Body == nil || - v.Capella.Message.Body.ExecutionPayload == nil { - return phase0.Hash32{}, ErrDataMissing + if v.Blinded { + return v.CapellaBlinded.Message.Body.ExecutionPayloadHeader.BlockHash, nil } return v.Capella.Message.Body.ExecutionPayload.BlockHash, nil case spec.DataVersionDeneb: - if v.Deneb == nil || - v.Deneb.SignedBlock == nil || - v.Deneb.SignedBlock.Message == nil || - v.Deneb.SignedBlock.Message.Body == nil || - v.Deneb.SignedBlock.Message.Body.ExecutionPayload == nil { - return phase0.Hash32{}, ErrDataMissing + if v.Blinded { + return v.DenebBlinded.Message.Body.ExecutionPayloadHeader.BlockHash, nil } return v.Deneb.SignedBlock.Message.Body.ExecutionPayload.BlockHash, nil @@ -128,18 +163,42 @@ func (v *VersionedSignedProposal) String() string { return v.Altair.String() case spec.DataVersionBellatrix: + if v.Blinded { + if v.BellatrixBlinded == nil { + return "" + } + + return v.BellatrixBlinded.String() + } + if v.Bellatrix == nil { return "" } return v.Bellatrix.String() case spec.DataVersionCapella: + if v.Blinded { + if v.CapellaBlinded == nil { + return "" + } + + return v.CapellaBlinded.String() + } + if v.Capella == nil { return "" } return v.Capella.String() case spec.DataVersionDeneb: + if v.Blinded { + if v.DenebBlinded == nil { + return "" + } + + return v.DenebBlinded.String() + } + if v.Deneb == nil { return "" } @@ -149,3 +208,113 @@ func (v *VersionedSignedProposal) String() string { return "unsupported version" } } + +// assertMessagePresent throws an error if the expected message +// given the version and blinded fields is not present. +func (v *VersionedSignedProposal) assertMessagePresent() error { + switch v.Version { + case spec.DataVersionBellatrix: + if v.Blinded { + if v.BellatrixBlinded == nil || + v.BellatrixBlinded.Message == nil { + return ErrDataMissing + } + } else { + if v.Bellatrix == nil || + v.Bellatrix.Message == nil { + return ErrDataMissing + } + } + case spec.DataVersionCapella: + if v.Blinded { + if v.CapellaBlinded == nil || + v.CapellaBlinded.Message == nil { + return ErrDataMissing + } + } else { + if v.Capella == nil || + v.Capella.Message == nil { + return ErrDataMissing + } + } + case spec.DataVersionDeneb: + if v.Blinded { + if v.DenebBlinded == nil || + v.DenebBlinded.Message == nil { + return ErrDataMissing + } + } else { + if v.Deneb == nil || + v.Deneb.SignedBlock == nil || + v.Deneb.SignedBlock.Message == nil { + return ErrDataMissing + } + } + default: + return ErrUnsupportedVersion + } + + return nil +} + +// assertExecutionPayloadPresent throws an error if the expected execution payload or payload header +// given the version and blinded fields is not present. +// +//nolint:gocyclo +func (v *VersionedSignedProposal) assertExecutionPayloadPresent() error { + switch v.Version { + case spec.DataVersionBellatrix: + if v.Blinded { + if v.BellatrixBlinded == nil || + v.BellatrixBlinded.Message == nil || + v.BellatrixBlinded.Message.Body == nil || + v.BellatrixBlinded.Message.Body.ExecutionPayloadHeader == nil { + return ErrDataMissing + } + } else { + if v.Bellatrix == nil || + v.Bellatrix.Message == nil || + v.Bellatrix.Message.Body == nil || + v.Bellatrix.Message.Body.ExecutionPayload == nil { + return ErrDataMissing + } + } + case spec.DataVersionCapella: + if v.Blinded { + if v.CapellaBlinded == nil || + v.CapellaBlinded.Message == nil || + v.CapellaBlinded.Message.Body == nil || + v.CapellaBlinded.Message.Body.ExecutionPayloadHeader == nil { + return ErrDataMissing + } + } else { + if v.Capella == nil || + v.Capella.Message == nil || + v.Capella.Message.Body == nil || + v.Capella.Message.Body.ExecutionPayload == nil { + return ErrDataMissing + } + } + case spec.DataVersionDeneb: + if v.Blinded { + if v.DenebBlinded == nil || + v.DenebBlinded.Message == nil || + v.DenebBlinded.Message.Body == nil || + v.DenebBlinded.Message.Body.ExecutionPayloadHeader == nil { + return ErrDataMissing + } + } else { + if v.Deneb == nil || + v.Deneb.SignedBlock == nil || + v.Deneb.SignedBlock.Message == nil || + v.Deneb.SignedBlock.Message.Body == nil || + v.Deneb.SignedBlock.Message.Body.ExecutionPayload == nil { + return ErrDataMissing + } + } + default: + return ErrUnsupportedVersion + } + + return nil +} diff --git a/http/blindedproposal_test.go b/http/blindedproposal_test.go deleted file mode 100644 index 2b642776..00000000 --- a/http/blindedproposal_test.go +++ /dev/null @@ -1,123 +0,0 @@ -// Copyright © 2023 Attestant Limited. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package http_test - -import ( - "context" - "errors" - "os" - "testing" - "time" - - client "github.com/attestantio/go-eth2-client" - "github.com/attestantio/go-eth2-client/api" - "github.com/attestantio/go-eth2-client/http" - "github.com/attestantio/go-eth2-client/spec/phase0" - "github.com/stretchr/testify/require" -) - -func TestBlindedProposal(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - - service, err := http.New(ctx, - http.WithTimeout(timeout), - http.WithAddress(os.Getenv("HTTP_ADDRESS")), - ) - require.NoError(t, err) - - // Need to fetch current slot for proposal. - genesisResponse, err := service.(client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{}) - require.NoError(t, err) - slotDuration, err := service.(client.SlotDurationProvider).SlotDuration(ctx) - require.NoError(t, err) - - tests := []struct { - name string - opts *api.BlindedProposalOpts - expected *api.VersionedBlindedProposal - err string - errCode int - }{ - { - name: "NilOpts", - err: "no options specified", - }, - { - name: "NilSlot", - opts: &api.BlindedProposalOpts{}, - err: "no slot specified", - }, - { - name: "InvalidSkipRANDAO", - opts: &api.BlindedProposalOpts{ - RandaoReveal: phase0.BLSSignature([96]byte{ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - }), - Graffiti: [32]byte{ - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, - 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, - }, - SkipRandaoVerification: true, - Slot: phase0.Slot(uint64(time.Since(genesisResponse.Data.GenesisTime).Seconds())/uint64(slotDuration.Seconds())) + 1, - }, - err: "randao reveal must be point at infinity if skip randao verification is set", - }, - { - name: "Good", - opts: &api.BlindedProposalOpts{ - RandaoReveal: phase0.BLSSignature([96]byte{ - 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - }), - Graffiti: [32]byte{ - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, - 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, - }, - SkipRandaoVerification: true, - Slot: phase0.Slot(uint64(time.Since(genesisResponse.Data.GenesisTime).Seconds())/uint64(slotDuration.Seconds())) + 1, - }, - }, - } - - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - response, err := service.(client.BlindedProposalProvider).BlindedProposal(ctx, test.opts) - switch { - case test.err != "": - require.ErrorContains(t, err, test.err) - case test.errCode != 0: - var apiErr *api.Error - if errors.As(err, &apiErr) { - require.Equal(t, test.errCode, apiErr.StatusCode) - } - default: - require.NoError(t, err) - require.NotNil(t, response) - if test.expected != nil { - require.Equal(t, test.expected, response.Data) - } - } - }) - } -} diff --git a/http/http.go b/http/http.go index ffd6f3ed..5b4424de 100644 --- a/http/http.go +++ b/http/http.go @@ -99,6 +99,8 @@ func (s *Service) post(ctx context.Context, endpoint string, body io.Reader) (io //nolint:unparam func (s *Service) post2(ctx context.Context, endpoint string, + query string, + _ *api.CommonOpts, body io.Reader, contentType ContentType, headers map[string]string, @@ -109,16 +111,22 @@ func (s *Service) post2(ctx context.Context, // #nosec G404 log := s.log.With().Str("id", fmt.Sprintf("%02x", rand.Int31())).Str("address", s.address).Str("endpoint", endpoint).Logger() if e := log.Trace(); e.Enabled() { - bodyBytes, err := io.ReadAll(body) - if err != nil { - return nil, errors.New("failed to read request body") + switch contentType { + case ContentTypeJSON: + bodyBytes, err := io.ReadAll(body) + if err != nil { + return nil, errors.New("failed to read request body") + } + body = bytes.NewReader(bodyBytes) + + e.Str("body", string(bodyBytes)).Msg("POST request") + default: + e.Str("content_type", contentType.String()).Msg("POST request") } - body = bytes.NewReader(bodyBytes) - - e.Str("body", string(bodyBytes)).Msg("POST request") } - url := urlForCall(s.base, endpoint, "") + url := urlForCall(s.base, endpoint, query) + log.Trace().Str("url", url.String()).Msg("URL to POST") opCtx, cancel := context.WithTimeout(ctx, s.timeout) defer cancel() @@ -200,6 +208,7 @@ func (s *Service) get(ctx context.Context, endpoint string, query string, opts * log.Trace().Msg("GET request") url := urlForCall(s.base, endpoint, query) + log.Trace().Str("url", url.String()).Msg("URL to GET") timeout := s.timeout if opts.Timeout != 0 { diff --git a/http/proposal.go b/http/proposal.go index 9cbd1faa..ca33eb80 100644 --- a/http/proposal.go +++ b/http/proposal.go @@ -18,9 +18,13 @@ import ( "context" "errors" "fmt" + "math/big" + "strings" client "github.com/attestantio/go-eth2-client" "github.com/attestantio/go-eth2-client/api" + apiv1bellatrix "github.com/attestantio/go-eth2-client/api/v1/bellatrix" + apiv1capella "github.com/attestantio/go-eth2-client/api/v1/capella" apiv1deneb "github.com/attestantio/go-eth2-client/api/v1/deneb" "github.com/attestantio/go-eth2-client/spec" "github.com/attestantio/go-eth2-client/spec/altair" @@ -50,7 +54,7 @@ func (s *Service) Proposal(ctx context.Context, return nil, errors.Join(errors.New("no slot specified"), client.ErrInvalidOptions) } - endpoint := fmt.Sprintf("/eth/v2/validator/blocks/%d", opts.Slot) + endpoint := fmt.Sprintf("/eth/v3/validator/blocks/%d", opts.Slot) query := fmt.Sprintf("randao_reveal=%#x&graffiti=%#x", opts.RandaoReveal, opts.Graffiti) if opts.SkipRandaoVerification { @@ -60,6 +64,12 @@ func (s *Service) Proposal(ctx context.Context, query = fmt.Sprintf("%s&skip_randao_verification", query) } + if opts.BuilderBoostFactor == nil { + query += "&builder_boost_factor=100" + } else { + query = fmt.Sprintf("%s&builder_boost_factor=%d", query, *opts.BuilderBoostFactor) + } + httpResponse, err := s.get(ctx, endpoint, query, &opts.Common) if err != nil { return nil, errors.Join(errors.New("failed to request beacon block proposal"), err) @@ -113,40 +123,55 @@ func (s *Service) Proposal(ctx context.Context, func (s *Service) beaconBlockProposalFromSSZ(res *httpResponse) (*api.Response[*api.VersionedProposal], error) { response := &api.Response[*api.VersionedProposal]{ Data: &api.VersionedProposal{ - Version: res.consensusVersion, + Version: res.consensusVersion, + ConsensusValue: big.NewInt(0), + ExecutionValue: big.NewInt(0), }, Metadata: metadataFromHeaders(res.headers), } + if err := s.populateProposalDataFromHeaders(response, res.headers); err != nil { + return nil, err + } + + var err error switch res.consensusVersion { case spec.DataVersionPhase0: response.Data.Phase0 = &phase0.BeaconBlock{} - if err := response.Data.Phase0.UnmarshalSSZ(res.body); err != nil { - return nil, errors.Join(errors.New("failed to decode phase0 beacon block proposal"), err) - } + err = response.Data.Phase0.UnmarshalSSZ(res.body) case spec.DataVersionAltair: response.Data.Altair = &altair.BeaconBlock{} - if err := response.Data.Altair.UnmarshalSSZ(res.body); err != nil { - return nil, errors.Join(errors.New("failed to decode altair beacon block proposal"), err) - } + err = response.Data.Altair.UnmarshalSSZ(res.body) case spec.DataVersionBellatrix: - response.Data.Bellatrix = &bellatrix.BeaconBlock{} - if err := response.Data.Bellatrix.UnmarshalSSZ(res.body); err != nil { - return nil, errors.Join(errors.New("failed to decode bellatrix beacon block proposal"), err) + if response.Data.Blinded { + response.Data.BellatrixBlinded = &apiv1bellatrix.BlindedBeaconBlock{} + err = response.Data.BellatrixBlinded.UnmarshalSSZ(res.body) + } else { + response.Data.Bellatrix = &bellatrix.BeaconBlock{} + err = response.Data.Bellatrix.UnmarshalSSZ(res.body) } case spec.DataVersionCapella: - response.Data.Capella = &capella.BeaconBlock{} - if err := response.Data.Capella.UnmarshalSSZ(res.body); err != nil { - return nil, errors.Join(errors.New("failed to decode capella beacon block proposal"), err) + if response.Data.Blinded { + response.Data.CapellaBlinded = &apiv1capella.BlindedBeaconBlock{} + err = response.Data.CapellaBlinded.UnmarshalSSZ(res.body) + } else { + response.Data.Capella = &capella.BeaconBlock{} + err = response.Data.Capella.UnmarshalSSZ(res.body) } case spec.DataVersionDeneb: - response.Data.Deneb = &apiv1deneb.BlockContents{} - if err := response.Data.Deneb.UnmarshalSSZ(res.body); err != nil { - return nil, errors.Join(errors.New("failed to decode deneb beacon block proposal"), err) + if response.Data.Blinded { + response.Data.DenebBlinded = &apiv1deneb.BlindedBeaconBlock{} + err = response.Data.DenebBlinded.UnmarshalSSZ(res.body) + } else { + response.Data.Deneb = &apiv1deneb.BlockContents{} + err = response.Data.Deneb.UnmarshalSSZ(res.body) } default: return nil, fmt.Errorf("unhandled block proposal version %s", res.consensusVersion) } + if err != nil { + return nil, errors.Join(fmt.Errorf("failed to decode %v SSZ beacon block (blinded: %v)", res.consensusVersion, response.Data.Blinded), err) + } return response, nil } @@ -154,8 +179,15 @@ func (s *Service) beaconBlockProposalFromSSZ(res *httpResponse) (*api.Response[* func (s *Service) beaconBlockProposalFromJSON(res *httpResponse) (*api.Response[*api.VersionedProposal], error) { response := &api.Response[*api.VersionedProposal]{ Data: &api.VersionedProposal{ - Version: res.consensusVersion, + Version: res.consensusVersion, + ConsensusValue: big.NewInt(0), + ExecutionValue: big.NewInt(0), }, + Metadata: metadataFromHeaders(res.headers), + } + + if err := s.populateProposalDataFromHeaders(response, res.headers); err != nil { + return nil, err } var err error @@ -165,17 +197,54 @@ func (s *Service) beaconBlockProposalFromJSON(res *httpResponse) (*api.Response[ case spec.DataVersionAltair: response.Data.Altair, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &altair.BeaconBlock{}) case spec.DataVersionBellatrix: - response.Data.Bellatrix, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &bellatrix.BeaconBlock{}) + if response.Data.Blinded { + response.Data.BellatrixBlinded, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &apiv1bellatrix.BlindedBeaconBlock{}) + } else { + response.Data.Bellatrix, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &bellatrix.BeaconBlock{}) + } case spec.DataVersionCapella: - response.Data.Capella, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &capella.BeaconBlock{}) + if response.Data.Blinded { + response.Data.CapellaBlinded, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &apiv1capella.BlindedBeaconBlock{}) + } else { + response.Data.Capella, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &capella.BeaconBlock{}) + } case spec.DataVersionDeneb: - response.Data.Deneb, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &apiv1deneb.BlockContents{}) + if response.Data.Blinded { + response.Data.DenebBlinded, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &apiv1deneb.BlindedBeaconBlock{}) + } else { + response.Data.Deneb, response.Metadata, err = decodeJSONResponse(bytes.NewReader(res.body), &apiv1deneb.BlockContents{}) + } default: err = fmt.Errorf("unsupported version %s", res.consensusVersion) } if err != nil { - return nil, err + return nil, errors.Join(fmt.Errorf("failed to decode %v JSON beacon block (blinded: %v)", res.consensusVersion, response.Data.Blinded), err) } return response, nil } + +func (s *Service) populateProposalDataFromHeaders(response *api.Response[*api.VersionedProposal], + headers map[string]string, +) error { + for k, v := range headers { + switch { + case strings.EqualFold(k, "Eth-Execution-Payload-Blinded"): + response.Data.Blinded = strings.EqualFold(v, "true") + case strings.EqualFold(k, "Eth-Execution-Payload-Value"): + var success bool + response.Data.ExecutionValue, success = new(big.Int).SetString(v, 10) + if !success { + return fmt.Errorf("proposal header Eth-Execution-Payload-Value %s not a valid integer", v) + } + case strings.EqualFold(k, "Eth-Consensus-Block-Value"): + var success bool + response.Data.ConsensusValue, success = new(big.Int).SetString(v, 10) + if !success { + return fmt.Errorf("proposal header Eth-Consensus-Block-Value %s not a valid integer", v) + } + } + } + + return nil +} diff --git a/http/submitblindedproposal.go b/http/submitblindedproposal.go index a810b1ca..6c3b5d6a 100644 --- a/http/submitblindedproposal.go +++ b/http/submitblindedproposal.go @@ -26,28 +26,33 @@ import ( ) // SubmitBlindedProposal submits a blinded proposal. -func (s *Service) SubmitBlindedProposal(ctx context.Context, proposal *api.VersionedSignedBlindedProposal) error { +func (s *Service) SubmitBlindedProposal(ctx context.Context, + opts *api.SubmitBlindedProposalOpts, +) error { if err := s.assertIsSynced(ctx); err != nil { return err } - if proposal == nil { - return errors.Join(errors.New("no blinded proposal supplied"), client.ErrInvalidOptions) + if opts == nil { + return client.ErrNoOptions + } + if opts.Proposal == nil { + return errors.Join(errors.New("no proposal supplied"), client.ErrInvalidOptions) } var specJSON []byte var err error - switch proposal.Version { + switch opts.Proposal.Version { case spec.DataVersionPhase0: err = errors.New("blinded phase0 proposals not supported") case spec.DataVersionAltair: err = errors.New("blinded altair proposals not supported") case spec.DataVersionBellatrix: - specJSON, err = json.Marshal(proposal.Bellatrix) + specJSON, err = json.Marshal(opts.Proposal.Bellatrix) case spec.DataVersionCapella: - specJSON, err = json.Marshal(proposal.Capella) + specJSON, err = json.Marshal(opts.Proposal.Capella) case spec.DataVersionDeneb: - specJSON, err = json.Marshal(proposal.Deneb) + specJSON, err = json.Marshal(opts.Proposal.Deneb) default: err = errors.New("unknown proposal version") } @@ -55,9 +60,15 @@ func (s *Service) SubmitBlindedProposal(ctx context.Context, proposal *api.Versi return errors.Join(errors.New("failed to marshal JSON"), err) } + endpoint := "/eth/v2/beacon/blocks" + query := "" + if opts.BroadcastValidation != nil { + query = "broadcast_validation=" + opts.BroadcastValidation.String() + } + headers := make(map[string]string) - headers["Eth-Consensus-Version"] = strings.ToLower(proposal.Version.String()) - _, err = s.post2(ctx, "/eth/v2/beacon/blinded_blocks", bytes.NewBuffer(specJSON), ContentTypeJSON, headers) + headers["Eth-Consensus-Version"] = strings.ToLower(opts.Proposal.Version.String()) + _, err = s.post2(ctx, endpoint, query, &opts.Common, bytes.NewBuffer(specJSON), ContentTypeJSON, headers) if err != nil { return errors.Join(errors.New("failed to submit blinded proposal"), err) } diff --git a/http/submitproposal.go b/http/submitproposal.go index b20bd355..d3895e51 100644 --- a/http/submitproposal.go +++ b/http/submitproposal.go @@ -26,17 +26,79 @@ import ( ) // SubmitProposal submits a proposal. -func (s *Service) SubmitProposal(ctx context.Context, proposal *api.VersionedSignedProposal) error { +func (s *Service) SubmitProposal(ctx context.Context, + opts *api.SubmitProposalOpts, +) error { if err := s.assertIsSynced(ctx); err != nil { return err } - if proposal == nil { + if opts == nil { + return client.ErrNoOptions + } + if opts.Proposal == nil { return errors.Join(errors.New("no proposal supplied"), client.ErrInvalidOptions) } + body, contentType, err := s.submitProposalData(ctx, opts.Proposal) + if err != nil { + return err + } + + endpoint := "/eth/v2/beacon/blocks" + query := "" + if opts.BroadcastValidation != nil { + query = "broadcast_validation=" + opts.BroadcastValidation.String() + } + + headers := make(map[string]string) + headers["Eth-Consensus-Version"] = strings.ToLower(opts.Proposal.Version.String()) + _, err = s.post2(ctx, endpoint, query, &opts.Common, bytes.NewBuffer(body), contentType, headers) + if err != nil { + return errors.Join(errors.New("failed to submit proposal"), err) + } + + return nil +} + +func (s *Service) submitProposalData(ctx context.Context, + proposal *api.VersionedSignedProposal, +) ( + []byte, + ContentType, + error, +) { + var body []byte + var contentType ContentType + var err error + + if s.enforceJSON { + contentType = ContentTypeJSON + body, err = s.submitProposalJSON(ctx, proposal) + } else { + contentType = ContentTypeSSZ + body, err = s.submitProposalSSZ(ctx, proposal) + } + + if err != nil { + return nil, ContentTypeUnknown, err + } + + return body, contentType, nil +} + +func (s *Service) submitProposalJSON(_ context.Context, + proposal *api.VersionedSignedProposal, +) ( + []byte, + error, +) { var specJSON []byte var err error + if err := proposal.AssertPresent(); err != nil { + return nil, err + } + switch proposal.Version { case spec.DataVersionPhase0: specJSON, err = json.Marshal(proposal.Phase0) @@ -52,15 +114,42 @@ func (s *Service) SubmitProposal(ctx context.Context, proposal *api.VersionedSig err = errors.New("unknown proposal version") } if err != nil { - return errors.Join(errors.New("failed to marshal JSON"), err) + return nil, errors.Join(errors.New("failed to marshal JSON"), err) } - headers := make(map[string]string) - headers["Eth-Consensus-Version"] = strings.ToLower(proposal.Version.String()) - _, err = s.post2(ctx, "/eth/v1/beacon/blocks", bytes.NewBuffer(specJSON), ContentTypeJSON, headers) + return specJSON, nil +} + +func (s *Service) submitProposalSSZ(_ context.Context, + proposal *api.VersionedSignedProposal, +) ( + []byte, + error, +) { + var specSSZ []byte + var err error + + if err := proposal.AssertPresent(); err != nil { + return nil, err + } + + switch proposal.Version { + case spec.DataVersionPhase0: + specSSZ, err = proposal.Phase0.MarshalSSZ() + case spec.DataVersionAltair: + specSSZ, err = proposal.Altair.MarshalSSZ() + case spec.DataVersionBellatrix: + specSSZ, err = proposal.Bellatrix.MarshalSSZ() + case spec.DataVersionCapella: + specSSZ, err = proposal.Capella.MarshalSSZ() + case spec.DataVersionDeneb: + specSSZ, err = proposal.Deneb.MarshalSSZ() + default: + err = errors.New("unknown proposal version") + } if err != nil { - return errors.Join(errors.New("failed to submit proposal"), err) + return nil, errors.Join(errors.New("failed to marshal SSZ"), err) } - return nil + return specSSZ, nil } diff --git a/http/submitproposal_test.go b/http/submitproposal_test.go index 9cd935fc..50be39bb 100644 --- a/http/submitproposal_test.go +++ b/http/submitproposal_test.go @@ -113,7 +113,9 @@ func TestSubmitProposal(t *testing.T) { t.Fatalf("unknown block version %s", res.Data.Version.String()) } // Some implementations return an error and some don't, so do not check. - service.(client.ProposalSubmitter).SubmitProposal(ctx, signedBeaconBlock) // nolint:errcheck + service.(client.ProposalSubmitter).SubmitProposal(ctx, &api.SubmitProposalOpts{ + Proposal: signedBeaconBlock, + }) // nolint:errcheck }) } } diff --git a/multi/blindedproposal.go b/multi/blindedproposal.go deleted file mode 100644 index 7bf04342..00000000 --- a/multi/blindedproposal.go +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright © 2021, 2023 Attestant Limited. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package multi - -import ( - "context" - - consensusclient "github.com/attestantio/go-eth2-client" - "github.com/attestantio/go-eth2-client/api" -) - -// BlindedProposal fetches a blinded proposal for signing. -func (s *Service) BlindedProposal(ctx context.Context, - opts *api.BlindedProposalOpts, -) ( - *api.Response[*api.VersionedBlindedProposal], - error, -) { - res, err := s.doCall(ctx, func(ctx context.Context, client consensusclient.Service) (interface{}, error) { - block, err := client.(consensusclient.BlindedProposalProvider).BlindedProposal(ctx, opts) - if err != nil { - return nil, err - } - - return block, nil - }, nil) - if err != nil { - return nil, err - } - - return res.(*api.Response[*api.VersionedBlindedProposal]), nil -} diff --git a/multi/submitproposal.go b/multi/submitproposal.go index 1717c16e..df058c66 100644 --- a/multi/submitproposal.go +++ b/multi/submitproposal.go @@ -21,9 +21,11 @@ import ( ) // SubmitProposal submits a beacon block. -func (s *Service) SubmitProposal(ctx context.Context, proposal *api.VersionedSignedProposal) error { +func (s *Service) SubmitProposal(ctx context.Context, + opts *api.SubmitProposalOpts, +) error { _, err := s.doCall(ctx, func(ctx context.Context, client consensusclient.Service) (interface{}, error) { - err := client.(consensusclient.ProposalSubmitter).SubmitProposal(ctx, proposal) + err := client.(consensusclient.ProposalSubmitter).SubmitProposal(ctx, opts) if err != nil { return nil, err } diff --git a/service.go b/service.go index 5c6de46b..90544a71 100644 --- a/service.go +++ b/service.go @@ -256,7 +256,7 @@ type BeaconBlockSubmitter interface { // ProposalSubmitter is the interface for submitting proposals. type ProposalSubmitter interface { // SubmitProposal submits a proposal. - SubmitProposal(ctx context.Context, block *api.VersionedSignedProposal) error + SubmitProposal(ctx context.Context, opts *api.SubmitProposalOpts) error } // BeaconCommitteeSubscriptionsSubmitter is the interface for submitting beacon committee subnet subscription requests. @@ -283,12 +283,6 @@ type BeaconStateRootProvider interface { BeaconStateRoot(ctx context.Context, opts *api.BeaconStateRootOpts) (*api.Response[*phase0.Root], error) } -// BlindedProposalProvider is the interface for providing blinded beacon block proposals. -type BlindedProposalProvider interface { - // BlindedProposal fetches a blinded proposed beacon block for signing. - BlindedProposal(ctx context.Context, opts *api.BlindedProposalOpts) (*api.Response[*api.VersionedBlindedProposal], error) -} - // BlindedBeaconBlockSubmitter is the interface for submitting blinded beacon blocks. type BlindedBeaconBlockSubmitter interface { // SubmitBlindedBeaconBlock submits a beacon block. @@ -300,7 +294,7 @@ type BlindedBeaconBlockSubmitter interface { // BlindedProposalSubmitter is the interface for submitting blinded proposals. type BlindedProposalSubmitter interface { // SubmitBlindedProposal submits a beacon block. - SubmitBlindedProposal(ctx context.Context, block *api.VersionedSignedBlindedProposal) error + SubmitBlindedProposal(ctx context.Context, opts *api.SubmitBlindedProposalOpts) error } // ValidatorRegistrationsSubmitter is the interface for submitting validator registrations.