StateTransition

狀態轉換模型

/*
The State Transitioning Model
狀態轉換模型
A state transition is a change made when a transaction is applied to the current world state
狀態轉換 是指用當前的world state來執行交易，並改變當前的world state
The state transitioning model does all all the necessary work to work out a valid new state root.
狀態轉換做了所有所需的工作來產生一個新的有效的state root
1) Nonce handling  Nonce 處理
2) Pre pay gas     預先支付Gas
3) Create a new state object if the recipient is \0*32 如果接收人是空，那麼建立一個新的state object
4) Value transfer  轉賬
== If contract creation ==
  4a) Attempt to run transaction data 嘗試執行輸入的資料
  4b) If valid, use result as code for the new state object 如果有效，那麼用執行的結果作為新的state object的code
== end ==
5) Run Script section 執行指令碼部分
6) Derive new state root 匯出新的state root
*/
type StateTransition struct {
    gp         *GasPool   //用來追蹤區塊內部的Gas的使用情況
    msg        Message      // Message Call
    gas        uint64
    gasPrice   *big.Int     // gas的價格
    initialGas *big.Int     // 最開始的gas
    value      *big.Int     // 轉賬的值
    data       []byte       // 輸入資料
    state      vm.StateDB   // StateDB
    evm        *vm.EVM      // 虛擬機器
}

// Message represents a message sent to a contract.
type Message interface {
    From() common.Address
    //FromFrontier() (common.Address, error)
    To() *common.Address    // 

    GasPrice() *big.Int  // Message 的 GasPrice
    Gas() *big.Int      //message 的 GasLimit
    Value() *big.Int

    Nonce() uint64
    CheckNonce() bool
    Data() []byte
}
 

構造

// NewStateTransition initialises and returns a new state transition object.
func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition {
    return &StateTransition{
        gp:         gp,
        evm:        evm,
        msg:        msg,
        gasPrice:   msg.GasPrice(),
        initialGas: new(big.Int),
        value:      msg.Value(),
        data:       msg.Data(),
        state:      evm.StateDB,
    }
}
 

執行Message

// ApplyMessage computes the new state by applying the given message
// against the old state within the environment.
// ApplyMessage 通過應用給定的Message 和狀態來生成新的狀態
// ApplyMessage returns the bytes returned by any EVM execution (if it took place),
// the gas used (which includes gas refunds) and an error if it failed. An error always
// indicates a core error meaning that the message would always fail for that particular
// state and would never be accepted within a block.
// ApplyMessage返回由任何EVM執行（如果發生）返回的位元組，
// 使用的Gas（包括Gas退款），如果失敗則返回錯誤。 一個錯誤總是表示一個核心錯誤，
// 意味著這個訊息對於這個特定的狀態將總是失敗，並且永遠不會在一個塊中被接受。
func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, *big.Int, bool, error) {
    st := NewStateTransition(evm, msg, gp)

    ret, _, gasUsed, failed, err := st.TransitionDb()
    return ret, gasUsed, failed, err
}
 

TransitionDb

// TransitionDb will transition the state by applying the current message and returning the result
// including the required gas for the operation as well as the used gas. It returns an error if it
// failed. An error indicates a consensus issue.
// TransitionDb 
func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, failed bool, err error) {
    if err = st.preCheck(); err != nil {
        return
    }
    msg := st.msg
    sender := st.from() // err checked in preCheck

    homestead := st.evm.ChainConfig().IsHomestead(st.evm.BlockNumber)
    contractCreation := msg.To() == nil // 如果msg.To是nil 那麼認為是一個合約建立

    // Pay intrinsic gas
    // TODO convert to uint64
    // 計算最開始的Gas  g0
    intrinsicGas := IntrinsicGas(st.data, contractCreation, homestead)
    if intrinsicGas.BitLen() > 64 {
        return nil, nil, nil, false, vm.ErrOutOfGas
    }
    if err = st.useGas(intrinsicGas.Uint64()); err != nil {
        return nil, nil, nil, false, err
    }

    var (
        evm = st.evm
        // vm errors do not effect consensus and are therefor
        // not assigned to err, except for insufficient balance
        // error.
        vmerr error
    )
    if contractCreation { //如果是合約建立， 那麼呼叫evm的Create方法
        ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)
    } else {
        // Increment the nonce for the next transaction
        // 如果是方法呼叫。那麼首先設定sender的nonce。
        st.state.SetNonce(sender.Address(), st.state.GetNonce(sender.Address())+1)
        ret, st.gas, vmerr = evm.Call(sender, st.to().Address(), st.data, st.gas, st.value)
    }
    if vmerr != nil {
        log.Debug("VM returned with error", "err", vmerr)
        // The only possible consensus-error would be if there wasn't
        // sufficient balance to make the transfer happen. The first
        // balance transfer may never fail.
        if vmerr == vm.ErrInsufficientBalance {
            return nil, nil, nil, false, vmerr
        }
    }
    requiredGas = new(big.Int).Set(st.gasUsed()) // 計算被使用的Gas數量

    st.refundGas()  //計算Gas的退費 會增加到 st.gas上面。 所以礦工拿到的是退稅後的
    st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(st.gasUsed(), st.gasPrice)) // 給礦工增加收入。
    // requiredGas和gasUsed的區別一個是沒有退稅的， 一個是退稅了的。
    // 看上面的呼叫 ApplyMessage直接丟棄了requiredGas, 說明返回的是退稅了的。
    return ret, requiredGas, st.gasUsed(), vmerr != nil, err
}

