EVM 인터프리터

pendingPlainTxs, _ := miner.txpool.Pending(filter)

// worker.go:435
func commitTransactions(ctx, env,
        plainTxs, blobTxs *TransactionsByPriceAndNonce,
        interrupt) error {
    // 가격순으로 꺼내 하나씩 실행
    miner.applyTransaction(env, tx)  // :420
}

// core/blockchain.go: 블록 임포트 경로
res, err := bc.processor.Process(block, statedb, ...)

// core/state_processor.go
func (p *StateProcessor) Process(block *types.Block,
        statedb *state.StateDB, ...) (...) {

    for i, tx := range block.Transactions() {
        receipt, err := ApplyTransaction(...)
    }
}

func (v *BlockValidator) ValidateState(block, statedb,
        res *ProcessResult, stateless bool) error {

    // 재계산한 값  vs  헤더에 적힌 값
    if res.GasUsed != header.GasUsed   { ... }
    if receiptSha != header.ReceiptHash { ... }
    if stateRoot  != header.Root       {
        return fmt.Errorf("invalid merkle root", ...)
    }
}

ApplyTransactionWithEVM  // :218, 두 경로의 합류점
  → ApplyMessage         // :369, 상태 전이 본체

// EVM에 들어가기 전에 먼저 깎는다
gas, err := IntrinsicGas(msg.Data, ..., rules)
st.gasRemaining -= gas

// 21000 (기본) + calldata 바이트당 비용
// + 액세스 리스트, EIP-7623 floor 등 포크별 규칙

ret, st.gasRemaining, vmerr = st.evm.Call(...)

func (evm *EVM) Call(caller, addr, input, gas, value) {
    ...
    evm.Context.Transfer(evm.StateDB, caller, addr, value)

    code := evm.resolveCode(addr)
    if len(code) == 0 {
        ret, err = nil, nil  // 잔액만 옮기고 끝
    } else {
        ret, err = evm.interpreter.Run(contract, input, false)
    }
}

for {
    op = contract.GetOp(pc)      // fetch
    operation := jt[op]          // decode

    // 스택 깊이 검사 → constant gas 차감
    // 메모리 확장 계산 → dynamic gas 차감

    res, err = operation.execute(&pc, in, callContext)
                                 // execute
    pc++
}

(3 + 5) * 2

PUSH1 03   PUSH1 05   ADD   PUSH1 02   MUL
  60  03     60  05    01     60  02    02    ← 실제 코드

// 명령 하나가 1바이트. 그래서 byte-code

같은 01 이라도
  6001  ← 여기 01은 데이터 자리, 숫자 1
  01    ← 여기 01은 명령 자리, ADD

PUSH1 0x03
PUSH1 0x05
ADD

        스택 (위가 top)
  0x05
  0x03   →   0x08
  ....        ....

// ADD는 피연산자를 명시하지 않는다
// 꺼내고, 더하고, 다시 올린다

type operation struct {
    execute     executionFunc  // 실행 함수
    constantGas uint64         // 고정 가스
    dynamicGas  gasFunc        // 동적 가스 계산
    minStack    int            // 필요한 최소 깊이
    maxStack    int            // 1024 초과 방지 상한
    memorySize  memorySizeFunc // 메모리 확장량
}

var jt JumpTable  // [256]*operation

func opAdd(pc *uint64, interpreter *EVMInterpreter,
        scope *ScopeContext) ([]byte, error) {

    x, y := scope.Stack.pop(), scope.Stack.peek()
    y.Add(&x, y)
    return nil, nil
}

// jump_table.go 등록
ADD: {execute: opAdd, constantGas: GasFastestStep,
     minStack: minStack(2, 1), maxStack: maxStack(2, 1)},

newFrontierInstructionSet()
  → newHomesteadInstructionSet()
    → ... → newShanghaiInstructionSet()
      → newCancunInstructionSet()

// 각 포크 함수 = 이전 테이블 + 변경분
instructionSet[PUSH0] = &operation{...}  // EIP-3855
instructionSet[TLOAD] = &operation{...}  // EIP-1153
instructionSet[MCOPY] = &operation{...}  // EIP-5656

// 매 옵코드마다
cost = operation.constantGas        // ADD면 3, 끝

if operation.dynamicGas != nil {
    // SSTORE: 0→비0 여부, warm/cold (EIP-2929)
    // 메모리 옵코드: 확장 비용, 크기에 2차 증가
    dynamicCost, err = operation.dynamicGas(...)
}

if !contract.UseGas(cost) { return ErrOutOfGas }