switch fork {
case "deneb", "electra":
	method = "engine_forkchoiceUpdatedV3"
case "capella":
	method = "engine_forkchoiceUpdatedV2"
default:
	method = "engine_forkchoiceUpdatedV1"
}

// forkchoiceUpdated는 포크초이스 업데이트 요청을 처리하는 내부 메서드입니다.

// update: 포크초이스 상태 (헤드, 완료, 안전 블록 해시)
// payloadAttributes: 페이로드 생성을 위한 속성들
// payloadVersion: 페이로드 버전
// payloadWitness: 위트니스 수집 여부
func (api *ConsensusAPI) forkchoiceUpdated(update engine.ForkchoiceStateV1, payloadAttributes *engine.PayloadAttributes, payloadVersion engine.PayloadVersion, payloadWitness bool) (engine.ForkChoiceResponse, error) {
	// 동시 접근 방지를 위한 락 획득
	api.forkchoiceLock.Lock()
	defer api.forkchoiceLock.Unlock()

	log.Trace("Engine API 요청 수신", "method", "ForkchoiceUpdated", "head", update.HeadBlockHash, "finalized", update.FinalizedBlockHash, "safe", update.SafeBlockHash)
	
	// 헤드 블록 해시가 빈 값인지 확인
	if update.HeadBlockHash == (common.Hash{}) {
		log.Warn("빈 해시로 포크초이스 업데이트 요청됨")
		return engine.STATUS_INVALID, nil // TODO(karalabe): 왜 누군가 이것을 보내는가?
	}
	
	// 비콘 클라이언트가 오프라인 상태가 되면 사용자에게 경고하기 위해 마지막 업데이트 시간을 저장
	api.lastForkchoiceLock.Lock()
	api.lastForkchoiceUpdate = time.Now()
	api.lastForkchoiceLock.Unlock()

	// 데이터베이스에서 해당 블록이 존재하는지 확인합니다.

	// 없다면 동기화를 트리거하거나 포크초이스 업데이트를 거부해야 합니다.

	block := api.eth.BlockChain().GetBlockByHash(update.HeadBlockHash)
	if block == nil {
		// 이 블록이 이전에 무효화되었다면, 여기서도 계속 거부합니다
		if res := api.checkInvalidAncestor(update.HeadBlockHash, update.HeadBlockHash); res != nil {
			return engine.ForkChoiceResponse{PayloadStatus: *res, PayloadID: nil}, nil
		}
		
		// 헤드 해시가 알려지지 않은 경우 (newPayload 요청에서 제공되지 않음)
		// 헤더를 해결할 수 없으므로 할 수 있는 일이 많지 않습니다.

		header := api.remoteBlocks.get(update.HeadBlockHash)
		if header == nil {
			log.Warn("알려지지 않은 헤드로 포크초이스 요청됨", "hash", update.HeadBlockHash)
			return engine.STATUS_SYNCING, nil
		}
		
		// 완료된 해시가 알려져 있다면, 다운로더가 처음부터 더 많은 데이터를 
		// 프리저로 이동시킬 수 있도록 지시할 수 있습니다.

		finalized := api.remoteBlocks.get(update.FinalizedBlockHash)

		// 과거 newPayload 요청을 통해 광고된 헤더입니다. 해당 헤더로 동기화를 시작합니다.

		context := []interface{}{"number", header.Number, "hash", header.Hash()}
		if update.FinalizedBlockHash != (common.Hash{}) {
			if finalized == nil {
				context = append(context, []interface{}{"finalized", "unknown"}...)
			} else {
				context = append(context, []interface{}{"finalized", finalized.Number}...)
			}
		}
		log.Info("새로운 헤드로 동기화 요청됨", context...)
		if err := api.eth.Downloader().BeaconSync(api.eth.SyncMode(), header, finalized); err != nil {
			return engine.STATUS_SYNCING, err
		}
		return engine.STATUS_SYNCING, nil
	}
	
	// 블록이 로컬에 알려져 있으므로, 비콘 클라이언트가 
	// 머지 이전으로 되돌리려 시도하지 않는지 건전성 검사를 합니다.

	if block.Difficulty().BitLen() > 0 && block.NumberU64() > 0 {
		ph := api.eth.BlockChain().GetHeader(block.ParentHash(), block.NumberU64()-1)
		if ph == nil {
			return engine.STATUS_INVALID, errors.New("난이도 확인을 위한 부모 블록 사용 불가")
		}
		// 부모가 이미 PoS이고 현재 블록이 PoW라면 오류
		if ph.Difficulty.Sign() == 0 && block.Difficulty().Sign() > 0 {
			log.Error("부모 블록이 이미 post-ttd 상태", "number", block.NumberU64(), "hash", update.HeadBlockHash, "diff", block.Difficulty(), "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)))
			return engine.ForkChoiceResponse{PayloadStatus: engine.INVALID_TERMINAL_BLOCK, PayloadID: nil}, nil
		}
	}
	
	// 유효한 응답을 생성하는 헬퍼 함수
	valid := func(id *engine.PayloadID) engine.ForkChoiceResponse {
		return engine.ForkChoiceResponse{
			PayloadStatus: engine.PayloadStatusV1{
				Status:          engine.VALID,
				LatestValidHash: &update.HeadBlockHash,
			},
			PayloadID: id,
		}
	}
	
	// 블록이 정규 체인에 없다면 헤드로 설정
	if rawdb.ReadCanonicalHash(api.eth.ChainDb(), block.NumberU64()) != update.HeadBlockHash {
		// 블록이 정규가 아니므로 헤드로 설정합니다.
		if latestValid, err := api.eth.BlockChain().SetCanonical(block); err != nil {
			return engine.ForkChoiceResponse{PayloadStatus: engine.PayloadStatusV1{Status: engine.INVALID, LatestValidHash: &latestValid}}, err
		}
	} else if api.eth.BlockChain().CurrentBlock().Hash() == update.HeadBlockHash {
		// 지정된 헤드가 로컬 헤드와 일치하는 경우, 아무것도 하지 않고 
		// 페이로드 생성을 계속합니다. 몇 개의 슬롯이 누락되고 
		// 슬롯에서 페이로드 생성이 요청되는 특별한 코너 케이스입니다.
	} else {
		// 헤드 블록이 이미 정규 체인에 있다면, 비콘 클라이언트가 
		// 아마도 재동기화 중일 것입니다. 업데이트를 무시합니다.
		log.Info("이전 헤드로의 비콘 업데이트 무시", "number", block.NumberU64(), "hash", update.HeadBlockHash, "age", common.PrettyAge(time.Unix(int64(block.Time()), 0)), "have", api.eth.BlockChain().CurrentBlock().Number)
		return valid(nil), nil
	}
	
	// 노드를 동기화된 상태로 설정
	api.eth.SetSynced()

	// 비콘 클라이언트가 완료된 블록도 광고했다면, 로컬 체인을 
	// 최종적이고 완전히 PoS 모드로 표시합니다.
	if update.FinalizedBlockHash != (common.Hash{}) {
		// 완료된 블록이 정규 트리에 없다면 문제가 있습니다
		finalBlock := api.eth.BlockChain().GetBlockByHash(update.FinalizedBlockHash)
		if finalBlock == nil {
			log.Warn("최종 블록이 데이터베이스에서 사용 불가", "hash", update.FinalizedBlockHash)
			return engine.STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("최종 블록이 데이터베이스에서 사용 불가"))
		} else if rawdb.ReadCanonicalHash(api.eth.ChainDb(), finalBlock.NumberU64()) != update.FinalizedBlockHash {
			log.Warn("최종 블록이 정규 체인에 없음", "number", finalBlock.NumberU64(), "hash", update.FinalizedBlockHash)
			return engine.STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("최종 블록이 정규 체인에 없음"))
		}
		// 완료된 블록 설정
		api.eth.BlockChain().SetFinalized(finalBlock.Header())
	}
	
	// 안전 블록 해시가 정규 트리에 있는지 확인, 없다면 문제가 있습니다
	if update.SafeBlockHash != (common.Hash{}) {
		safeBlock := api.eth.BlockChain().GetBlockByHash(update.SafeBlockHash)
		if safeBlock == nil {
			log.Warn("안전 블록이 데이터베이스에서 사용 불가")
			return engine.STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("안전 블록이 데이터베이스에서 사용 불가"))
		}
		if rawdb.ReadCanonicalHash(api.eth.ChainDb(), safeBlock.NumberU64()) != update.SafeBlockHash {
			log.Warn("안전 블록이 정규 체인에 없음")
			return engine.STATUS_INVALID, engine.InvalidForkChoiceState.With(errors.New("안전 블록이 정규 체인에 없음"))
		}
		// 안전 블록 설정
		api.eth.BlockChain().SetSafe(safeBlock.Header())
	}
	
	// 페이로드 생성이 요청되었다면, 비콘 클라이언트에 의해 잠재적으로 
	// 봉인될 새로운 블록을 생성합니다. 페이로드는 나중에 요청될 것이고,
	// 그 사이에 임의로 여러 번 교체할 수 있습니다.
	if payloadAttributes != nil {
		// 페이로드 빌드를 위한 인수 구성
		args := &miner.BuildPayloadArgs{
			Parent:       update.HeadBlockHash,
			Timestamp:    payloadAttributes.Timestamp,
			FeeRecipient: payloadAttributes.SuggestedFeeRecipient,
			Random:       payloadAttributes.Random,
			Withdrawals:  payloadAttributes.Withdrawals,
			BeaconRoot:   payloadAttributes.BeaconRoot,
			Version:      payloadVersion,
		}
		id := args.Id()
		
		// 이미 이 작업을 생성하느라 바쁘다면, 두 번째 프로세스를 
		// 시작할 필요가 없습니다.
		if api.localBlocks.has(id) {
			return valid(&id), nil
		}
		
		// 페이로드 빌드 시작
		payload, err := api.eth.Miner().BuildPayload(args, payloadWitness)
		if err != nil {
			log.Error("페이로드 빌드 실패", "err", err)
			return valid(nil), engine.InvalidPayloadAttributes.With(err)
		}
		// 로컬 블록 캐시에 페이로드 저장
		api.localBlocks.put(id, payload)
		return valid(&id), nil
	}
	return valid(nil), nil
}