關於g0的計算，在黃皮書上由詳細的介紹

和黃皮書有一定出入的部分在於if contractCreation && homestead {igas.SetUint64(params.TxGasContractCreation) 這是因為 Gtxcreate+Gtransaction = TxGasContractCreation

func IntrinsicGas(data []byte, contractCreation, homestead bool) *big.Int {
    igas := new(big.Int)
    if contractCreation && homestead {
        igas.SetUint64(params.TxGasContractCreation)
    } else {
        igas.SetUint64(params.TxGas)
    }
    if len(data) > 0 {
        var nz int64
        for _, byt := range data {
            if byt != 0 {
                nz++
            }
        }
        m := big.NewInt(nz)
        m.Mul(m, new(big.Int).SetUint64(params.TxDataNonZeroGas))
        igas.Add(igas, m)
        m.SetInt64(int64(len(data)) - nz)
        m.Mul(m, new(big.Int).SetUint64(params.TxDataZeroGas))
        igas.Add(igas, m)
    }
    return igas
}

執行前的檢查

func (st *StateTransition) preCheck() error {
    msg := st.msg
    sender := st.from()

    // Make sure this transaction's nonce is correct
    if msg.CheckNonce() {
        nonce := st.state.GetNonce(sender.Address())
        // 當前本地的nonce 需要和 msg的Nonce一樣 不然就是狀態不同步了。
        if nonce < msg.Nonce() {
            return ErrNonceTooHigh
        } else if nonce > msg.Nonce() {
            return ErrNonceTooLow
        }
    }
    return st.buyGas()
}

buyGas， 實現Gas的預扣費， 首先就扣除你的GasLimit * GasPrice的錢。 然後根據計算完的狀態在退還一部分。

func (st *StateTransition) buyGas() error {
    mgas := st.msg.Gas()
    if mgas.BitLen() > 64 {
        return vm.ErrOutOfGas
    }

    mgval := new(big.Int).Mul(mgas, st.gasPrice)

    var (
        state  = st.state
        sender = st.from()
    )
    if state.GetBalance(sender.Address()).Cmp(mgval) < 0 {
        return errInsufficientBalanceForGas
    }
    if err := st.gp.SubGas(mgas); err != nil { // 從區塊的gaspool裡面減去， 因為區塊是由GasLimit限制整個區塊的Gas使用的。 
        return err
    }
    st.gas += mgas.Uint64()

    st.initialGas.Set(mgas)
    state.SubBalance(sender.Address(), mgval)
    // 從賬號裡面減去 GasLimit * GasPrice
    return nil
}

退稅，退稅是為了獎勵大家執行一些能夠減輕區塊鏈負擔的指令， 比如清空賬戶的storage. 或者是執行suicide命令來清空賬號。

func (st *StateTransition) refundGas() {
    // Return eth for remaining gas to the sender account,
    // exchanged at the original rate.
    sender := st.from() // err already checked
    remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
    // 首先把使用者還剩下的Gas還回去。
    st.state.AddBalance(sender.Address(), remaining)

    // Apply refund counter, capped to half of the used gas.
    // 然後退稅的總金額不會超過使用者Gas總使用的1/2。 
    uhalf := remaining.Div(st.gasUsed(), common.Big2)
    refund := math.BigMin(uhalf, st.state.GetRefund())
    st.gas += refund.Uint64()
    // 把退稅的金額加到使用者賬戶上。
    st.state.AddBalance(sender.Address(), refund.Mul(refund, st.gasPrice))

    // Also return remaining gas to the block gas counter so it is
    // available for the next transaction.
    // 同時也把退稅的錢還給gaspool給下個交易騰點Gas空間。
    st.gp.AddGas(new(big.Int).SetUint64(st.gas))
}

StateProcessor

StateTransition是用來處理一個一個的交易的。那麼StateProcessor就是用來處理區塊級別的交易的。

結構和構造

// StateProcessor is a basic Processor, which takes care of transitioning
// state from one point to another.
//
// StateProcessor implements Processor.
type StateProcessor struct {
    config *params.ChainConfig // Chain configuration options
    bc     *BlockChain         // Canonical block chain
    engine consensus.Engine    // Consensus engine used for block rewards
}

// NewStateProcessor initialises a new StateProcessor.
func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consensus.Engine) *StateProcessor {
    return &StateProcessor{
        config: config,
        bc:     bc,
        engine: engine,
    }
}

