Script to compute state root for a specific block/state pair

compute_state_root.go

package main

import (
	"context"
	"flag"
	"log"

	"github.com/prysmaticlabs/go-ssz"
	"github.com/prysmaticlabs/prysm/beacon-chain/core/state"
	"github.com/prysmaticlabs/prysm/beacon-chain/db"
	"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
	"github.com/prysmaticlabs/prysm/shared/bytesutil"
	"github.com/prysmaticlabs/prysm/shared/params"
)

var dbPath = flag.String("db", "", "path to db")

func main() {
	flag.Parse()
	beaconDB, err := db.NewDB(*dbPath)
	if err != nil {
		log.Fatal(err)
	}
	ctx := context.Background()
	block, err := beaconDB.HeadBlock(ctx)
	if err != nil {
		log.Fatal(err)
	}
	beaconState, err := beaconDB.HeadState(ctx)
	if err != nil {
		log.Fatal(err)
	}
	headRoot, err := ssz.SigningRoot(block)
	if err != nil {
		log.Fatal(err)
	}
	stateRoot, err := ssz.HashTreeRoot(beaconState)
	if err != nil {
		log.Fatal(err)
	}
	parentBlock, err := beaconDB.Block(ctx, bytesutil.ToBytes32(block.ParentRoot))
	if err != nil {
		log.Fatal(err)
	}
	parentRoot, err := ssz.SigningRoot(parentBlock)
	if err != nil {
		log.Fatal(err)
	}

	atts, err := beaconDB.Attestations(ctx, filters.NewFilter().SetHeadBlockRoot(parentRoot[:]))
	if err != nil {
		log.Fatal(err)
	}

	blk := &ethpb.BeaconBlock{
		Slot:       block.Slot+1,
		ParentRoot: headRoot[:],
		StateRoot:  stateRoot[:],
		Body: &ethpb.BeaconBlockBody{
			Eth1Data:   &ethpb.Eth1Data{
				DepositRoot:          make([]byte, 32),
				DepositCount:         0,
				BlockHash:            make([]byte, 32),
			},
			Deposits:     []*ethpb.Deposit{},
			Attestations: atts,
			RandaoReveal: make([]byte, 96),
			// TODO(2766): Implement rest of the retrievals for beacon block operations
			Transfers:         []*ethpb.Transfer{},
			ProposerSlashings: []*ethpb.ProposerSlashing{},
			AttesterSlashings: []*ethpb.AttesterSlashing{},
			VoluntaryExits:    []*ethpb.VoluntaryExit{},
			Graffiti:          []byte{},
		},
		Signature: make([]byte, 96),
	}

	params.UseDemoBeaconConfig()

	computed, err := state.ExecuteStateTransitionNoVerify(
		ctx,
		beaconState,
		blk,
	)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(computed)
}