블록 생성과 합의 경계

func (beacon *Beacon) Prepare(...) error {
    header.Difficulty = beaconDifficulty   // 0
    return nil
}

func (beacon *Beacon) Seal(...) error {
    // seal verification is done by the external consensus engine
    return nil
}

func (beacon *Beacon) Finalize(...) {
    for _, w := range body.Withdrawals {
        state.AddBalance(w.Address, amount)
    }
    // No block reward (consensus layer instead)
}

func Register(stack *node.Node, backend *eth.Ethereum) error {
    stack.RegisterAPIs([]rpc.API{{
        Namespace:     "engine",
        Service:       NewConsensusAPI(backend),
        Authenticated: true,
    }})
}

block := GetBlockByHash(update.HeadBlockHash)
if block == nil { BeaconSync(); return SYNCING }   // 모르는 블록
if 정본이 아니면 { SetCanonical(block) }            // head 지정, 필요시 reorg
SetFinalized(...); SetSafe(...)

if payloadAttributes != nil {              // 다음 블록 만들어
    args := BuildPayloadArgs{Parent: head, Timestamp, FeeRecipient,
                             Random, Withdrawals, BeaconRoot}
    id := args.Id()                        // 인자 해시 앞 8바이트
    payload := Miner().BuildPayload(args)
    localBlocks.put(id, payload)
    return valid(&id)                      // 응답에 PayloadID
}
return valid(nil)

// engine.ExecutableDataToBlock: newPayload 첫 줄
block, err := ExecutableDataToBlockNoHash(data, hashes, beaconRoot, requests)
if block.Hash() != data.BlockHash {
    return nil, fmt.Errorf("blockhash mismatch ...")
}

empty := generateWork(noTxs: true)   // 1) 빈 블록 먼저
payload := newPayload(empty, args.Id())

go func() {                          // 2) 계속 갱신
    for {
        select {
        case <-timer.C:              // 즉시 1회, 이후 2초마다
            r := generateWork(full)
            payload.update(r)        // 수수료 더 크면 교체
        case <-payload.stop:  return // getPayload가 가져감
        case <-endTimer.C:    return // 12초 지나면 포기
        }
    }
}()

// payload.update: 교체 조건
if payload.full == nil || r.fees.Cmp(payload.fullFees) > 0 {
    payload.full = r.block
    ...
}

pending := txpool.Pending(filter{MinTip, BaseFee})
        // 2주차의 pending 맵. queue는 안 옴
txs := newTransactionsByPriceAndNonce(pending)
        // 계정 안은 nonce 순, 계정 사이는 팁 순
commitTransactions(env, txs, interrupt)
        // 하나씩 꺼내 실행. 가스 다 쓰거나 interrupt면 끝

func (miner *Miner) applyTransaction(env, tx) {
    snap := env.state.Snapshot()
    receipt, err := core.ApplyTransaction(env.evm, env.gasPool,
                       env.state, env.header, tx)
    if err != nil { env.state.RevertToSnapshot(snap) }
    return receipt, err
}

func (beacon *Beacon) FinalizeAndAssemble(...) {
    beacon.Finalize(...)                      // 인출 잔액 반영
    header.Root = state.IntermediateRoot(true)
    return types.NewBlock(header, body, receipts)
}

// getPayload(id) → localBlocks.get(id) → Resolve()
func (payload *Payload) Resolve() {
    close(payload.stop)           // 빌더 고루틴 종료
    if payload.full != nil { return payload.full }
    return payload.empty
}

block := ExecutableDataToBlock(params)         // 해시 대조
if 이미 아는 블록 { return VALID }
if 부모 없음     { 보류; return SYNCING }

err := InsertBlockWithoutSetHead(block)
   // → Process(block)         tx 전부 재실행
   // → ValidateState(block)   IntermediateRoot vs header.Root
   // → writeBlockWithState    저장. head는 안 건드림

if err != nil { return INVALID }   // 무효 조상 목록에 기억
return VALID

func (c *SimulatedBeacon) sealBlock(...) {
    // ① 다음 블록 만들어
    fc := c.engineAPI.forkchoiceUpdated(state, &attrs)
    // ② 만든 거 내놔
    env := c.engineAPI.getPayload(*fc.PayloadID)
    // ③ 실행해서 검증해
    c.engineAPI.newPayload(env.ExecutionPayload, ...)
    // ④ 이걸 head로
    c.engineAPI.forkchoiceUpdated(state{head: payload.BlockHash}, nil)
}

func handleNewBlock(...) error {
    return errors.New("block broadcasts disallowed")
}