Process，這個方法會被blockchain呼叫。

// Process processes the state changes according to the Ethereum rules by running
// the transaction messages using the statedb and applying any rewards to both
// the processor (coinbase) and any included uncles.
// Process 根據以太坊規則執行交易資訊來對statedb進行狀態改變，以及獎勵挖礦者或者是其他的叔父節點。
// Process returns the receipts and logs accumulated during the process and
// returns the amount of gas that was used in the process. If any of the
// transactions failed to execute due to insufficient gas it will return an error.
// Process返回執行過程中累計的收據和日誌，並返回過程中使用的Gas。 如果由於Gas不足而導致任何交易執行失敗，將返回錯誤。
func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) {
    var (
        receipts     types.Receipts
        totalUsedGas = big.NewInt(0)
        header       = block.Header()
        allLogs      []*types.Log
        gp           = new(GasPool).AddGas(block.GasLimit())
    )
    // Mutate the the block and state according to any hard-fork specs
    // DAO 事件的硬分叉處理 
    if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
        misc.ApplyDAOHardFork(statedb)
    }
    // Iterate over and process the individual transactions
    for i, tx := range block.Transactions() {
        statedb.Prepare(tx.Hash(), block.Hash(), i)
        receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, totalUsedGas, cfg)
        if err != nil {
            return nil, nil, nil, err
        }
        receipts = append(receipts, receipt)
        allLogs = append(allLogs, receipt.Logs...)
    }
    // Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
    p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts)
    // 返回收據 日誌 總的Gas使用量和nil
    return receipts, allLogs, totalUsedGas, nil
}

ApplyTransaction

// ApplyTransaction attempts to apply a transaction to the given state database
// and uses the input parameters for its environment. It returns the receipt
// for the transaction, gas used and an error if the transaction failed,
// indicating the block was invalid.
ApplyTransaction嘗試將事務應用於給定的狀態資料庫，並使用其環境的輸入引數。 
//它返回事務的收據，使用的Gas和錯誤，如果交易失敗，表明塊是無效的。

func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, *big.Int, error) {
    // 把交易轉換成Message 
    // 這裡如何驗證訊息確實是Sender傳送的。 TODO
    msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
    if err != nil {
        return nil, nil, err
    }
    // Create a new context to be used in the EVM environment
    // 每一個交易都建立了新的虛擬機器環境。
    context := NewEVMContext(msg, header, bc, author)
    // Create a new environment which holds all relevant information
    // about the transaction and calling mechanisms.
    vmenv := vm.NewEVM(context, statedb, config, cfg)
    // Apply the transaction to the current state (included in the env)
    _, gas, failed, err := ApplyMessage(vmenv, msg, gp)
    if err != nil {
        return nil, nil, err
    }

    // Update the state with pending changes
    // 求得中間狀態
    var root []byte
    if config.IsByzantium(header.Number) {
        statedb.Finalise(true)
    } else {
        root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes()
    }
    usedGas.Add(usedGas, gas)

    // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
    // based on the eip phase, we're passing wether the root touch-delete accounts.
    // 建立一個收據, 用來儲存中間狀態的root, 以及交易使用的gas
    receipt := types.NewReceipt(root, failed, usedGas)
    receipt.TxHash = tx.Hash()
    receipt.GasUsed = new(big.Int).Set(gas)
    // if the transaction created a contract, store the creation address in the receipt.
    // 如果是建立合約的交易.那麼我們把建立地址儲存到收據裡面.
    if msg.To() == nil {
        receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce())
    }

    // Set the receipt logs and create a bloom for filtering
    receipt.Logs = statedb.GetLogs(tx.Hash())
    receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
    // 拿到所有的日誌並建立日誌的布隆過濾器.
    return receipt, gas, err
}