// SetFinalized는 블록체인의 최종화된 블록 헤더를 설정합니다.
// header가 nil이 아닌 경우, 현재 최종화된 블록을 업데이트하고
// 데이터베이스에 최종화된 블록 해시를 저장하며 관련 메트릭을 업데이트합니다.
// header가 nil인 경우, 최종화된 블록을 제거하고 빈 해시와 0 값으로 초기화합니다.
func (bc *BlockChain) SetFinalized(header *types.Header) {
	bc.currentFinalBlock.Store(header)
	if header != nil {
		rawdb.WriteFinalizedBlockHash(bc.db, header.Hash())
		headFinalizedBlockGauge.Update(int64(header.Number.Uint64()))
	} else {
		rawdb.WriteFinalizedBlockHash(bc.db, common.Hash{})
		headFinalizedBlockGauge.Update(0)
	}
}

// SetSafe는 블록체인의 안전한 블록 헤더를 설정합니다.
// 안전블록으로 설정된 헤더는 체인의 재구성이 거의 불가능함을 의미합니다.
func (bc *BlockChain) SetSafe(header *types.Header) {
	bc.currentSafeBlock.Store(header)
	if header != nil {
		headSafeBlockGauge.Update(int64(header.Number.Uint64()))
	} else {
		headSafeBlockGauge.Update(0)
	}
}

