diff --git a/Makefile b/Makefile
index 3bcd92f..a34d6d2 100644
--- a/Makefile
+++ b/Makefile
@@ -1,12 +1,12 @@
 
 .PHONY:
 build-spec-tests:
-	go run github.com/ferranbt/fastssz/sszgen --path ./spectests/structs.go --exclude-objs Hash
+	go run github.com/ferranbt/fastssz/sszgen --path ./spectests/structs.go --exclude-objs Hash,Uint256
 	go run github.com/ferranbt/fastssz/sszgen --path ./tests
 
 .PHONY:
 get-spec-tests:
-	./scripts/download-spec-tests.sh v1.1.10
+	./scripts/download-spec-tests.sh v1.3.0-rc.0
 
 .PHONY:
 generate-testcases:
diff --git a/spectests/structs.go b/spectests/structs.go
index 0247219..31c91c3 100644
--- a/spectests/structs.go
+++ b/spectests/structs.go
@@ -318,3 +318,124 @@ type ExecutionPayloadHeader struct {
 	BlockHash        []byte `json:"block_hash" ssz-size:"32"`
 	TransactionsRoot []byte `json:"transactions_root" ssz-size:"32"`
 }
+
+// Capella types
+
+type Uint256 [32]byte
+
+type ExecutionPayloadCapella struct {
+	ParentHash    [32]byte      `ssz-size:"32" json:"parent_hash"`
+	FeeRecipient  [20]byte      `ssz-size:"20" json:"fee_recipient"`
+	StateRoot     [32]byte      `ssz-size:"32" json:"state_root"`
+	ReceiptsRoot  [32]byte      `ssz-size:"32" json:"receipts_root"`
+	LogsBloom     [256]byte     `ssz-size:"256" json:"logs_bloom"`
+	PrevRandao    [32]byte      `ssz-size:"32" json:"prev_randao"`
+	BlockNumber   uint64        `json:"block_number"`
+	GasLimit      uint64        `json:"gas_limit"`
+	GasUsed       uint64        `json:"gas_used"`
+	Timestamp     uint64        `json:"timestamp"`
+	ExtraData     []byte        `ssz-max:"32" json:"extra_data"`
+	BaseFeePerGas Uint256       `ssz-size:"32" json:"base_fee_per_gas"`
+	BlockHash     [32]byte      `ssz-size:"32" json:"block_hash"`
+	Transactions  [][]byte      `ssz-max:"1048576,1073741824" ssz-size:"?,?" json:"transactions"`
+	Withdrawals   []*Withdrawal `json:"withdrawals" ssz-max:"16"`
+}
+
+type ExecutionPayloadHeaderCapella struct {
+	ParentHash       [32]byte  `json:"parent_hash" ssz-size:"32"`
+	FeeRecipient     [20]byte  `json:"fee_recipient" ssz-size:"20"`
+	StateRoot        [32]byte  `json:"state_root" ssz-size:"32"`
+	ReceiptsRoot     [32]byte  `json:"receipts_root" ssz-size:"32"`
+	LogsBloom        [256]byte `json:"logs_bloom" ssz-size:"256"`
+	PrevRandao       [32]byte  `json:"prev_randao" ssz-size:"32"`
+	BlockNumber      uint64    `json:"block_number"`
+	GasLimit         uint64    `json:"gas_limit"`
+	GasUsed          uint64    `json:"gas_used"`
+	Timestamp        uint64    `json:"timestamp"`
+	ExtraData        []byte    `json:"extra_data" ssz-max:"32"`
+	BaseFeePerGas    Uint256   `json:"base_fee_per_gas" ssz-size:"32"`
+	BlockHash        [32]byte  `json:"block_hash" ssz-size:"32"`
+	TransactionsRoot [32]byte  `json:"transactions_root" ssz-size:"32"`
+	WithdrawalRoot   [32]byte  `json:"withdrawals_root" ssz-size:"32"`
+}
+
+type BLSToExecutionChange struct {
+	ValidatorIndex     uint64   `json:"validator_index"`
+	FromBLSPubKey      [48]byte `json:"from_bls_pubkey" ssz-size:"48"`
+	ToExecutionAddress [20]byte `json:"to_execution_address" ssz-size:"20"`
+}
+
+type HistoricalSummary struct {
+	BlockSummaryRoot [32]byte `json:"block_summary_root" ssz-size:"32"`
+	StateSummaryRoot [32]byte `json:"state_summary_root" ssz-size:"32"`
+}
+
+type SignedBLSToExecutionChange struct {
+	Message   *BLSToExecutionChange `json:"message"`
+	Signature [96]byte              `json:"signature" ssz-size:"96"`
+}
+
+type Withdrawal struct {
+	Index          uint64   `json:"index"`
+	ValidatorIndex uint64   `json:"validator_index"`
+	Address        [20]byte `json:"address" ssz-size:"20"`
+	Amount         uint64   `json:"amount"`
+}
+
+type BeaconStateCapella struct {
+	GenesisTime                  uint64                         `json:"genesis_time"`
+	GenesisValidatorsRoot        [32]byte                       `json:"genesis_validators_root" ssz-size:"32"`
+	Slot                         uint64                         `json:"slot"`
+	Fork                         *Fork                          `json:"fork"`
+	LatestBlockHeader            *BeaconBlockHeader             `json:"latest_block_header"`
+	BlockRoots                   [8192][32]byte                 `json:"block_roots" ssz-size:"8192,32"`
+	StateRoots                   [8192][32]byte                 `json:"state_roots" ssz-size:"8192,32"`
+	HistoricalRoots              [][]byte                       `json:"historical_roots" ssz-max:"16777216" ssz-size:"?,32"`
+	Eth1Data                     *Eth1Data                      `json:"eth1_data"`
+	Eth1DataVotes                []*Eth1Data                    `json:"eth1_data_votes" ssz-max:"2048"`
+	Eth1DepositIndex             uint64                         `json:"eth1_deposit_index"`
+	Validators                   []*Validator                   `json:"validators" ssz-max:"1099511627776"`
+	Balances                     []uint64                       `json:"balances" ssz-max:"1099511627776"`
+	RandaoMixes                  [65536][32]byte                `json:"randao_mixes" ssz-size:"65536,32"`
+	Slashings                    []uint64                       `json:"slashings" ssz-size:"8192"`
+	PreviousEpochParticipation   []byte                         `json:"previous_epoch_participation" ssz-max:"1099511627776"`
+	CurrentEpochParticipation    []byte                         `json:"current_epoch_participation" ssz-max:"1099511627776"`
+	JustificationBits            [1]byte                        `json:"justification_bits" ssz-size:"1"`
+	PreviousJustifiedCheckpoint  *Checkpoint                    `json:"previous_justified_checkpoint"`
+	CurrentJustifiedCheckpoint   *Checkpoint                    `json:"current_justified_checkpoint"`
+	FinalizedCheckpoint          *Checkpoint                    `json:"finalized_checkpoint"`
+	InactivityScores             []uint64                       `json:"inactivity_scores" ssz-max:"1099511627776"`
+	CurrentSyncCommittee         *SyncCommittee                 `json:"current_sync_committee"`
+	NextSyncCommittee            *SyncCommittee                 `json:"next_sync_committee"`
+	LatestExecutionPayloadHeader *ExecutionPayloadHeaderCapella `json:"latest_execution_payload_header"`
+	NextWithdrawalIndex          uint64                         `json:"next_withdrawal_index"`
+	NextWithdrawalValidatorIndex uint64                         `json:"next_withdrawal_validator_index"`
+	HistoricalSummaries          []*HistoricalSummary           `json:"historical_summaries" ssz-max:"16777216"`
+}
+
+type SignedBeaconBlockCapella struct {
+	Block     *BeaconBlockCapella `json:"message"`
+	Signature []byte              `json:"signature" ssz-size:"96"`
+}
+
+type BeaconBlockCapella struct {
+	Slot          uint64                  `json:"slot"`
+	ProposerIndex uint64                  `json:"proposer_index"`
+	ParentRoot    [32]byte                `json:"parent_root" ssz-size:"32"`
+	StateRoot     [32]byte                `json:"state_root" ssz-size:"32"`
+	Body          *BeaconBlockBodyCapella `json:"body"`
+}
+
+type BeaconBlockBodyCapella struct {
+	RandaoReveal          []byte                        `json:"randao_reveal" ssz-size:"96"`
+	Eth1Data              *Eth1Data                     `json:"eth1_data"`
+	Graffiti              [32]byte                      `json:"graffiti" ssz-size:"32"`
+	ProposerSlashings     []*ProposerSlashing           `json:"proposer_slashings" ssz-max:"16"`
+	AttesterSlashings     []*AttesterSlashing           `json:"attester_slashings" ssz-max:"2"`
+	Attestations          []*Attestation                `json:"attestations" ssz-max:"128"`
+	Deposits              []*Deposit                    `json:"deposits" ssz-max:"16"`
+	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits" ssz-max:"16"`
+	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
+	ExecutionPayload      *ExecutionPayloadCapella      `json:"execution_payload"`
+	BlsToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes" ssz-max:"16"`
+}
diff --git a/spectests/structs_encoding.go b/spectests/structs_encoding.go
index 31940a8..cc8dff9 100644
--- a/spectests/structs_encoding.go
+++ b/spectests/structs_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
-// Hash: cfac9e341705c688752501b280887d264459049d96995c02d8131318075eda9e
-// Version: 0.1.3-dev
+// Hash: 4b6082d3c45d849a722cdecd961b0f2104e825fb90ec076853be18a10cbdeb41
+// Version: 0.1.3
 package spectests
 
 import (
@@ -7360,3 +7360,2518 @@ func (e *ExecutionPayloadHeader) HashTreeRootWith(hh ssz.HashWalker) (err error)
 func (e *ExecutionPayloadHeader) GetTree() (*ssz.Node, error) {
 	return ssz.ProofTree(e)
 }
+
+// MarshalSSZ ssz marshals the ExecutionPayloadCapella object
+func (e *ExecutionPayloadCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(e)
+}
+
+// MarshalSSZTo ssz marshals the ExecutionPayloadCapella object to a target array
+func (e *ExecutionPayloadCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(512)
+
+	// Field (0) 'ParentHash'
+	dst = append(dst, e.ParentHash[:]...)
+
+	// Field (1) 'FeeRecipient'
+	dst = append(dst, e.FeeRecipient[:]...)
+
+	// Field (2) 'StateRoot'
+	dst = append(dst, e.StateRoot[:]...)
+
+	// Field (3) 'ReceiptsRoot'
+	dst = append(dst, e.ReceiptsRoot[:]...)
+
+	// Field (4) 'LogsBloom'
+	dst = append(dst, e.LogsBloom[:]...)
+
+	// Field (5) 'PrevRandao'
+	dst = append(dst, e.PrevRandao[:]...)
+
+	// Field (6) 'BlockNumber'
+	dst = ssz.MarshalUint64(dst, e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	dst = ssz.MarshalUint64(dst, e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	dst = ssz.MarshalUint64(dst, e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	dst = ssz.MarshalUint64(dst, e.Timestamp)
+
+	// Offset (10) 'ExtraData'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.ExtraData)
+
+	// Field (11) 'BaseFeePerGas'
+	dst = append(dst, e.BaseFeePerGas[:]...)
+
+	// Field (12) 'BlockHash'
+	dst = append(dst, e.BlockHash[:]...)
+
+	// Offset (13) 'Transactions'
+	dst = ssz.WriteOffset(dst, offset)
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		offset += 4
+		offset += len(e.Transactions[ii])
+	}
+
+	// Offset (14) 'Withdrawals'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.Withdrawals) * 44
+
+	// Field (10) 'ExtraData'
+	if size := len(e.ExtraData); size > 32 {
+		err = ssz.ErrBytesLengthFn("ExecutionPayloadCapella.ExtraData", size, 32)
+		return
+	}
+	dst = append(dst, e.ExtraData...)
+
+	// Field (13) 'Transactions'
+	if size := len(e.Transactions); size > 1048576 {
+		err = ssz.ErrListTooBigFn("ExecutionPayloadCapella.Transactions", size, 1048576)
+		return
+	}
+	{
+		offset = 4 * len(e.Transactions)
+		for ii := 0; ii < len(e.Transactions); ii++ {
+			dst = ssz.WriteOffset(dst, offset)
+			offset += len(e.Transactions[ii])
+		}
+	}
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		if size := len(e.Transactions[ii]); size > 1073741824 {
+			err = ssz.ErrBytesLengthFn("ExecutionPayloadCapella.Transactions[ii]", size, 1073741824)
+			return
+		}
+		dst = append(dst, e.Transactions[ii]...)
+	}
+
+	// Field (14) 'Withdrawals'
+	if size := len(e.Withdrawals); size > 16 {
+		err = ssz.ErrListTooBigFn("ExecutionPayloadCapella.Withdrawals", size, 16)
+		return
+	}
+	for ii := 0; ii < len(e.Withdrawals); ii++ {
+		if dst, err = e.Withdrawals[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the ExecutionPayloadCapella object
+func (e *ExecutionPayloadCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 512 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o10, o13, o14 uint64
+
+	// Field (0) 'ParentHash'
+	copy(e.ParentHash[:], buf[0:32])
+
+	// Field (1) 'FeeRecipient'
+	copy(e.FeeRecipient[:], buf[32:52])
+
+	// Field (2) 'StateRoot'
+	copy(e.StateRoot[:], buf[52:84])
+
+	// Field (3) 'ReceiptsRoot'
+	copy(e.ReceiptsRoot[:], buf[84:116])
+
+	// Field (4) 'LogsBloom'
+	copy(e.LogsBloom[:], buf[116:372])
+
+	// Field (5) 'PrevRandao'
+	copy(e.PrevRandao[:], buf[372:404])
+
+	// Field (6) 'BlockNumber'
+	e.BlockNumber = ssz.UnmarshallUint64(buf[404:412])
+
+	// Field (7) 'GasLimit'
+	e.GasLimit = ssz.UnmarshallUint64(buf[412:420])
+
+	// Field (8) 'GasUsed'
+	e.GasUsed = ssz.UnmarshallUint64(buf[420:428])
+
+	// Field (9) 'Timestamp'
+	e.Timestamp = ssz.UnmarshallUint64(buf[428:436])
+
+	// Offset (10) 'ExtraData'
+	if o10 = ssz.ReadOffset(buf[436:440]); o10 > size {
+		return ssz.ErrOffset
+	}
+
+	if o10 < 512 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	copy(e.BaseFeePerGas[:], buf[440:472])
+
+	// Field (12) 'BlockHash'
+	copy(e.BlockHash[:], buf[472:504])
+
+	// Offset (13) 'Transactions'
+	if o13 = ssz.ReadOffset(buf[504:508]); o13 > size || o10 > o13 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (14) 'Withdrawals'
+	if o14 = ssz.ReadOffset(buf[508:512]); o14 > size || o13 > o14 {
+		return ssz.ErrOffset
+	}
+
+	// Field (10) 'ExtraData'
+	{
+		buf = tail[o10:o13]
+		if len(buf) > 32 {
+			return ssz.ErrBytesLength
+		}
+		if cap(e.ExtraData) == 0 {
+			e.ExtraData = make([]byte, 0, len(buf))
+		}
+		e.ExtraData = append(e.ExtraData, buf...)
+	}
+
+	// Field (13) 'Transactions'
+	{
+		buf = tail[o13:o14]
+		num, err := ssz.DecodeDynamicLength(buf, 1048576)
+		if err != nil {
+			return err
+		}
+		e.Transactions = make([][]byte, num)
+		err = ssz.UnmarshalDynamic(buf, num, func(indx int, buf []byte) (err error) {
+			if len(buf) > 1073741824 {
+				return ssz.ErrBytesLength
+			}
+			if cap(e.Transactions[indx]) == 0 {
+				e.Transactions[indx] = make([]byte, 0, len(buf))
+			}
+			e.Transactions[indx] = append(e.Transactions[indx], buf...)
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Field (14) 'Withdrawals'
+	{
+		buf = tail[o14:]
+		num, err := ssz.DivideInt2(len(buf), 44, 16)
+		if err != nil {
+			return err
+		}
+		e.Withdrawals = make([]*Withdrawal, num)
+		for ii := 0; ii < num; ii++ {
+			if e.Withdrawals[ii] == nil {
+				e.Withdrawals[ii] = new(Withdrawal)
+			}
+			if err = e.Withdrawals[ii].UnmarshalSSZ(buf[ii*44 : (ii+1)*44]); err != nil {
+				return err
+			}
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadCapella object
+func (e *ExecutionPayloadCapella) SizeSSZ() (size int) {
+	size = 512
+
+	// Field (10) 'ExtraData'
+	size += len(e.ExtraData)
+
+	// Field (13) 'Transactions'
+	for ii := 0; ii < len(e.Transactions); ii++ {
+		size += 4
+		size += len(e.Transactions[ii])
+	}
+
+	// Field (14) 'Withdrawals'
+	size += len(e.Withdrawals) * 44
+
+	return
+}
+
+// HashTreeRoot ssz hashes the ExecutionPayloadCapella object
+func (e *ExecutionPayloadCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(e)
+}
+
+// HashTreeRootWith ssz hashes the ExecutionPayloadCapella object with a hasher
+func (e *ExecutionPayloadCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ParentHash'
+	hh.PutBytes(e.ParentHash[:])
+
+	// Field (1) 'FeeRecipient'
+	hh.PutBytes(e.FeeRecipient[:])
+
+	// Field (2) 'StateRoot'
+	hh.PutBytes(e.StateRoot[:])
+
+	// Field (3) 'ReceiptsRoot'
+	hh.PutBytes(e.ReceiptsRoot[:])
+
+	// Field (4) 'LogsBloom'
+	hh.PutBytes(e.LogsBloom[:])
+
+	// Field (5) 'PrevRandao'
+	hh.PutBytes(e.PrevRandao[:])
+
+	// Field (6) 'BlockNumber'
+	hh.PutUint64(e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	hh.PutUint64(e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	hh.PutUint64(e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	hh.PutUint64(e.Timestamp)
+
+	// Field (10) 'ExtraData'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(e.ExtraData))
+		if byteLen > 32 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.Append(e.ExtraData)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (32+31)/32)
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	hh.PutBytes(e.BaseFeePerGas[:])
+
+	// Field (12) 'BlockHash'
+	hh.PutBytes(e.BlockHash[:])
+
+	// Field (13) 'Transactions'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(e.Transactions))
+		if num > 1048576 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range e.Transactions {
+			{
+				elemIndx := hh.Index()
+				byteLen := uint64(len(elem))
+				if byteLen > 1073741824 {
+					err = ssz.ErrIncorrectListSize
+					return
+				}
+				hh.AppendBytes32(elem)
+				hh.MerkleizeWithMixin(elemIndx, byteLen, (1073741824+31)/32)
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 1048576)
+	}
+
+	// Field (14) 'Withdrawals'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(e.Withdrawals))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range e.Withdrawals {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the ExecutionPayloadCapella object
+func (e *ExecutionPayloadCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(e)
+}
+
+// MarshalSSZ ssz marshals the ExecutionPayloadHeaderCapella object
+func (e *ExecutionPayloadHeaderCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(e)
+}
+
+// MarshalSSZTo ssz marshals the ExecutionPayloadHeaderCapella object to a target array
+func (e *ExecutionPayloadHeaderCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(568)
+
+	// Field (0) 'ParentHash'
+	dst = append(dst, e.ParentHash[:]...)
+
+	// Field (1) 'FeeRecipient'
+	dst = append(dst, e.FeeRecipient[:]...)
+
+	// Field (2) 'StateRoot'
+	dst = append(dst, e.StateRoot[:]...)
+
+	// Field (3) 'ReceiptsRoot'
+	dst = append(dst, e.ReceiptsRoot[:]...)
+
+	// Field (4) 'LogsBloom'
+	dst = append(dst, e.LogsBloom[:]...)
+
+	// Field (5) 'PrevRandao'
+	dst = append(dst, e.PrevRandao[:]...)
+
+	// Field (6) 'BlockNumber'
+	dst = ssz.MarshalUint64(dst, e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	dst = ssz.MarshalUint64(dst, e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	dst = ssz.MarshalUint64(dst, e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	dst = ssz.MarshalUint64(dst, e.Timestamp)
+
+	// Offset (10) 'ExtraData'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(e.ExtraData)
+
+	// Field (11) 'BaseFeePerGas'
+	dst = append(dst, e.BaseFeePerGas[:]...)
+
+	// Field (12) 'BlockHash'
+	dst = append(dst, e.BlockHash[:]...)
+
+	// Field (13) 'TransactionsRoot'
+	dst = append(dst, e.TransactionsRoot[:]...)
+
+	// Field (14) 'WithdrawalRoot'
+	dst = append(dst, e.WithdrawalRoot[:]...)
+
+	// Field (10) 'ExtraData'
+	if size := len(e.ExtraData); size > 32 {
+		err = ssz.ErrBytesLengthFn("ExecutionPayloadHeaderCapella.ExtraData", size, 32)
+		return
+	}
+	dst = append(dst, e.ExtraData...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the ExecutionPayloadHeaderCapella object
+func (e *ExecutionPayloadHeaderCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 568 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o10 uint64
+
+	// Field (0) 'ParentHash'
+	copy(e.ParentHash[:], buf[0:32])
+
+	// Field (1) 'FeeRecipient'
+	copy(e.FeeRecipient[:], buf[32:52])
+
+	// Field (2) 'StateRoot'
+	copy(e.StateRoot[:], buf[52:84])
+
+	// Field (3) 'ReceiptsRoot'
+	copy(e.ReceiptsRoot[:], buf[84:116])
+
+	// Field (4) 'LogsBloom'
+	copy(e.LogsBloom[:], buf[116:372])
+
+	// Field (5) 'PrevRandao'
+	copy(e.PrevRandao[:], buf[372:404])
+
+	// Field (6) 'BlockNumber'
+	e.BlockNumber = ssz.UnmarshallUint64(buf[404:412])
+
+	// Field (7) 'GasLimit'
+	e.GasLimit = ssz.UnmarshallUint64(buf[412:420])
+
+	// Field (8) 'GasUsed'
+	e.GasUsed = ssz.UnmarshallUint64(buf[420:428])
+
+	// Field (9) 'Timestamp'
+	e.Timestamp = ssz.UnmarshallUint64(buf[428:436])
+
+	// Offset (10) 'ExtraData'
+	if o10 = ssz.ReadOffset(buf[436:440]); o10 > size {
+		return ssz.ErrOffset
+	}
+
+	if o10 < 568 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	copy(e.BaseFeePerGas[:], buf[440:472])
+
+	// Field (12) 'BlockHash'
+	copy(e.BlockHash[:], buf[472:504])
+
+	// Field (13) 'TransactionsRoot'
+	copy(e.TransactionsRoot[:], buf[504:536])
+
+	// Field (14) 'WithdrawalRoot'
+	copy(e.WithdrawalRoot[:], buf[536:568])
+
+	// Field (10) 'ExtraData'
+	{
+		buf = tail[o10:]
+		if len(buf) > 32 {
+			return ssz.ErrBytesLength
+		}
+		if cap(e.ExtraData) == 0 {
+			e.ExtraData = make([]byte, 0, len(buf))
+		}
+		e.ExtraData = append(e.ExtraData, buf...)
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the ExecutionPayloadHeaderCapella object
+func (e *ExecutionPayloadHeaderCapella) SizeSSZ() (size int) {
+	size = 568
+
+	// Field (10) 'ExtraData'
+	size += len(e.ExtraData)
+
+	return
+}
+
+// HashTreeRoot ssz hashes the ExecutionPayloadHeaderCapella object
+func (e *ExecutionPayloadHeaderCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(e)
+}
+
+// HashTreeRootWith ssz hashes the ExecutionPayloadHeaderCapella object with a hasher
+func (e *ExecutionPayloadHeaderCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ParentHash'
+	hh.PutBytes(e.ParentHash[:])
+
+	// Field (1) 'FeeRecipient'
+	hh.PutBytes(e.FeeRecipient[:])
+
+	// Field (2) 'StateRoot'
+	hh.PutBytes(e.StateRoot[:])
+
+	// Field (3) 'ReceiptsRoot'
+	hh.PutBytes(e.ReceiptsRoot[:])
+
+	// Field (4) 'LogsBloom'
+	hh.PutBytes(e.LogsBloom[:])
+
+	// Field (5) 'PrevRandao'
+	hh.PutBytes(e.PrevRandao[:])
+
+	// Field (6) 'BlockNumber'
+	hh.PutUint64(e.BlockNumber)
+
+	// Field (7) 'GasLimit'
+	hh.PutUint64(e.GasLimit)
+
+	// Field (8) 'GasUsed'
+	hh.PutUint64(e.GasUsed)
+
+	// Field (9) 'Timestamp'
+	hh.PutUint64(e.Timestamp)
+
+	// Field (10) 'ExtraData'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(e.ExtraData))
+		if byteLen > 32 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.Append(e.ExtraData)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (32+31)/32)
+	}
+
+	// Field (11) 'BaseFeePerGas'
+	hh.PutBytes(e.BaseFeePerGas[:])
+
+	// Field (12) 'BlockHash'
+	hh.PutBytes(e.BlockHash[:])
+
+	// Field (13) 'TransactionsRoot'
+	hh.PutBytes(e.TransactionsRoot[:])
+
+	// Field (14) 'WithdrawalRoot'
+	hh.PutBytes(e.WithdrawalRoot[:])
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the ExecutionPayloadHeaderCapella object
+func (e *ExecutionPayloadHeaderCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(e)
+}
+
+// MarshalSSZ ssz marshals the BLSToExecutionChange object
+func (b *BLSToExecutionChange) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(b)
+}
+
+// MarshalSSZTo ssz marshals the BLSToExecutionChange object to a target array
+func (b *BLSToExecutionChange) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'ValidatorIndex'
+	dst = ssz.MarshalUint64(dst, b.ValidatorIndex)
+
+	// Field (1) 'FromBLSPubKey'
+	dst = append(dst, b.FromBLSPubKey[:]...)
+
+	// Field (2) 'ToExecutionAddress'
+	dst = append(dst, b.ToExecutionAddress[:]...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the BLSToExecutionChange object
+func (b *BLSToExecutionChange) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 76 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'ValidatorIndex'
+	b.ValidatorIndex = ssz.UnmarshallUint64(buf[0:8])
+
+	// Field (1) 'FromBLSPubKey'
+	copy(b.FromBLSPubKey[:], buf[8:56])
+
+	// Field (2) 'ToExecutionAddress'
+	copy(b.ToExecutionAddress[:], buf[56:76])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the BLSToExecutionChange object
+func (b *BLSToExecutionChange) SizeSSZ() (size int) {
+	size = 76
+	return
+}
+
+// HashTreeRoot ssz hashes the BLSToExecutionChange object
+func (b *BLSToExecutionChange) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(b)
+}
+
+// HashTreeRootWith ssz hashes the BLSToExecutionChange object with a hasher
+func (b *BLSToExecutionChange) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'ValidatorIndex'
+	hh.PutUint64(b.ValidatorIndex)
+
+	// Field (1) 'FromBLSPubKey'
+	hh.PutBytes(b.FromBLSPubKey[:])
+
+	// Field (2) 'ToExecutionAddress'
+	hh.PutBytes(b.ToExecutionAddress[:])
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the BLSToExecutionChange object
+func (b *BLSToExecutionChange) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(b)
+}
+
+// MarshalSSZ ssz marshals the HistoricalSummary object
+func (h *HistoricalSummary) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(h)
+}
+
+// MarshalSSZTo ssz marshals the HistoricalSummary object to a target array
+func (h *HistoricalSummary) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'BlockSummaryRoot'
+	dst = append(dst, h.BlockSummaryRoot[:]...)
+
+	// Field (1) 'StateSummaryRoot'
+	dst = append(dst, h.StateSummaryRoot[:]...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the HistoricalSummary object
+func (h *HistoricalSummary) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 64 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'BlockSummaryRoot'
+	copy(h.BlockSummaryRoot[:], buf[0:32])
+
+	// Field (1) 'StateSummaryRoot'
+	copy(h.StateSummaryRoot[:], buf[32:64])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the HistoricalSummary object
+func (h *HistoricalSummary) SizeSSZ() (size int) {
+	size = 64
+	return
+}
+
+// HashTreeRoot ssz hashes the HistoricalSummary object
+func (h *HistoricalSummary) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(h)
+}
+
+// HashTreeRootWith ssz hashes the HistoricalSummary object with a hasher
+func (h *HistoricalSummary) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'BlockSummaryRoot'
+	hh.PutBytes(h.BlockSummaryRoot[:])
+
+	// Field (1) 'StateSummaryRoot'
+	hh.PutBytes(h.StateSummaryRoot[:])
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the HistoricalSummary object
+func (h *HistoricalSummary) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(h)
+}
+
+// MarshalSSZ ssz marshals the SignedBLSToExecutionChange object
+func (s *SignedBLSToExecutionChange) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(s)
+}
+
+// MarshalSSZTo ssz marshals the SignedBLSToExecutionChange object to a target array
+func (s *SignedBLSToExecutionChange) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'Message'
+	if s.Message == nil {
+		s.Message = new(BLSToExecutionChange)
+	}
+	if dst, err = s.Message.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (1) 'Signature'
+	dst = append(dst, s.Signature[:]...)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the SignedBLSToExecutionChange object
+func (s *SignedBLSToExecutionChange) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 172 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'Message'
+	if s.Message == nil {
+		s.Message = new(BLSToExecutionChange)
+	}
+	if err = s.Message.UnmarshalSSZ(buf[0:76]); err != nil {
+		return err
+	}
+
+	// Field (1) 'Signature'
+	copy(s.Signature[:], buf[76:172])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the SignedBLSToExecutionChange object
+func (s *SignedBLSToExecutionChange) SizeSSZ() (size int) {
+	size = 172
+	return
+}
+
+// HashTreeRoot ssz hashes the SignedBLSToExecutionChange object
+func (s *SignedBLSToExecutionChange) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(s)
+}
+
+// HashTreeRootWith ssz hashes the SignedBLSToExecutionChange object with a hasher
+func (s *SignedBLSToExecutionChange) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'Message'
+	if s.Message == nil {
+		s.Message = new(BLSToExecutionChange)
+	}
+	if err = s.Message.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (1) 'Signature'
+	hh.PutBytes(s.Signature[:])
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the SignedBLSToExecutionChange object
+func (s *SignedBLSToExecutionChange) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(s)
+}
+
+// MarshalSSZ ssz marshals the Withdrawal object
+func (w *Withdrawal) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(w)
+}
+
+// MarshalSSZTo ssz marshals the Withdrawal object to a target array
+func (w *Withdrawal) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+
+	// Field (0) 'Index'
+	dst = ssz.MarshalUint64(dst, w.Index)
+
+	// Field (1) 'ValidatorIndex'
+	dst = ssz.MarshalUint64(dst, w.ValidatorIndex)
+
+	// Field (2) 'Address'
+	dst = append(dst, w.Address[:]...)
+
+	// Field (3) 'Amount'
+	dst = ssz.MarshalUint64(dst, w.Amount)
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the Withdrawal object
+func (w *Withdrawal) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size != 44 {
+		return ssz.ErrSize
+	}
+
+	// Field (0) 'Index'
+	w.Index = ssz.UnmarshallUint64(buf[0:8])
+
+	// Field (1) 'ValidatorIndex'
+	w.ValidatorIndex = ssz.UnmarshallUint64(buf[8:16])
+
+	// Field (2) 'Address'
+	copy(w.Address[:], buf[16:36])
+
+	// Field (3) 'Amount'
+	w.Amount = ssz.UnmarshallUint64(buf[36:44])
+
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the Withdrawal object
+func (w *Withdrawal) SizeSSZ() (size int) {
+	size = 44
+	return
+}
+
+// HashTreeRoot ssz hashes the Withdrawal object
+func (w *Withdrawal) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(w)
+}
+
+// HashTreeRootWith ssz hashes the Withdrawal object with a hasher
+func (w *Withdrawal) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'Index'
+	hh.PutUint64(w.Index)
+
+	// Field (1) 'ValidatorIndex'
+	hh.PutUint64(w.ValidatorIndex)
+
+	// Field (2) 'Address'
+	hh.PutBytes(w.Address[:])
+
+	// Field (3) 'Amount'
+	hh.PutUint64(w.Amount)
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the Withdrawal object
+func (w *Withdrawal) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(w)
+}
+
+// MarshalSSZ ssz marshals the BeaconStateCapella object
+func (b *BeaconStateCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(b)
+}
+
+// MarshalSSZTo ssz marshals the BeaconStateCapella object to a target array
+func (b *BeaconStateCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(2736653)
+
+	// Field (0) 'GenesisTime'
+	dst = ssz.MarshalUint64(dst, b.GenesisTime)
+
+	// Field (1) 'GenesisValidatorsRoot'
+	dst = append(dst, b.GenesisValidatorsRoot[:]...)
+
+	// Field (2) 'Slot'
+	dst = ssz.MarshalUint64(dst, b.Slot)
+
+	// Field (3) 'Fork'
+	if b.Fork == nil {
+		b.Fork = new(Fork)
+	}
+	if dst, err = b.Fork.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (4) 'LatestBlockHeader'
+	if b.LatestBlockHeader == nil {
+		b.LatestBlockHeader = new(BeaconBlockHeader)
+	}
+	if dst, err = b.LatestBlockHeader.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (5) 'BlockRoots'
+	for ii := 0; ii < 8192; ii++ {
+		dst = append(dst, b.BlockRoots[ii][:]...)
+	}
+
+	// Field (6) 'StateRoots'
+	for ii := 0; ii < 8192; ii++ {
+		dst = append(dst, b.StateRoots[ii][:]...)
+	}
+
+	// Offset (7) 'HistoricalRoots'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.HistoricalRoots) * 32
+
+	// Field (8) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if dst, err = b.Eth1Data.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Offset (9) 'Eth1DataVotes'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.Eth1DataVotes) * 72
+
+	// Field (10) 'Eth1DepositIndex'
+	dst = ssz.MarshalUint64(dst, b.Eth1DepositIndex)
+
+	// Offset (11) 'Validators'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.Validators) * 121
+
+	// Offset (12) 'Balances'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.Balances) * 8
+
+	// Field (13) 'RandaoMixes'
+	for ii := 0; ii < 65536; ii++ {
+		dst = append(dst, b.RandaoMixes[ii][:]...)
+	}
+
+	// Field (14) 'Slashings'
+	if size := len(b.Slashings); size != 8192 {
+		err = ssz.ErrVectorLengthFn("BeaconStateCapella.Slashings", size, 8192)
+		return
+	}
+	for ii := 0; ii < 8192; ii++ {
+		dst = ssz.MarshalUint64(dst, b.Slashings[ii])
+	}
+
+	// Offset (15) 'PreviousEpochParticipation'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.PreviousEpochParticipation)
+
+	// Offset (16) 'CurrentEpochParticipation'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.CurrentEpochParticipation)
+
+	// Field (17) 'JustificationBits'
+	dst = append(dst, b.JustificationBits[:]...)
+
+	// Field (18) 'PreviousJustifiedCheckpoint'
+	if b.PreviousJustifiedCheckpoint == nil {
+		b.PreviousJustifiedCheckpoint = new(Checkpoint)
+	}
+	if dst, err = b.PreviousJustifiedCheckpoint.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (19) 'CurrentJustifiedCheckpoint'
+	if b.CurrentJustifiedCheckpoint == nil {
+		b.CurrentJustifiedCheckpoint = new(Checkpoint)
+	}
+	if dst, err = b.CurrentJustifiedCheckpoint.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (20) 'FinalizedCheckpoint'
+	if b.FinalizedCheckpoint == nil {
+		b.FinalizedCheckpoint = new(Checkpoint)
+	}
+	if dst, err = b.FinalizedCheckpoint.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Offset (21) 'InactivityScores'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.InactivityScores) * 8
+
+	// Field (22) 'CurrentSyncCommittee'
+	if b.CurrentSyncCommittee == nil {
+		b.CurrentSyncCommittee = new(SyncCommittee)
+	}
+	if dst, err = b.CurrentSyncCommittee.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (23) 'NextSyncCommittee'
+	if b.NextSyncCommittee == nil {
+		b.NextSyncCommittee = new(SyncCommittee)
+	}
+	if dst, err = b.NextSyncCommittee.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Offset (24) 'LatestExecutionPayloadHeader'
+	dst = ssz.WriteOffset(dst, offset)
+	if b.LatestExecutionPayloadHeader == nil {
+		b.LatestExecutionPayloadHeader = new(ExecutionPayloadHeaderCapella)
+	}
+	offset += b.LatestExecutionPayloadHeader.SizeSSZ()
+
+	// Field (25) 'NextWithdrawalIndex'
+	dst = ssz.MarshalUint64(dst, b.NextWithdrawalIndex)
+
+	// Field (26) 'NextWithdrawalValidatorIndex'
+	dst = ssz.MarshalUint64(dst, b.NextWithdrawalValidatorIndex)
+
+	// Offset (27) 'HistoricalSummaries'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.HistoricalSummaries) * 64
+
+	// Field (7) 'HistoricalRoots'
+	if size := len(b.HistoricalRoots); size > 16777216 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.HistoricalRoots", size, 16777216)
+		return
+	}
+	for ii := 0; ii < len(b.HistoricalRoots); ii++ {
+		if size := len(b.HistoricalRoots[ii]); size != 32 {
+			err = ssz.ErrBytesLengthFn("BeaconStateCapella.HistoricalRoots[ii]", size, 32)
+			return
+		}
+		dst = append(dst, b.HistoricalRoots[ii]...)
+	}
+
+	// Field (9) 'Eth1DataVotes'
+	if size := len(b.Eth1DataVotes); size > 2048 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.Eth1DataVotes", size, 2048)
+		return
+	}
+	for ii := 0; ii < len(b.Eth1DataVotes); ii++ {
+		if dst, err = b.Eth1DataVotes[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (11) 'Validators'
+	if size := len(b.Validators); size > 1099511627776 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.Validators", size, 1099511627776)
+		return
+	}
+	for ii := 0; ii < len(b.Validators); ii++ {
+		if dst, err = b.Validators[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (12) 'Balances'
+	if size := len(b.Balances); size > 1099511627776 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.Balances", size, 1099511627776)
+		return
+	}
+	for ii := 0; ii < len(b.Balances); ii++ {
+		dst = ssz.MarshalUint64(dst, b.Balances[ii])
+	}
+
+	// Field (15) 'PreviousEpochParticipation'
+	if size := len(b.PreviousEpochParticipation); size > 1099511627776 {
+		err = ssz.ErrBytesLengthFn("BeaconStateCapella.PreviousEpochParticipation", size, 1099511627776)
+		return
+	}
+	dst = append(dst, b.PreviousEpochParticipation...)
+
+	// Field (16) 'CurrentEpochParticipation'
+	if size := len(b.CurrentEpochParticipation); size > 1099511627776 {
+		err = ssz.ErrBytesLengthFn("BeaconStateCapella.CurrentEpochParticipation", size, 1099511627776)
+		return
+	}
+	dst = append(dst, b.CurrentEpochParticipation...)
+
+	// Field (21) 'InactivityScores'
+	if size := len(b.InactivityScores); size > 1099511627776 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.InactivityScores", size, 1099511627776)
+		return
+	}
+	for ii := 0; ii < len(b.InactivityScores); ii++ {
+		dst = ssz.MarshalUint64(dst, b.InactivityScores[ii])
+	}
+
+	// Field (24) 'LatestExecutionPayloadHeader'
+	if dst, err = b.LatestExecutionPayloadHeader.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (27) 'HistoricalSummaries'
+	if size := len(b.HistoricalSummaries); size > 16777216 {
+		err = ssz.ErrListTooBigFn("BeaconStateCapella.HistoricalSummaries", size, 16777216)
+		return
+	}
+	for ii := 0; ii < len(b.HistoricalSummaries); ii++ {
+		if dst, err = b.HistoricalSummaries[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the BeaconStateCapella object
+func (b *BeaconStateCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 2736653 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o7, o9, o11, o12, o15, o16, o21, o24, o27 uint64
+
+	// Field (0) 'GenesisTime'
+	b.GenesisTime = ssz.UnmarshallUint64(buf[0:8])
+
+	// Field (1) 'GenesisValidatorsRoot'
+	copy(b.GenesisValidatorsRoot[:], buf[8:40])
+
+	// Field (2) 'Slot'
+	b.Slot = ssz.UnmarshallUint64(buf[40:48])
+
+	// Field (3) 'Fork'
+	if b.Fork == nil {
+		b.Fork = new(Fork)
+	}
+	if err = b.Fork.UnmarshalSSZ(buf[48:64]); err != nil {
+		return err
+	}
+
+	// Field (4) 'LatestBlockHeader'
+	if b.LatestBlockHeader == nil {
+		b.LatestBlockHeader = new(BeaconBlockHeader)
+	}
+	if err = b.LatestBlockHeader.UnmarshalSSZ(buf[64:176]); err != nil {
+		return err
+	}
+
+	// Field (5) 'BlockRoots'
+
+	for ii := 0; ii < 8192; ii++ {
+		copy(b.BlockRoots[ii][:], buf[176:262320][ii*32:(ii+1)*32])
+	}
+
+	// Field (6) 'StateRoots'
+
+	for ii := 0; ii < 8192; ii++ {
+		copy(b.StateRoots[ii][:], buf[262320:524464][ii*32:(ii+1)*32])
+	}
+
+	// Offset (7) 'HistoricalRoots'
+	if o7 = ssz.ReadOffset(buf[524464:524468]); o7 > size {
+		return ssz.ErrOffset
+	}
+
+	if o7 < 2736653 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (8) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if err = b.Eth1Data.UnmarshalSSZ(buf[524468:524540]); err != nil {
+		return err
+	}
+
+	// Offset (9) 'Eth1DataVotes'
+	if o9 = ssz.ReadOffset(buf[524540:524544]); o9 > size || o7 > o9 {
+		return ssz.ErrOffset
+	}
+
+	// Field (10) 'Eth1DepositIndex'
+	b.Eth1DepositIndex = ssz.UnmarshallUint64(buf[524544:524552])
+
+	// Offset (11) 'Validators'
+	if o11 = ssz.ReadOffset(buf[524552:524556]); o11 > size || o9 > o11 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (12) 'Balances'
+	if o12 = ssz.ReadOffset(buf[524556:524560]); o12 > size || o11 > o12 {
+		return ssz.ErrOffset
+	}
+
+	// Field (13) 'RandaoMixes'
+
+	for ii := 0; ii < 65536; ii++ {
+		copy(b.RandaoMixes[ii][:], buf[524560:2621712][ii*32:(ii+1)*32])
+	}
+
+	// Field (14) 'Slashings'
+	b.Slashings = ssz.ExtendUint64(b.Slashings, 8192)
+	for ii := 0; ii < 8192; ii++ {
+		b.Slashings[ii] = ssz.UnmarshallUint64(buf[2621712:2687248][ii*8 : (ii+1)*8])
+	}
+
+	// Offset (15) 'PreviousEpochParticipation'
+	if o15 = ssz.ReadOffset(buf[2687248:2687252]); o15 > size || o12 > o15 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (16) 'CurrentEpochParticipation'
+	if o16 = ssz.ReadOffset(buf[2687252:2687256]); o16 > size || o15 > o16 {
+		return ssz.ErrOffset
+	}
+
+	// Field (17) 'JustificationBits'
+	copy(b.JustificationBits[:], buf[2687256:2687257])
+
+	// Field (18) 'PreviousJustifiedCheckpoint'
+	if b.PreviousJustifiedCheckpoint == nil {
+		b.PreviousJustifiedCheckpoint = new(Checkpoint)
+	}
+	if err = b.PreviousJustifiedCheckpoint.UnmarshalSSZ(buf[2687257:2687297]); err != nil {
+		return err
+	}
+
+	// Field (19) 'CurrentJustifiedCheckpoint'
+	if b.CurrentJustifiedCheckpoint == nil {
+		b.CurrentJustifiedCheckpoint = new(Checkpoint)
+	}
+	if err = b.CurrentJustifiedCheckpoint.UnmarshalSSZ(buf[2687297:2687337]); err != nil {
+		return err
+	}
+
+	// Field (20) 'FinalizedCheckpoint'
+	if b.FinalizedCheckpoint == nil {
+		b.FinalizedCheckpoint = new(Checkpoint)
+	}
+	if err = b.FinalizedCheckpoint.UnmarshalSSZ(buf[2687337:2687377]); err != nil {
+		return err
+	}
+
+	// Offset (21) 'InactivityScores'
+	if o21 = ssz.ReadOffset(buf[2687377:2687381]); o21 > size || o16 > o21 {
+		return ssz.ErrOffset
+	}
+
+	// Field (22) 'CurrentSyncCommittee'
+	if b.CurrentSyncCommittee == nil {
+		b.CurrentSyncCommittee = new(SyncCommittee)
+	}
+	if err = b.CurrentSyncCommittee.UnmarshalSSZ(buf[2687381:2712005]); err != nil {
+		return err
+	}
+
+	// Field (23) 'NextSyncCommittee'
+	if b.NextSyncCommittee == nil {
+		b.NextSyncCommittee = new(SyncCommittee)
+	}
+	if err = b.NextSyncCommittee.UnmarshalSSZ(buf[2712005:2736629]); err != nil {
+		return err
+	}
+
+	// Offset (24) 'LatestExecutionPayloadHeader'
+	if o24 = ssz.ReadOffset(buf[2736629:2736633]); o24 > size || o21 > o24 {
+		return ssz.ErrOffset
+	}
+
+	// Field (25) 'NextWithdrawalIndex'
+	b.NextWithdrawalIndex = ssz.UnmarshallUint64(buf[2736633:2736641])
+
+	// Field (26) 'NextWithdrawalValidatorIndex'
+	b.NextWithdrawalValidatorIndex = ssz.UnmarshallUint64(buf[2736641:2736649])
+
+	// Offset (27) 'HistoricalSummaries'
+	if o27 = ssz.ReadOffset(buf[2736649:2736653]); o27 > size || o24 > o27 {
+		return ssz.ErrOffset
+	}
+
+	// Field (7) 'HistoricalRoots'
+	{
+		buf = tail[o7:o9]
+		num, err := ssz.DivideInt2(len(buf), 32, 16777216)
+		if err != nil {
+			return err
+		}
+		b.HistoricalRoots = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(b.HistoricalRoots[ii]) == 0 {
+				b.HistoricalRoots[ii] = make([]byte, 0, len(buf[ii*32:(ii+1)*32]))
+			}
+			b.HistoricalRoots[ii] = append(b.HistoricalRoots[ii], buf[ii*32:(ii+1)*32]...)
+		}
+	}
+
+	// Field (9) 'Eth1DataVotes'
+	{
+		buf = tail[o9:o11]
+		num, err := ssz.DivideInt2(len(buf), 72, 2048)
+		if err != nil {
+			return err
+		}
+		b.Eth1DataVotes = make([]*Eth1Data, num)
+		for ii := 0; ii < num; ii++ {
+			if b.Eth1DataVotes[ii] == nil {
+				b.Eth1DataVotes[ii] = new(Eth1Data)
+			}
+			if err = b.Eth1DataVotes[ii].UnmarshalSSZ(buf[ii*72 : (ii+1)*72]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (11) 'Validators'
+	{
+		buf = tail[o11:o12]
+		num, err := ssz.DivideInt2(len(buf), 121, 1099511627776)
+		if err != nil {
+			return err
+		}
+		b.Validators = make([]*Validator, num)
+		for ii := 0; ii < num; ii++ {
+			if b.Validators[ii] == nil {
+				b.Validators[ii] = new(Validator)
+			}
+			if err = b.Validators[ii].UnmarshalSSZ(buf[ii*121 : (ii+1)*121]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (12) 'Balances'
+	{
+		buf = tail[o12:o15]
+		num, err := ssz.DivideInt2(len(buf), 8, 1099511627776)
+		if err != nil {
+			return err
+		}
+		b.Balances = ssz.ExtendUint64(b.Balances, num)
+		for ii := 0; ii < num; ii++ {
+			b.Balances[ii] = ssz.UnmarshallUint64(buf[ii*8 : (ii+1)*8])
+		}
+	}
+
+	// Field (15) 'PreviousEpochParticipation'
+	{
+		buf = tail[o15:o16]
+		if len(buf) > 1099511627776 {
+			return ssz.ErrBytesLength
+		}
+		if cap(b.PreviousEpochParticipation) == 0 {
+			b.PreviousEpochParticipation = make([]byte, 0, len(buf))
+		}
+		b.PreviousEpochParticipation = append(b.PreviousEpochParticipation, buf...)
+	}
+
+	// Field (16) 'CurrentEpochParticipation'
+	{
+		buf = tail[o16:o21]
+		if len(buf) > 1099511627776 {
+			return ssz.ErrBytesLength
+		}
+		if cap(b.CurrentEpochParticipation) == 0 {
+			b.CurrentEpochParticipation = make([]byte, 0, len(buf))
+		}
+		b.CurrentEpochParticipation = append(b.CurrentEpochParticipation, buf...)
+	}
+
+	// Field (21) 'InactivityScores'
+	{
+		buf = tail[o21:o24]
+		num, err := ssz.DivideInt2(len(buf), 8, 1099511627776)
+		if err != nil {
+			return err
+		}
+		b.InactivityScores = ssz.ExtendUint64(b.InactivityScores, num)
+		for ii := 0; ii < num; ii++ {
+			b.InactivityScores[ii] = ssz.UnmarshallUint64(buf[ii*8 : (ii+1)*8])
+		}
+	}
+
+	// Field (24) 'LatestExecutionPayloadHeader'
+	{
+		buf = tail[o24:o27]
+		if b.LatestExecutionPayloadHeader == nil {
+			b.LatestExecutionPayloadHeader = new(ExecutionPayloadHeaderCapella)
+		}
+		if err = b.LatestExecutionPayloadHeader.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+
+	// Field (27) 'HistoricalSummaries'
+	{
+		buf = tail[o27:]
+		num, err := ssz.DivideInt2(len(buf), 64, 16777216)
+		if err != nil {
+			return err
+		}
+		b.HistoricalSummaries = make([]*HistoricalSummary, num)
+		for ii := 0; ii < num; ii++ {
+			if b.HistoricalSummaries[ii] == nil {
+				b.HistoricalSummaries[ii] = new(HistoricalSummary)
+			}
+			if err = b.HistoricalSummaries[ii].UnmarshalSSZ(buf[ii*64 : (ii+1)*64]); err != nil {
+				return err
+			}
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the BeaconStateCapella object
+func (b *BeaconStateCapella) SizeSSZ() (size int) {
+	size = 2736653
+
+	// Field (7) 'HistoricalRoots'
+	size += len(b.HistoricalRoots) * 32
+
+	// Field (9) 'Eth1DataVotes'
+	size += len(b.Eth1DataVotes) * 72
+
+	// Field (11) 'Validators'
+	size += len(b.Validators) * 121
+
+	// Field (12) 'Balances'
+	size += len(b.Balances) * 8
+
+	// Field (15) 'PreviousEpochParticipation'
+	size += len(b.PreviousEpochParticipation)
+
+	// Field (16) 'CurrentEpochParticipation'
+	size += len(b.CurrentEpochParticipation)
+
+	// Field (21) 'InactivityScores'
+	size += len(b.InactivityScores) * 8
+
+	// Field (24) 'LatestExecutionPayloadHeader'
+	if b.LatestExecutionPayloadHeader == nil {
+		b.LatestExecutionPayloadHeader = new(ExecutionPayloadHeaderCapella)
+	}
+	size += b.LatestExecutionPayloadHeader.SizeSSZ()
+
+	// Field (27) 'HistoricalSummaries'
+	size += len(b.HistoricalSummaries) * 64
+
+	return
+}
+
+// HashTreeRoot ssz hashes the BeaconStateCapella object
+func (b *BeaconStateCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(b)
+}
+
+// HashTreeRootWith ssz hashes the BeaconStateCapella object with a hasher
+func (b *BeaconStateCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'GenesisTime'
+	hh.PutUint64(b.GenesisTime)
+
+	// Field (1) 'GenesisValidatorsRoot'
+	hh.PutBytes(b.GenesisValidatorsRoot[:])
+
+	// Field (2) 'Slot'
+	hh.PutUint64(b.Slot)
+
+	// Field (3) 'Fork'
+	if b.Fork == nil {
+		b.Fork = new(Fork)
+	}
+	if err = b.Fork.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (4) 'LatestBlockHeader'
+	if b.LatestBlockHeader == nil {
+		b.LatestBlockHeader = new(BeaconBlockHeader)
+	}
+	if err = b.LatestBlockHeader.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (5) 'BlockRoots'
+	{
+		subIndx := hh.Index()
+		for _, i := range b.BlockRoots {
+			hh.Append(i[:])
+		}
+		hh.Merkleize(subIndx)
+	}
+
+	// Field (6) 'StateRoots'
+	{
+		subIndx := hh.Index()
+		for _, i := range b.StateRoots {
+			hh.Append(i[:])
+		}
+		hh.Merkleize(subIndx)
+	}
+
+	// Field (7) 'HistoricalRoots'
+	{
+		if size := len(b.HistoricalRoots); size > 16777216 {
+			err = ssz.ErrListTooBigFn("BeaconStateCapella.HistoricalRoots", size, 16777216)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range b.HistoricalRoots {
+			if len(i) != 32 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.Append(i)
+		}
+		numItems := uint64(len(b.HistoricalRoots))
+		hh.MerkleizeWithMixin(subIndx, numItems, 16777216)
+	}
+
+	// Field (8) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if err = b.Eth1Data.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (9) 'Eth1DataVotes'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.Eth1DataVotes))
+		if num > 2048 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.Eth1DataVotes {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 2048)
+	}
+
+	// Field (10) 'Eth1DepositIndex'
+	hh.PutUint64(b.Eth1DepositIndex)
+
+	// Field (11) 'Validators'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.Validators))
+		if num > 1099511627776 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.Validators {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 1099511627776)
+	}
+
+	// Field (12) 'Balances'
+	{
+		if size := len(b.Balances); size > 1099511627776 {
+			err = ssz.ErrListTooBigFn("BeaconStateCapella.Balances", size, 1099511627776)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range b.Balances {
+			hh.AppendUint64(i)
+		}
+		hh.FillUpTo32()
+		numItems := uint64(len(b.Balances))
+		hh.MerkleizeWithMixin(subIndx, numItems, ssz.CalculateLimit(1099511627776, numItems, 8))
+	}
+
+	// Field (13) 'RandaoMixes'
+	{
+		subIndx := hh.Index()
+		for _, i := range b.RandaoMixes {
+			hh.Append(i[:])
+		}
+		hh.Merkleize(subIndx)
+	}
+
+	// Field (14) 'Slashings'
+	{
+		if size := len(b.Slashings); size != 8192 {
+			err = ssz.ErrVectorLengthFn("BeaconStateCapella.Slashings", size, 8192)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range b.Slashings {
+			hh.AppendUint64(i)
+		}
+		hh.Merkleize(subIndx)
+	}
+
+	// Field (15) 'PreviousEpochParticipation'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(b.PreviousEpochParticipation))
+		if byteLen > 1099511627776 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.Append(b.PreviousEpochParticipation)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (1099511627776+31)/32)
+	}
+
+	// Field (16) 'CurrentEpochParticipation'
+	{
+		elemIndx := hh.Index()
+		byteLen := uint64(len(b.CurrentEpochParticipation))
+		if byteLen > 1099511627776 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		hh.Append(b.CurrentEpochParticipation)
+		hh.MerkleizeWithMixin(elemIndx, byteLen, (1099511627776+31)/32)
+	}
+
+	// Field (17) 'JustificationBits'
+	hh.PutBytes(b.JustificationBits[:])
+
+	// Field (18) 'PreviousJustifiedCheckpoint'
+	if b.PreviousJustifiedCheckpoint == nil {
+		b.PreviousJustifiedCheckpoint = new(Checkpoint)
+	}
+	if err = b.PreviousJustifiedCheckpoint.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (19) 'CurrentJustifiedCheckpoint'
+	if b.CurrentJustifiedCheckpoint == nil {
+		b.CurrentJustifiedCheckpoint = new(Checkpoint)
+	}
+	if err = b.CurrentJustifiedCheckpoint.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (20) 'FinalizedCheckpoint'
+	if b.FinalizedCheckpoint == nil {
+		b.FinalizedCheckpoint = new(Checkpoint)
+	}
+	if err = b.FinalizedCheckpoint.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (21) 'InactivityScores'
+	{
+		if size := len(b.InactivityScores); size > 1099511627776 {
+			err = ssz.ErrListTooBigFn("BeaconStateCapella.InactivityScores", size, 1099511627776)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range b.InactivityScores {
+			hh.AppendUint64(i)
+		}
+		hh.FillUpTo32()
+		numItems := uint64(len(b.InactivityScores))
+		hh.MerkleizeWithMixin(subIndx, numItems, ssz.CalculateLimit(1099511627776, numItems, 8))
+	}
+
+	// Field (22) 'CurrentSyncCommittee'
+	if b.CurrentSyncCommittee == nil {
+		b.CurrentSyncCommittee = new(SyncCommittee)
+	}
+	if err = b.CurrentSyncCommittee.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (23) 'NextSyncCommittee'
+	if b.NextSyncCommittee == nil {
+		b.NextSyncCommittee = new(SyncCommittee)
+	}
+	if err = b.NextSyncCommittee.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (24) 'LatestExecutionPayloadHeader'
+	if err = b.LatestExecutionPayloadHeader.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (25) 'NextWithdrawalIndex'
+	hh.PutUint64(b.NextWithdrawalIndex)
+
+	// Field (26) 'NextWithdrawalValidatorIndex'
+	hh.PutUint64(b.NextWithdrawalValidatorIndex)
+
+	// Field (27) 'HistoricalSummaries'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.HistoricalSummaries))
+		if num > 16777216 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.HistoricalSummaries {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16777216)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the BeaconStateCapella object
+func (b *BeaconStateCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(b)
+}
+
+// MarshalSSZ ssz marshals the SignedBeaconBlockCapella object
+func (s *SignedBeaconBlockCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(s)
+}
+
+// MarshalSSZTo ssz marshals the SignedBeaconBlockCapella object to a target array
+func (s *SignedBeaconBlockCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(100)
+
+	// Offset (0) 'Block'
+	dst = ssz.WriteOffset(dst, offset)
+	if s.Block == nil {
+		s.Block = new(BeaconBlockCapella)
+	}
+	offset += s.Block.SizeSSZ()
+
+	// Field (1) 'Signature'
+	if size := len(s.Signature); size != 96 {
+		err = ssz.ErrBytesLengthFn("SignedBeaconBlockCapella.Signature", size, 96)
+		return
+	}
+	dst = append(dst, s.Signature...)
+
+	// Field (0) 'Block'
+	if dst, err = s.Block.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the SignedBeaconBlockCapella object
+func (s *SignedBeaconBlockCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 100 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o0 uint64
+
+	// Offset (0) 'Block'
+	if o0 = ssz.ReadOffset(buf[0:4]); o0 > size {
+		return ssz.ErrOffset
+	}
+
+	if o0 < 100 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (1) 'Signature'
+	if cap(s.Signature) == 0 {
+		s.Signature = make([]byte, 0, len(buf[4:100]))
+	}
+	s.Signature = append(s.Signature, buf[4:100]...)
+
+	// Field (0) 'Block'
+	{
+		buf = tail[o0:]
+		if s.Block == nil {
+			s.Block = new(BeaconBlockCapella)
+		}
+		if err = s.Block.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the SignedBeaconBlockCapella object
+func (s *SignedBeaconBlockCapella) SizeSSZ() (size int) {
+	size = 100
+
+	// Field (0) 'Block'
+	if s.Block == nil {
+		s.Block = new(BeaconBlockCapella)
+	}
+	size += s.Block.SizeSSZ()
+
+	return
+}
+
+// HashTreeRoot ssz hashes the SignedBeaconBlockCapella object
+func (s *SignedBeaconBlockCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(s)
+}
+
+// HashTreeRootWith ssz hashes the SignedBeaconBlockCapella object with a hasher
+func (s *SignedBeaconBlockCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'Block'
+	if err = s.Block.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (1) 'Signature'
+	if size := len(s.Signature); size != 96 {
+		err = ssz.ErrBytesLengthFn("SignedBeaconBlockCapella.Signature", size, 96)
+		return
+	}
+	hh.PutBytes(s.Signature)
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the SignedBeaconBlockCapella object
+func (s *SignedBeaconBlockCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(s)
+}
+
+// MarshalSSZ ssz marshals the BeaconBlockCapella object
+func (b *BeaconBlockCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(b)
+}
+
+// MarshalSSZTo ssz marshals the BeaconBlockCapella object to a target array
+func (b *BeaconBlockCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(84)
+
+	// Field (0) 'Slot'
+	dst = ssz.MarshalUint64(dst, b.Slot)
+
+	// Field (1) 'ProposerIndex'
+	dst = ssz.MarshalUint64(dst, b.ProposerIndex)
+
+	// Field (2) 'ParentRoot'
+	dst = append(dst, b.ParentRoot[:]...)
+
+	// Field (3) 'StateRoot'
+	dst = append(dst, b.StateRoot[:]...)
+
+	// Offset (4) 'Body'
+	dst = ssz.WriteOffset(dst, offset)
+	if b.Body == nil {
+		b.Body = new(BeaconBlockBodyCapella)
+	}
+	offset += b.Body.SizeSSZ()
+
+	// Field (4) 'Body'
+	if dst, err = b.Body.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the BeaconBlockCapella object
+func (b *BeaconBlockCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 84 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o4 uint64
+
+	// Field (0) 'Slot'
+	b.Slot = ssz.UnmarshallUint64(buf[0:8])
+
+	// Field (1) 'ProposerIndex'
+	b.ProposerIndex = ssz.UnmarshallUint64(buf[8:16])
+
+	// Field (2) 'ParentRoot'
+	copy(b.ParentRoot[:], buf[16:48])
+
+	// Field (3) 'StateRoot'
+	copy(b.StateRoot[:], buf[48:80])
+
+	// Offset (4) 'Body'
+	if o4 = ssz.ReadOffset(buf[80:84]); o4 > size {
+		return ssz.ErrOffset
+	}
+
+	if o4 < 84 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Field (4) 'Body'
+	{
+		buf = tail[o4:]
+		if b.Body == nil {
+			b.Body = new(BeaconBlockBodyCapella)
+		}
+		if err = b.Body.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the BeaconBlockCapella object
+func (b *BeaconBlockCapella) SizeSSZ() (size int) {
+	size = 84
+
+	// Field (4) 'Body'
+	if b.Body == nil {
+		b.Body = new(BeaconBlockBodyCapella)
+	}
+	size += b.Body.SizeSSZ()
+
+	return
+}
+
+// HashTreeRoot ssz hashes the BeaconBlockCapella object
+func (b *BeaconBlockCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(b)
+}
+
+// HashTreeRootWith ssz hashes the BeaconBlockCapella object with a hasher
+func (b *BeaconBlockCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'Slot'
+	hh.PutUint64(b.Slot)
+
+	// Field (1) 'ProposerIndex'
+	hh.PutUint64(b.ProposerIndex)
+
+	// Field (2) 'ParentRoot'
+	hh.PutBytes(b.ParentRoot[:])
+
+	// Field (3) 'StateRoot'
+	hh.PutBytes(b.StateRoot[:])
+
+	// Field (4) 'Body'
+	if err = b.Body.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the BeaconBlockCapella object
+func (b *BeaconBlockCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(b)
+}
+
+// MarshalSSZ ssz marshals the BeaconBlockBodyCapella object
+func (b *BeaconBlockBodyCapella) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(b)
+}
+
+// MarshalSSZTo ssz marshals the BeaconBlockBodyCapella object to a target array
+func (b *BeaconBlockBodyCapella) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(388)
+
+	// Field (0) 'RandaoReveal'
+	if size := len(b.RandaoReveal); size != 96 {
+		err = ssz.ErrBytesLengthFn("BeaconBlockBodyCapella.RandaoReveal", size, 96)
+		return
+	}
+	dst = append(dst, b.RandaoReveal...)
+
+	// Field (1) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if dst, err = b.Eth1Data.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (2) 'Graffiti'
+	dst = append(dst, b.Graffiti[:]...)
+
+	// Offset (3) 'ProposerSlashings'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.ProposerSlashings) * 416
+
+	// Offset (4) 'AttesterSlashings'
+	dst = ssz.WriteOffset(dst, offset)
+	for ii := 0; ii < len(b.AttesterSlashings); ii++ {
+		offset += 4
+		offset += b.AttesterSlashings[ii].SizeSSZ()
+	}
+
+	// Offset (5) 'Attestations'
+	dst = ssz.WriteOffset(dst, offset)
+	for ii := 0; ii < len(b.Attestations); ii++ {
+		offset += 4
+		offset += b.Attestations[ii].SizeSSZ()
+	}
+
+	// Offset (6) 'Deposits'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.Deposits) * 1240
+
+	// Offset (7) 'VoluntaryExits'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.VoluntaryExits) * 112
+
+	// Field (8) 'SyncAggregate'
+	if b.SyncAggregate == nil {
+		b.SyncAggregate = new(SyncAggregate)
+	}
+	if dst, err = b.SyncAggregate.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Offset (9) 'ExecutionPayload'
+	dst = ssz.WriteOffset(dst, offset)
+	if b.ExecutionPayload == nil {
+		b.ExecutionPayload = new(ExecutionPayloadCapella)
+	}
+	offset += b.ExecutionPayload.SizeSSZ()
+
+	// Offset (10) 'BlsToExecutionChanges'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(b.BlsToExecutionChanges) * 172
+
+	// Field (3) 'ProposerSlashings'
+	if size := len(b.ProposerSlashings); size > 16 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.ProposerSlashings", size, 16)
+		return
+	}
+	for ii := 0; ii < len(b.ProposerSlashings); ii++ {
+		if dst, err = b.ProposerSlashings[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (4) 'AttesterSlashings'
+	if size := len(b.AttesterSlashings); size > 2 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.AttesterSlashings", size, 2)
+		return
+	}
+	{
+		offset = 4 * len(b.AttesterSlashings)
+		for ii := 0; ii < len(b.AttesterSlashings); ii++ {
+			dst = ssz.WriteOffset(dst, offset)
+			offset += b.AttesterSlashings[ii].SizeSSZ()
+		}
+	}
+	for ii := 0; ii < len(b.AttesterSlashings); ii++ {
+		if dst, err = b.AttesterSlashings[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (5) 'Attestations'
+	if size := len(b.Attestations); size > 128 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.Attestations", size, 128)
+		return
+	}
+	{
+		offset = 4 * len(b.Attestations)
+		for ii := 0; ii < len(b.Attestations); ii++ {
+			dst = ssz.WriteOffset(dst, offset)
+			offset += b.Attestations[ii].SizeSSZ()
+		}
+	}
+	for ii := 0; ii < len(b.Attestations); ii++ {
+		if dst, err = b.Attestations[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (6) 'Deposits'
+	if size := len(b.Deposits); size > 16 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.Deposits", size, 16)
+		return
+	}
+	for ii := 0; ii < len(b.Deposits); ii++ {
+		if dst, err = b.Deposits[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (7) 'VoluntaryExits'
+	if size := len(b.VoluntaryExits); size > 16 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.VoluntaryExits", size, 16)
+		return
+	}
+	for ii := 0; ii < len(b.VoluntaryExits); ii++ {
+		if dst, err = b.VoluntaryExits[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	// Field (9) 'ExecutionPayload'
+	if dst, err = b.ExecutionPayload.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (10) 'BlsToExecutionChanges'
+	if size := len(b.BlsToExecutionChanges); size > 16 {
+		err = ssz.ErrListTooBigFn("BeaconBlockBodyCapella.BlsToExecutionChanges", size, 16)
+		return
+	}
+	for ii := 0; ii < len(b.BlsToExecutionChanges); ii++ {
+		if dst, err = b.BlsToExecutionChanges[ii].MarshalSSZTo(dst); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the BeaconBlockBodyCapella object
+func (b *BeaconBlockBodyCapella) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 388 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o3, o4, o5, o6, o7, o9, o10 uint64
+
+	// Field (0) 'RandaoReveal'
+	if cap(b.RandaoReveal) == 0 {
+		b.RandaoReveal = make([]byte, 0, len(buf[0:96]))
+	}
+	b.RandaoReveal = append(b.RandaoReveal, buf[0:96]...)
+
+	// Field (1) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if err = b.Eth1Data.UnmarshalSSZ(buf[96:168]); err != nil {
+		return err
+	}
+
+	// Field (2) 'Graffiti'
+	copy(b.Graffiti[:], buf[168:200])
+
+	// Offset (3) 'ProposerSlashings'
+	if o3 = ssz.ReadOffset(buf[200:204]); o3 > size {
+		return ssz.ErrOffset
+	}
+
+	if o3 < 388 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Offset (4) 'AttesterSlashings'
+	if o4 = ssz.ReadOffset(buf[204:208]); o4 > size || o3 > o4 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (5) 'Attestations'
+	if o5 = ssz.ReadOffset(buf[208:212]); o5 > size || o4 > o5 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (6) 'Deposits'
+	if o6 = ssz.ReadOffset(buf[212:216]); o6 > size || o5 > o6 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (7) 'VoluntaryExits'
+	if o7 = ssz.ReadOffset(buf[216:220]); o7 > size || o6 > o7 {
+		return ssz.ErrOffset
+	}
+
+	// Field (8) 'SyncAggregate'
+	if b.SyncAggregate == nil {
+		b.SyncAggregate = new(SyncAggregate)
+	}
+	if err = b.SyncAggregate.UnmarshalSSZ(buf[220:380]); err != nil {
+		return err
+	}
+
+	// Offset (9) 'ExecutionPayload'
+	if o9 = ssz.ReadOffset(buf[380:384]); o9 > size || o7 > o9 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (10) 'BlsToExecutionChanges'
+	if o10 = ssz.ReadOffset(buf[384:388]); o10 > size || o9 > o10 {
+		return ssz.ErrOffset
+	}
+
+	// Field (3) 'ProposerSlashings'
+	{
+		buf = tail[o3:o4]
+		num, err := ssz.DivideInt2(len(buf), 416, 16)
+		if err != nil {
+			return err
+		}
+		b.ProposerSlashings = make([]*ProposerSlashing, num)
+		for ii := 0; ii < num; ii++ {
+			if b.ProposerSlashings[ii] == nil {
+				b.ProposerSlashings[ii] = new(ProposerSlashing)
+			}
+			if err = b.ProposerSlashings[ii].UnmarshalSSZ(buf[ii*416 : (ii+1)*416]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (4) 'AttesterSlashings'
+	{
+		buf = tail[o4:o5]
+		num, err := ssz.DecodeDynamicLength(buf, 2)
+		if err != nil {
+			return err
+		}
+		b.AttesterSlashings = make([]*AttesterSlashing, num)
+		err = ssz.UnmarshalDynamic(buf, num, func(indx int, buf []byte) (err error) {
+			if b.AttesterSlashings[indx] == nil {
+				b.AttesterSlashings[indx] = new(AttesterSlashing)
+			}
+			if err = b.AttesterSlashings[indx].UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Field (5) 'Attestations'
+	{
+		buf = tail[o5:o6]
+		num, err := ssz.DecodeDynamicLength(buf, 128)
+		if err != nil {
+			return err
+		}
+		b.Attestations = make([]*Attestation, num)
+		err = ssz.UnmarshalDynamic(buf, num, func(indx int, buf []byte) (err error) {
+			if b.Attestations[indx] == nil {
+				b.Attestations[indx] = new(Attestation)
+			}
+			if err = b.Attestations[indx].UnmarshalSSZ(buf); err != nil {
+				return err
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Field (6) 'Deposits'
+	{
+		buf = tail[o6:o7]
+		num, err := ssz.DivideInt2(len(buf), 1240, 16)
+		if err != nil {
+			return err
+		}
+		b.Deposits = make([]*Deposit, num)
+		for ii := 0; ii < num; ii++ {
+			if b.Deposits[ii] == nil {
+				b.Deposits[ii] = new(Deposit)
+			}
+			if err = b.Deposits[ii].UnmarshalSSZ(buf[ii*1240 : (ii+1)*1240]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (7) 'VoluntaryExits'
+	{
+		buf = tail[o7:o9]
+		num, err := ssz.DivideInt2(len(buf), 112, 16)
+		if err != nil {
+			return err
+		}
+		b.VoluntaryExits = make([]*SignedVoluntaryExit, num)
+		for ii := 0; ii < num; ii++ {
+			if b.VoluntaryExits[ii] == nil {
+				b.VoluntaryExits[ii] = new(SignedVoluntaryExit)
+			}
+			if err = b.VoluntaryExits[ii].UnmarshalSSZ(buf[ii*112 : (ii+1)*112]); err != nil {
+				return err
+			}
+		}
+	}
+
+	// Field (9) 'ExecutionPayload'
+	{
+		buf = tail[o9:o10]
+		if b.ExecutionPayload == nil {
+			b.ExecutionPayload = new(ExecutionPayloadCapella)
+		}
+		if err = b.ExecutionPayload.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+
+	// Field (10) 'BlsToExecutionChanges'
+	{
+		buf = tail[o10:]
+		num, err := ssz.DivideInt2(len(buf), 172, 16)
+		if err != nil {
+			return err
+		}
+		b.BlsToExecutionChanges = make([]*SignedBLSToExecutionChange, num)
+		for ii := 0; ii < num; ii++ {
+			if b.BlsToExecutionChanges[ii] == nil {
+				b.BlsToExecutionChanges[ii] = new(SignedBLSToExecutionChange)
+			}
+			if err = b.BlsToExecutionChanges[ii].UnmarshalSSZ(buf[ii*172 : (ii+1)*172]); err != nil {
+				return err
+			}
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the BeaconBlockBodyCapella object
+func (b *BeaconBlockBodyCapella) SizeSSZ() (size int) {
+	size = 388
+
+	// Field (3) 'ProposerSlashings'
+	size += len(b.ProposerSlashings) * 416
+
+	// Field (4) 'AttesterSlashings'
+	for ii := 0; ii < len(b.AttesterSlashings); ii++ {
+		size += 4
+		size += b.AttesterSlashings[ii].SizeSSZ()
+	}
+
+	// Field (5) 'Attestations'
+	for ii := 0; ii < len(b.Attestations); ii++ {
+		size += 4
+		size += b.Attestations[ii].SizeSSZ()
+	}
+
+	// Field (6) 'Deposits'
+	size += len(b.Deposits) * 1240
+
+	// Field (7) 'VoluntaryExits'
+	size += len(b.VoluntaryExits) * 112
+
+	// Field (9) 'ExecutionPayload'
+	if b.ExecutionPayload == nil {
+		b.ExecutionPayload = new(ExecutionPayloadCapella)
+	}
+	size += b.ExecutionPayload.SizeSSZ()
+
+	// Field (10) 'BlsToExecutionChanges'
+	size += len(b.BlsToExecutionChanges) * 172
+
+	return
+}
+
+// HashTreeRoot ssz hashes the BeaconBlockBodyCapella object
+func (b *BeaconBlockBodyCapella) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(b)
+}
+
+// HashTreeRootWith ssz hashes the BeaconBlockBodyCapella object with a hasher
+func (b *BeaconBlockBodyCapella) HashTreeRootWith(hh ssz.HashWalker) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'RandaoReveal'
+	if size := len(b.RandaoReveal); size != 96 {
+		err = ssz.ErrBytesLengthFn("BeaconBlockBodyCapella.RandaoReveal", size, 96)
+		return
+	}
+	hh.PutBytes(b.RandaoReveal)
+
+	// Field (1) 'Eth1Data'
+	if b.Eth1Data == nil {
+		b.Eth1Data = new(Eth1Data)
+	}
+	if err = b.Eth1Data.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (2) 'Graffiti'
+	hh.PutBytes(b.Graffiti[:])
+
+	// Field (3) 'ProposerSlashings'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.ProposerSlashings))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.ProposerSlashings {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	// Field (4) 'AttesterSlashings'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.AttesterSlashings))
+		if num > 2 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.AttesterSlashings {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 2)
+	}
+
+	// Field (5) 'Attestations'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.Attestations))
+		if num > 128 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.Attestations {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 128)
+	}
+
+	// Field (6) 'Deposits'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.Deposits))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.Deposits {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	// Field (7) 'VoluntaryExits'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.VoluntaryExits))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.VoluntaryExits {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	// Field (8) 'SyncAggregate'
+	if b.SyncAggregate == nil {
+		b.SyncAggregate = new(SyncAggregate)
+	}
+	if err = b.SyncAggregate.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (9) 'ExecutionPayload'
+	if err = b.ExecutionPayload.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (10) 'BlsToExecutionChanges'
+	{
+		subIndx := hh.Index()
+		num := uint64(len(b.BlsToExecutionChanges))
+		if num > 16 {
+			err = ssz.ErrIncorrectListSize
+			return
+		}
+		for _, elem := range b.BlsToExecutionChanges {
+			if err = elem.HashTreeRootWith(hh); err != nil {
+				return
+			}
+		}
+		hh.MerkleizeWithMixin(subIndx, num, 16)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
+// GetTree ssz hashes the BeaconBlockBodyCapella object
+func (b *BeaconBlockBodyCapella) GetTree() (*ssz.Node, error) {
+	return ssz.ProofTree(b)
+}
diff --git a/spectests/structs_test.go b/spectests/structs_test.go
index d8457a8..fa9636d 100644
--- a/spectests/structs_test.go
+++ b/spectests/structs_test.go
@@ -28,6 +28,7 @@ const (
 	phase0    fork = "phase0"
 	altair    fork = "altair"
 	bellatrix fork = "bellatrix"
+	capella   fork = "capella"
 )
 
 type testCallback func(fork fork) codec
@@ -45,12 +46,16 @@ var codecs = map[string]testCallback{
 			return new(BeaconStateAltair)
 		} else if fork == bellatrix {
 			return new(BeaconStateBellatrix)
+		} else if fork == capella {
+			return new(BeaconStateCapella)
 		}
 		return nil
 	},
 	"BeaconBlock": func(fork fork) codec {
 		if fork == phase0 {
 			return new(BeaconBlock)
+		} else if fork == capella {
+			return new(BeaconBlockCapella)
 		}
 		return nil
 	},
@@ -61,6 +66,8 @@ var codecs = map[string]testCallback{
 			return new(BeaconBlockBodyAltair)
 		} else if fork == bellatrix {
 			return new(BeaconBlockBodyBellatrix)
+		} else if fork == capella {
+			return new(BeaconBlockBodyCapella)
 		}
 		return nil
 	},
@@ -78,6 +85,8 @@ var codecs = map[string]testCallback{
 	"SignedBeaconBlock": func(fork fork) codec {
 		if fork == phase0 {
 			return new(SignedBeaconBlock)
+		} else if fork == capella {
+			return new(SignedBeaconBlockCapella)
 		}
 		return nil
 	},
@@ -94,8 +103,21 @@ var codecs = map[string]testCallback{
 		return new(SyncAggregate)
 	},
 	"ExecutionPayload": func(fork fork) codec {
+		if fork == capella {
+			return new(ExecutionPayloadCapella)
+		}
 		return new(ExecutionPayload)
 	},
+	"ExecutionPayloadHeader": func(fork fork) codec {
+		if fork == capella {
+			return new(ExecutionPayloadHeaderCapella)
+		}
+		return new(ExecutionPayloadHeader)
+	},
+	"BLSToExecutionChange":       func(f fork) codec { return new(BLSToExecutionChange) },
+	"HistoricalSummary":          func(f fork) codec { return new(HistoricalSummary) },
+	"SignedBLSToExecutionChange": func(f fork) codec { return new(SignedBLSToExecutionChange) },
+	"Withdrawal":                 func(f fork) codec { return new(Withdrawal) },
 }
 
 func testSpecFork(t *testing.T, fork fork) {
@@ -130,6 +152,10 @@ func TestSpec_Bellatrix(t *testing.T) {
 	testSpecFork(t, bellatrix)
 }
 
+func TestSpec_Capella(t *testing.T) {
+	testSpecFork(t, capella)
+}
+
 func checkSSZEncoding(t *testing.T, fork fork, fileName, structName string, base testCallback) {
 	obj := base(fork)
 	if obj == nil {
diff --git a/spectests/structs_utils.go b/spectests/structs_utils.go
new file mode 100644
index 0000000..d10cace
--- /dev/null
+++ b/spectests/structs_utils.go
@@ -0,0 +1,36 @@
+package spectests
+
+import (
+	"fmt"
+	"math/big"
+)
+
+func (u *Uint256) UnmarshalText(text []byte) error {
+	x := new(big.Int)
+	if err := x.UnmarshalText(text); err != nil {
+		return err
+	}
+	if x.BitLen() > 256 {
+		return fmt.Errorf("too big")
+	}
+
+	buf := reverse(x.Bytes())
+	copy(u[:], buf)
+	return nil
+}
+
+func (u Uint256) MarshalText() (text []byte, err error) {
+	buf := reverse(u[:])
+	x := new(big.Int).SetBytes(buf[:])
+	return []byte(x.String()), nil
+}
+
+func reverse(in []byte) (out []byte) {
+	out = make([]byte, len(in))
+	copy(out[:], in[:])
+
+	for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
+		out[i], out[j] = out[j], out[i]
+	}
+	return
+}
diff --git a/sszgen/testcases/case1_encoding.go b/sszgen/testcases/case1_encoding.go
index 3cef5a2..cfa1b12 100644
--- a/sszgen/testcases/case1_encoding.go
+++ b/sszgen/testcases/case1_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: 849887b610983adf4efa1abfd912b25aa4f0ffbde8211f1e3909136539b1c2d9
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case2_encoding.go b/sszgen/testcases/case2_encoding.go
index 20d9430..95c2430 100644
--- a/sszgen/testcases/case2_encoding.go
+++ b/sszgen/testcases/case2_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: 44566646e4c1498bce3271d6c03a9108bb4af48414b1d759c07e3572846863f1
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case3_encoding.go b/sszgen/testcases/case3_encoding.go
index d756dcc..d509925 100644
--- a/sszgen/testcases/case3_encoding.go
+++ b/sszgen/testcases/case3_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: 4ebf31c9db2d40eb24702116641d6e98d75ebeb401ec69e41b7f351b81e25aa2
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case4_encoding.go b/sszgen/testcases/case4_encoding.go
index 2df31d2..85885d9 100644
--- a/sszgen/testcases/case4_encoding.go
+++ b/sszgen/testcases/case4_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: b35462b93b5ec0e1c9d9c7f2da382a9fb37543169a41064ce4421ecac43f7f62
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case5_encoding.go b/sszgen/testcases/case5_encoding.go
index 0c278d6..c234184 100644
--- a/sszgen/testcases/case5_encoding.go
+++ b/sszgen/testcases/case5_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: b89ee134b519595b8276174178242203f6bfb9e0594654a23e1c35e5fb8b5369
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case6_encoding.go b/sszgen/testcases/case6_encoding.go
index d733b37..3600ae9 100644
--- a/sszgen/testcases/case6_encoding.go
+++ b/sszgen/testcases/case6_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: 2c62e4f3a52cd6b3a37d9953ebbc566ecb0f1f591f68f1f60aa6f5ca0f2bb4a6
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/case7_encoding.go b/sszgen/testcases/case7_encoding.go
index a8ff702..ac343f0 100644
--- a/sszgen/testcases/case7_encoding.go
+++ b/sszgen/testcases/case7_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: af56ac74ccaeb89b8d2d802f56cbfab0248f088a80a7879c0e2f0fb8ca88f22c
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package testcases
 
 import (
diff --git a/sszgen/testcases/other/case3_encoding.go b/sszgen/testcases/other/case3_encoding.go
index ca4df19..dc164f3 100644
--- a/sszgen/testcases/other/case3_encoding.go
+++ b/sszgen/testcases/other/case3_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: 6490f11f815acc14fad304d8132c076222645a9159aca1f7cca2c6e0caa56b00
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package other
 
 import (
diff --git a/tests/codetrie_encoding.go b/tests/codetrie_encoding.go
index 547c9d3..6d88f83 100644
--- a/tests/codetrie_encoding.go
+++ b/tests/codetrie_encoding.go
@@ -1,6 +1,6 @@
 // Code generated by fastssz. DO NOT EDIT.
 // Hash: df8ee20c084275038d70ba95d464efb07c8cdbd9bbc7ff4cf7d9f52ebad035db
-// Version: 0.1.3-dev
+// Version: 0.1.3
 package tests
 
 import (