상태와 트라이

type StateAccount struct {
    Nonce    uint64
    Balance  *uint256.Int
    Root     common.Hash   // merkle root of the storage trie
    CodeHash []byte
}

// ProcessBlock (프리페처 끈 경로)
statedb, _ := state.New(parentRoot, bc.statedb)
p.Process(block, statedb, cfg)

// opSstore: 스택에서 꺼내 넘긴다
evm.StateDB.SetState(addr, loc, val)

// opSload: 물어보고 스택에 놓는다
val := evm.StateDB.GetState(addr, loc)

// EVM이 아는 상태의 전부
type StateDB interface {
    GetBalance(...)  AddBalance(...)
    GetNonce(...)    SetNonce(...)
    GetCode(...)     SetCode(...)
    GetState(...)
    SetState(...)
    AddRefund(...)   Snapshot()
    RevertToSnapshot(...)
    ...
}

type stateObject struct {
    data types.StateAccount   // 변경 반영된 계정 값

    // 읽어온 원본 캐시
    originStorage  Storage // accessed within the current block
    // 쓰기가 쌓이고 승격되는 두 칸
    dirtyStorage   Storage // modified within the current transaction
    pendingStorage Storage // modified within the current block
}

func (s *stateObject) getState(key) (common.Hash, common.Hash) {
    origin := s.GetCommittedState(key)   // 커밋된 값 먼저
    value, dirty := s.dirtyStorage[key]
    if dirty {
        return value, origin             // 이번 tx가 쓴 값이 답
    }
    return origin, origin                // 안 바꿨으면 원본이 곧 현재값
}

func (s *stateObject) GetCommittedState(key) common.Hash {
    if v, ok := s.pendingStorage[key]; ok { return v }   // 1. 이번 블록
    if v, ok := s.originStorage[key]; ok { return v }    // 2. 캐시
    value, err := s.db.reader.Storage(s.address, key)    // 3. 저장소
    s.originStorage[key] = value        // 4. 다음을 위해 남긴다
    return value
}

func (s *stateObject) SetState(key, value) common.Hash {
    prev, origin := s.getState(key)
    if prev == value { return prev }   // 같으면 아무것도 안 함
    s.db.journal.storageChange(s.address, key, prev, origin)
    s.setState(key, value, origin)     // dirtyStorage[key] = value
}

func (j *journal) revert(statedb *StateDB, snapshot int) {
    for i := len(j.entries) - 1; i >= snapshot; i-- {
        j.entries[i].revert(statedb)   // 예: setState(이전 값)
    }
}

// ApplyTransactionWithEVM 마지막: tx 하나마다 불린다
evm.StateDB.Finalise(true)

// Finalise, however, will not push any updates into the tries
// just yet. Only IntermediateRoot or Commit will do that.
func (s *StateDB) Finalise(deleteEmptyObjects bool) {

func (s *StateDB) IntermediateRoot(...) common.Hash {
    s.Finalise(...)                    // 1. dirty를 pending으로
    for addr, op := range s.mutations {
        workers.Go(func() error {
            obj.updateRoot()           // 2. 스토리지 트라이 → data.Root
        })
    }
    for addr := range s.mutations {
        s.updateStateObject(...)       // 3. 계정 트라이에 반영
    }
    return s.trie.Hash()               // 4. 상태 루트
}

// 2번 단계 확대
func (s *stateObject) updateRoot() {
    tr, _ := s.updateTrie()
    s.data.Root = tr.Hash()
}

// ValidateState 마지막
if root := statedb.IntermediateRoot(...); header.Root != root {
    return fmt.Errorf("invalid merkle root (remote: %x local: %x)",
                      header.Root, root, ...)
}

// writeBlockWithState → statedb.Commit → commit
    s.IntermediateRoot(...)             // 1. 루트 확정
    for addr := range s.mutations {
        workers.Go(func() error {
            update, set, _ := obj.commit()  // 2. 바뀐 노드 수집
            merge(set)                      // 3. 전역 집합으로
        })
    }
    newroot, set := s.trie.Commit(true)  // 4. 계정 트라이도 (병렬)
    // 5. 노드 꾸러미 → triedb, 디스크는 triedb가 맡는다