// reorg는 두 개의 블록(구 체인과 신 체인)을 받아서 블록들을 재구성하고,
// 새로운 정규 체인의 일부가 되도록 블록들을 삽입하며, 누락될 수 있는 트랜잭션들을 수집하고
// 그것들에 대한 이벤트를 게시합니다.
//
// 주의: 새로운 헤드 블록은 여기서 처리되지 않으므로, 호출자가 외부에서 처리해야 합니다.
func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Header) error {
	var (
		newChain    []*types.Header // 새로운 체인에 추가될 헤더들
		oldChain    []*types.Header // 구 체인에서 제거될 헤더들
		commonBlock *types.Header   // 공통 조상 블록
	)
	
	// 더 긴 체인을 짧은 체인과 같은 길이로 맞춤
	// 먼저 두 체인을 같은 높이로 맞춰서 공통 조상을 찾기 쉽게 함
	if oldHead.Number.Uint64() > newHead.Number.Uint64() {
		// 구 체인이 더 길 때, 모든 트랜잭션과 로그를 삭제된 것으로 수집
		for ; oldHead != nil && oldHead.Number.Uint64() != newHead.Number.Uint64(); oldHead = bc.GetHeader(oldHead.ParentHash, oldHead.Number.Uint64()-1) {
			oldChain = append(oldChain, oldHead)
		}
	} else {
		// 새 체인이 더 길 때, 모든 블록을 후속 삽입을 위해 보관
		for ; newHead != nil && newHead.Number.Uint64() != oldHead.Number.Uint64(); newHead = bc.GetHeader(newHead.ParentHash, newHead.Number.Uint64()-1) {
			newChain = append(newChain, newHead)
		}
	}
	
	// 체인 유효성 검증 - 헤더가 존재하지 않으면 오류
	if oldHead == nil {
		return errInvalidOldChain
	}
	if newHead == nil {
		return errInvalidNewChain
	}
	
	// 양쪽 체인이 같은 높이에 있으므로, 공통 조상을 찾을 때까지 양쪽을 모두 역추적
	for {
		// 공통 조상을 찾았으면 루프 종료
		if oldHead.Hash() == newHead.Hash() {
			commonBlock = oldHead
			break
		}
		
		// 구 블록을 제거 대상에 추가하고 새 블록을 추가 대상에 보관
		oldChain = append(oldChain, oldHead)
		newChain = append(newChain, newHead)

		// 양쪽 체인 모두 한 단계씩 뒤로 이동
		oldHead = bc.GetHeader(oldHead.ParentHash, oldHead.Number.Uint64()-1)
		if oldHead == nil {
			return errInvalidOldChain
		}
		newHead = bc.GetHeader(newHead.ParentHash, newHead.Number.Uint64()-1)
		if newHead == nil {
			return errInvalidNewChain
		}
	}
	
	// 사용자가 큰 재구성을 인지할 수 있도록 로그 출력
	if len(oldChain) > 0 && len(newChain) > 0 {
		logFn := log.Info
		msg := "Chain reorg detected"
		// 63개 이상의 블록이 재구성되면 경고 레벨로 로그 출력
		if len(oldChain) > 63 {
			msg = "Large chain reorg detected"
			logFn = log.Warn
		}
		logFn(msg, "number", commonBlock.Number, "hash", commonBlock.Hash(),
			"drop", len(oldChain), "dropfrom", oldChain[0].Hash(), "add", len(newChain), "addfrom", newChain[0].Hash())
		
		// 재구성 관련 메트릭 업데이트
		blockReorgAddMeter.Mark(int64(len(newChain)))
		blockReorgDropMeter.Mark(int64(len(oldChain)))
		blockReorgMeter.Mark(1)
	} else if len(newChain) > 0 {
		// 특별한 경우: 현재 헤드가 새 헤드의 조상이지만 연속되지 않는 경우 (주로 머지 이후 단계에서 발생)
		log.Info("Extend chain", "add", len(newChain), "number", newChain[0].Number, "hash", newChain[0].Hash())
		blockReorgAddMeter.Mark(int64(len(newChain)))
	} else {
		// len(newChain) == 0 && len(oldChain) > 0
		// 정규 체인을 더 낮은 지점으로 되감기 (이는 일반적으로 발생하지 않아야 함)
		log.Error("Impossible reorg, please file an issue", "oldnum", oldHead.Number, "oldhash", oldHead.Hash(), "oldblocks", len(oldChain), "newnum", newHead.Number, "newhash", newHead.Hash(), "newblocks", len(newChain))
	}
	
	// 변경 전에 트랜잭션 룩업 락 획득
	// 이 단계는 txlookup이 Atomic하게 변경되어야 하고, 변경이 완료될 때까지 모든 후속 읽기가 차단되어야 하므로 필수임
	bc.txLookupLock.Lock()

	// 재구성 실행: 체인의 구 블록들을 제거하고 새 블록들을 추가 시작
	var (
		deletedTxs []common.Hash // 삭제된 트랜잭션 해시 목록
		rebirthTxs []common.Hash // 재생성된 트랜잭션 해시 목록

		deletedLogs []*types.Log // 삭제된 로그 목록
		rebirthLogs []*types.Log // 재생성된 로그 목록
	)
	
	// API에서 삭제된 로그 방출은 순방향 순서를 사용하는데, 이는 잘못된 것이지만
	// 레거시 이유로 유지됩니다.
	//
	// TODO(karalabe): 이것은 제거되어야 하지만, 방법을 모르겠으므로 일부 API를 더 이상 사용하지 않는 것으로 표시해야 할지도?
	{
		// 구 체인의 블록들을 역순으로 처리하여 삭제된 로그 수집
		for i := len(oldChain) - 1; i >= 0; i-- {
			block := bc.GetBlock(oldChain[i].Hash(), oldChain[i].Number.Uint64())
			if block == nil {
				return errInvalidOldChain // 데이터베이스 손상, 주로 이상한 패닉을 방지하기 위함
			}
			if logs := bc.collectLogs(block, true); len(logs) > 0 {
				deletedLogs = append(deletedLogs, logs...)
			}
			// 메모리 사용량 제한을 위해 512개씩 배치로 처리
			if len(deletedLogs) > 512 {
				bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
				deletedLogs = nil
			}
		}
		// 남은 삭제된 로그가 있으면 전송
		if len(deletedLogs) > 0 {
			bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
		}
	}
	
	// 구 블록들을 역순으로 실행 취소
	for i := 0; i < len(oldChain); i++ {
		// 삭제된 모든 트랜잭션 수집
		block := bc.GetBlock(oldChain[i].Hash(), oldChain[i].Number.Uint64())
		if block == nil {
			return errInvalidOldChain // 데이터베이스 손상, 주로 이상한 패닉을 방지하기 위함
		}
		for _, tx := range block.Transactions() {
			deletedTxs = append(deletedTxs, tx.Hash())
		}
		// 삭제된 로그를 수집하고 새로운 통합을 위해 방출
		if logs := bc.collectLogs(block, true); len(logs) > 0 {
			// 최신 것부터 먼저 되돌림을 방출하고, 그 다음 이전 것들
			slices.Reverse(logs)

			// TODO(karalabe): 역방향 방출 부분에 연결
		}
	}
	
	// 새 블록들을 순방향 순서로 적용
	for i := len(newChain) - 1; i >= 1; i-- {
		// 포함된 모든 트랜잭션 수집
		block := bc.GetBlock(newChain[i].Hash(), newChain[i].Number.Uint64())
		if block == nil {
			return errInvalidNewChain // 데이터베이스 손상, 주로 이상한 패닉을 방지하기 위함
		}
		for _, tx := range block.Transactions() {
			rebirthTxs = append(rebirthTxs, tx.Hash())
		}
		// 삽입된 로그를 수집하고 방출
		if logs := bc.collectLogs(block, false); len(logs) > 0 {
			rebirthLogs = append(rebirthLogs, logs...)
		}
		// 메모리 사용량 제한을 위해 512개씩 배치로 처리
		if len(rebirthLogs) > 512 {
			bc.logsFeed.Send(rebirthLogs)
			rebirthLogs = nil
		}
		// 헤드 블록 업데이트
		bc.writeHeadBlock(block)
	}
	// 남은 재생성된 로그가 있으면 전송
	if len(rebirthLogs) > 0 {
		bc.logsFeed.Send(rebirthLogs)
	}
	
	// 불필요한 인덱스를 즉시 삭제 (비정규 트랜잭션 인덱스, 헤드 위의 정규 체인 인덱스 포함)
	batch := bc.db.NewBatch()
	// 삭제된 트랜잭션에서 재생성된 트랜잭션을 제외한 것들의 룩업 엔트리 삭제
	for _, tx := range types.HashDifference(deletedTxs, rebirthTxs) {
		rawdb.DeleteTxLookupEntry(batch, tx)
	}
	
	// 새로운 정규 체인의 일부가 아닌 모든 해시 마커 삭제
	// reorg 함수는 새 체인 헤드를 처리하지 않으므로, 새 체인 헤드보다 크거나 같은 모든 해시 마커를 삭제해야 함
	number := commonBlock.Number
	if len(newChain) > 1 {
		number = newChain[1].Number
	}
	// 공통 블록 이후의 모든 정규 해시 삭제
	for i := number.Uint64() + 1; ; i++ {
		hash := rawdb.ReadCanonicalHash(bc.db, i)
		if hash == (common.Hash{}) {
			break // 더 이상 정규 해시가 없으면 중단
		}
		rawdb.DeleteCanonicalHash(batch, i)
	}
	
	// 배치 쓰기 실행
	if err := batch.Write(); err != nil {
		log.Crit("Failed to delete useless indexes", "err", err)
	}
	
	// 오래된 txlookup 캐시를 지우기 위해 tx lookup 캐시 리셋
	bc.txLookupCache.Purge()

	// 변경 후 트랜잭션 룩업 락 해제
	bc.txLookupLock.Unlock()

	return nil
}

