Skip to content

Commit

Permalink
migrating Beacon API code from eip4844 to deneb-integration (#12568)
Browse files Browse the repository at this point in the history
  • Loading branch information
@james-prysm
james-prysm committed Aug 4, 2023
1 parent 3a1d61d commit e810d23
Show file tree
Hide file tree
Showing 34 changed files with 8,077 additions and 2,648 deletions.
3 changes: 3 additions & 0 deletions api/client/builder/client.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -376,6 +376,9 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
r.Header.Add("Eth-Consensus-Version", version.String(version.Deneb))
}
rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), versionOpt)
if err != nil {
return nil, nil, errors.Wrap(err, "error posting the SignedBlindedBeaconBlockDeneb to the builder api")
}
ep := &ExecPayloadResponseDeneb{}
if err := json.Unmarshal(rb, ep); err != nil {
return nil, nil, errors.Wrap(err, "error unmarshaling the builder SubmitBlindedBlockDeneb response")
Expand Down
301 changes: 211 additions & 90 deletions beacon-chain/rpc/apimiddleware/custom_hooks.go
View file

Large diffs are not rendered by default.

190 changes: 175 additions & 15 deletions beacon-chain/rpc/apimiddleware/custom_hooks_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -297,13 +297,15 @@ func TestSetInitialPublishBlockPostRequest(t *testing.T) {
params.SetupTestConfigCleanup(t)
cfg := params.BeaconConfig().Copy()
cfg.BellatrixForkEpoch = params.BeaconConfig().AltairForkEpoch + 1
cfg.CapellaForkEpoch = params.BeaconConfig().BellatrixForkEpoch + 1
cfg.DenebForkEpoch = params.BeaconConfig().CapellaForkEpoch + 1
params.OverrideBeaconConfig(cfg)

endpoint := &apimiddleware.Endpoint{}
s := struct {
Message struct {
Slot string
}
} `json:"message"`
}{}
t.Run("Phase 0", func(t *testing.T) {
s.Message = struct{ Slot string }{Slot: "0"}
Expand All @@ -316,7 +318,7 @@ func TestSetInitialPublishBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Altair", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
Expand All @@ -331,7 +333,7 @@ func TestSetInitialPublishBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockAltairContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockAltairJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Bellatrix", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
Expand All @@ -346,7 +348,7 @@ func TestSetInitialPublishBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockBellatrixContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockBellatrixJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Capella", func(t *testing.T) {
params.SetupTestConfigCleanup(t)
Expand All @@ -366,14 +368,48 @@ func TestSetInitialPublishBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockCapellaContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockCapellaJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Deneb", func(t *testing.T) {
params.SetupTestConfigCleanup(t)
cfg := params.BeaconConfig()
cfg.DenebForkEpoch = cfg.CapellaForkEpoch.Add(2)
params.OverrideBeaconConfig(cfg)
slot, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
require.NoError(t, err)
denebS := struct {
SignedBlock struct {
Message struct {
Slot string
} `json:"message"`
} `json:"signed_block"`
}{}
denebS.SignedBlock = struct {
Message struct {
Slot string
} `json:"message"`
}{
Message: struct {
Slot string
}{Slot: strconv.FormatUint(uint64(slot), 10)},
}
j, err := json.Marshal(denebS)
require.NoError(t, err)
var body bytes.Buffer
_, err = body.Write(j)
require.NoError(t, err)
request := httptest.NewRequest("POST", "http://foo.example", &body)
runDefault, errJson := setInitialPublishBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockContentsDenebJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
}

func TestPreparePublishedBlock(t *testing.T) {
t.Run("Phase 0", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBeaconBlockContainerJson{
PostRequest: &SignedBeaconBlockJson{
Message: &BeaconBlockJson{
Body: &BeaconBlockBodyJson{},
},
Expand All @@ -387,7 +423,7 @@ func TestPreparePublishedBlock(t *testing.T) {

t.Run("Altair", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBeaconBlockAltairContainerJson{
PostRequest: &SignedBeaconBlockAltairJson{
Message: &BeaconBlockAltairJson{
Body: &BeaconBlockBodyAltairJson{},
},
Expand All @@ -401,7 +437,7 @@ func TestPreparePublishedBlock(t *testing.T) {

t.Run("Bellatrix", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBeaconBlockBellatrixContainerJson{
PostRequest: &SignedBeaconBlockBellatrixJson{
Message: &BeaconBlockBellatrixJson{
Body: &BeaconBlockBodyBellatrixJson{},
},
Expand All @@ -423,13 +459,15 @@ func TestSetInitialPublishBlindedBlockPostRequest(t *testing.T) {
params.SetupTestConfigCleanup(t)
cfg := params.BeaconConfig().Copy()
cfg.BellatrixForkEpoch = params.BeaconConfig().AltairForkEpoch + 1
cfg.CapellaForkEpoch = params.BeaconConfig().BellatrixForkEpoch + 1
cfg.DenebForkEpoch = params.BeaconConfig().CapellaForkEpoch + 1
params.OverrideBeaconConfig(cfg)

endpoint := &apimiddleware.Endpoint{}
s := struct {
Message struct {
Slot string
}
} `json:"message"`
}{}
t.Run("Phase 0", func(t *testing.T) {
s.Message = struct{ Slot string }{Slot: "0"}
Expand All @@ -442,7 +480,7 @@ func TestSetInitialPublishBlindedBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlindedBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Altair", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
Expand All @@ -457,7 +495,7 @@ func TestSetInitialPublishBlindedBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlindedBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockAltairContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBeaconBlockAltairJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Bellatrix", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
Expand All @@ -472,14 +510,59 @@ func TestSetInitialPublishBlindedBlockPostRequest(t *testing.T) {
runDefault, errJson := setInitialPublishBlindedBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBlindedBeaconBlockBellatrixContainerJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
assert.Equal(t, reflect.TypeOf(SignedBlindedBeaconBlockBellatrixJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Capella", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
require.NoError(t, err)
s.Message = struct{ Slot string }{Slot: strconv.FormatUint(uint64(slot), 10)}
j, err := json.Marshal(s)
require.NoError(t, err)
var body bytes.Buffer
_, err = body.Write(j)
require.NoError(t, err)
request := httptest.NewRequest("POST", "http://foo.example", &body)
runDefault, errJson := setInitialPublishBlindedBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBlindedBeaconBlockCapellaJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
t.Run("Deneb", func(t *testing.T) {
slot, err := slots.EpochStart(params.BeaconConfig().DenebForkEpoch)
require.NoError(t, err)
denebS := struct {
SignedBlindedBlock struct {
Message struct {
Slot string
} `json:"message"`
} `json:"signed_blinded_block"`
}{}
denebS.SignedBlindedBlock = struct {
Message struct {
Slot string
} `json:"message"`
}{
Message: struct {
Slot string
}{Slot: strconv.FormatUint(uint64(slot), 10)},
}
j, err := json.Marshal(denebS)
require.NoError(t, err)
var body bytes.Buffer
_, err = body.Write(j)
require.NoError(t, err)
request := httptest.NewRequest("POST", "http://foo.example", &body)
runDefault, errJson := setInitialPublishBlindedBlockPostRequest(endpoint, nil, request)
require.Equal(t, true, errJson == nil)
assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
assert.Equal(t, reflect.TypeOf(SignedBlindedBeaconBlockContentsDenebJson{}).Name(), reflect.Indirect(reflect.ValueOf(endpoint.PostRequest)).Type().Name())
})
}

func TestPreparePublishedBlindedBlock(t *testing.T) {
t.Run("Phase 0", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBeaconBlockContainerJson{
PostRequest: &SignedBeaconBlockJson{
Message: &BeaconBlockJson{
Body: &BeaconBlockBodyJson{},
},
Expand All @@ -493,7 +576,7 @@ func TestPreparePublishedBlindedBlock(t *testing.T) {

t.Run("Altair", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBeaconBlockAltairContainerJson{
PostRequest: &SignedBeaconBlockAltairJson{
Message: &BeaconBlockAltairJson{
Body: &BeaconBlockBodyAltairJson{},
},
Expand All @@ -507,7 +590,7 @@ func TestPreparePublishedBlindedBlock(t *testing.T) {

t.Run("Bellatrix", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBlindedBeaconBlockBellatrixContainerJson{
PostRequest: &SignedBlindedBeaconBlockBellatrixJson{
Message: &BlindedBeaconBlockBellatrixJson{
Body: &BlindedBeaconBlockBodyBellatrixJson{},
},
Expand All @@ -518,7 +601,34 @@ func TestPreparePublishedBlindedBlock(t *testing.T) {
_, ok := endpoint.PostRequest.(*bellatrixPublishBlindedBlockRequestJson)
assert.Equal(t, true, ok)
})
t.Run("Capella", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBlindedBeaconBlockCapellaJson{
Message: &BlindedBeaconBlockCapellaJson{
Body: &BlindedBeaconBlockBodyCapellaJson{},
},
},
}
errJson := preparePublishedBlindedBlock(endpoint, nil, nil)
require.Equal(t, true, errJson == nil)
_, ok := endpoint.PostRequest.(*capellaPublishBlindedBlockRequestJson)
assert.Equal(t, true, ok)
})

t.Run("Deneb", func(t *testing.T) {
endpoint := &apimiddleware.Endpoint{
PostRequest: &SignedBlindedBeaconBlockContentsDenebJson{
SignedBlindedBlock: &SignedBlindedBeaconBlockDenebJson{
Message: &BlindedBeaconBlockDenebJson{},
},
SignedBlindedBlobSidecars: []*SignedBlindedBlobSidecarJson{},
},
}
errJson := preparePublishedBlindedBlock(endpoint, nil, nil)
require.Equal(t, true, errJson == nil)
_, ok := endpoint.PostRequest.(*denebPublishBlindedBlockRequestJson)
assert.Equal(t, true, ok)
})
t.Run("unsupported block type", func(t *testing.T) {
errJson := preparePublishedBlock(&apimiddleware.Endpoint{}, nil, nil)
assert.Equal(t, true, strings.Contains(errJson.Msg(), "unsupported block type"))
Expand Down Expand Up @@ -1050,6 +1160,56 @@ func TestSerializeProducedV2Block(t *testing.T) {
assert.Equal(t, "root", beaconBlock.StateRoot)
require.NotNil(t, beaconBlock.Body)
})
t.Run("Deneb", func(t *testing.T) {
response := &ProduceBlockResponseV2Json{
Version: ethpbv2.Version_DENEB.String(),
Data: &BeaconBlockContainerV2Json{
DenebContents: &BeaconBlockContentsDenebJson{
Block: &BeaconBlockDenebJson{
Slot: "1",
ProposerIndex: "1",
ParentRoot: "root",
StateRoot: "root",
Body: &BeaconBlockBodyDenebJson{},
},
BlobSidecars: []*BlobSidecarJson{{
BlockRoot: "root",
Index: "1",
Slot: "1",
BlockParentRoot: "root",
ProposerIndex: "1",
Blob: "blob",
KzgCommitment: "kzgcommitment",
KzgProof: "kzgproof",
}},
},
},
}
runDefault, j, errJson := serializeProducedV2Block(response)
require.Equal(t, nil, errJson)
require.Equal(t, apimiddleware.RunDefault(false), runDefault)
require.NotNil(t, j)
resp := &denebProduceBlockResponseJson{}
require.NoError(t, json.Unmarshal(j, resp))
require.NotNil(t, resp.Data)
require.NotNil(t, resp.Data)
beaconBlock := resp.Data.Block
assert.Equal(t, "1", beaconBlock.Slot)
assert.Equal(t, "1", beaconBlock.ProposerIndex)
assert.Equal(t, "root", beaconBlock.ParentRoot)
assert.Equal(t, "root", beaconBlock.StateRoot)
assert.NotNil(t, beaconBlock.Body)
require.Equal(t, 1, len(resp.Data.BlobSidecars))
sidecar := resp.Data.BlobSidecars[0]
assert.Equal(t, "root", sidecar.BlockRoot)
assert.Equal(t, "1", sidecar.Index)
assert.Equal(t, "1", sidecar.Slot)
assert.Equal(t, "root", sidecar.BlockParentRoot)
assert.Equal(t, "1", sidecar.ProposerIndex)
assert.Equal(t, "blob", sidecar.Blob)
assert.Equal(t, "kzgcommitment", sidecar.KzgCommitment)
assert.Equal(t, "kzgproof", sidecar.KzgProof)
})
t.Run("incorrect response type", func(t *testing.T) {
response := &types.Empty{}
runDefault, j, errJson := serializeProducedV2Block(response)
Expand Down
Loading

0 comments on commit e810d23

Please sign in to comment.