// VerifyHeader는 헤더가 이더리움 합의 엔진의 합의 규칙에 부합하는지 확인합니다.
// 이 함수는 PoW/PoA에서 PoS로의 전환을 올바르게 처리하기 위한 검증 로직을 포함합니다.
func (beacon *Beacon) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header) error {
	// 라이브 머지 전환 중에는 합의 엔진이 터미널 총 난이도를 사용하여
	// PoW(PoA)가 PoS로 전환되는 시점을 감지했습니다. 하지만 총 난이도 값을
	// 유지하려면 제네시스부터 모든 블록을 적용하여 TD를 구축해야 합니다.
	// 동기화 중에 체인의 끝부분이 이미 가지치기된 경우에는 이것이 불가능해집니다.
	//
	// Merge 전 블록과 Merge 후 블록을 구분하는 데 사용할 수 있는 한 가지 휴리스틱은
	// 각각의 *난이도*가 >0인지 ==0인지 여부입니다. 물론 이것은 과거 체인이
	// 올바른 TTD에서 진정으로 전환되었음을 더 이상 증명할 수 없다는 것을 의미하지만,
	// 오래된 시점이 오래 전에 확정되었다고 간주한다면, 합의 클라이언트가
	// 매우 오래된 히스토리를 다시 쓰려는 시도는 없어야 합니다.
	//
	// 아마도 필요하지 않지만 이 검증을 더욱 엄격하게 만들기 위해 추가할 수 있는
	// 한 가지는 ==0이 >0으로 이어지는 것을 금지함으로써 체인이 >0에서 ==0 TD로
	// 단 한 번만 전환할 수 있도록 강제하는 것입니다.

	// 머지 후에서 머지 전으로 되돌리지 않는지 확인합니다.
	// 이는 블록체인의 일관성을 보장하기 위한 중요한 검증입니다.
	parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
	if parent == nil {
		return consensus.ErrUnknownAncestor
	}
	// 부모 블록이 PoS(난이도 0)이고 현재 헤더가 PoW(난이도 > 0)인 경우
	// 이는 유효하지 않은 전환이므로 에러를 반환합니다.
	if parent.Difficulty.Sign() == 0 && header.Difficulty.Sign() > 0 {
		return consensus.ErrInvalidTerminalBlock
	}
	// 난이도가 >0인 경우 머지 전 규칙으로 검증하고,
	// 난이도가 ==0인 경우 머지 후 규칙으로 검증합니다.
	if header.Difficulty.Sign() > 0 {
		// PoW/PoA 블록: 기존 eth1 엔진의 검증 로직 사용
		return beacon.ethone.VerifyHeader(chain, header)
	}
	// PoS 블록: 비콘 체인의 검증 로직 사용
	return beacon.verifyHeader(chain, header, parent)
}

func (api *ConsensusAPI) ForkchoiceUpdatedV3(update engine.ForkchoiceStateV1, params *engine.PayloadAttributes) (engine.ForkChoiceResponse, error) {
  ...

type PayloadAttributes struct {
	Timestamp             uint64              `json:"timestamp"             gencodec:"required"`
	Random                common.Hash         `json:"prevRandao"            gencodec:"required"`
	SuggestedFeeRecipient common.Address      `json:"suggestedFeeRecipient" gencodec:"required"`
	Withdrawals           []*types.Withdrawal `json:"withdrawals"`
	BeaconRoot            *common.Hash        `json:"parentBeaconBlockRoot"`
}