path: root/ethchain/deprecated.go

package ethchain

import (
    "bytes"
    "fmt"
    "github.com/ethereum/eth-go/ethutil"
    "math/big"
)

func (sm *StateManager) MakeStateObject(state *State, tx *Transaction) *StateObject {
    contract := MakeContract(tx, state)
    if contract != nil {
        state.states[string(tx.CreationAddress())] = contract.state

        return contract
    }

    return nil
}

func (sm *StateManager) EvalScript(state *State, script []byte, object *StateObject, tx *Transaction, block *Block) (ret []byte, gas *big.Int, err error) {
    account := state.GetAccount(tx.Sender())

    err = account.ConvertGas(tx.Gas, tx.GasPrice)
    if err != nil {
        ethutil.Config.Log.Debugln(err)
        return
    }

    closure := NewClosure(account, object, script, state, tx.Gas, tx.GasPrice)
    vm := NewVm(state, sm, RuntimeVars{
        Origin:      account.Address(),
        BlockNumber: block.BlockInfo().Number,
        PrevHash:    block.PrevHash,
        Coinbase:    block.Coinbase,
        Time:        block.Time,
        Diff:        block.Difficulty,
        Value:       tx.Value,
        //Price:       tx.GasPrice,
    })
    ret, gas, err = closure.Call(vm, tx.Data, nil)

    // Update the account (refunds)
    state.UpdateStateObject(account)
    state.UpdateStateObject(object)

    return
}

func (self *StateManager) ProcessTransaction(tx *Transaction, coinbase *StateObject, state *State, toContract bool) (gas *big.Int, err error) {
    fmt.Printf("state root before update %x\n", state.Root())
    defer func() {
        if r := recover(); r != nil {
            ethutil.Config.Log.Infoln(r)
            err = fmt.Errorf("%v", r)
        }
    }()

    gas = new(big.Int)
    addGas := func(g *big.Int) { gas.Add(gas, g) }
    addGas(GasTx)

    // Get the sender
    sender := state.GetAccount(tx.Sender())

    if sender.Nonce != tx.Nonce {
        err = NonceError(tx.Nonce, sender.Nonce)
        return
    }

    sender.Nonce += 1
    defer func() {
        //state.UpdateStateObject(sender)
        // Notify all subscribers
        self.Ethereum.Reactor().Post("newTx:post", tx)
    }()

    txTotalBytes := big.NewInt(int64(len(tx.Data)))
    //fmt.Println("txTotalBytes", txTotalBytes)
    //txTotalBytes.Div(txTotalBytes, ethutil.Big32)
    addGas(new(big.Int).Mul(txTotalBytes, GasData))

    rGas := new(big.Int).Set(gas)
    rGas.Mul(gas, tx.GasPrice)

    // Make sure there's enough in the sender's account. Having insufficient
    // funds won't invalidate this transaction but simple ignores it.
    totAmount := new(big.Int).Add(tx.Value, rGas)
    if sender.Amount.Cmp(totAmount) < 0 {
        state.UpdateStateObject(sender)
        err = fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
        return
    }

    coinbase.BuyGas(gas, tx.GasPrice)
    state.UpdateStateObject(coinbase)
    fmt.Printf("1. root %x\n", state.Root())

    // Get the receiver
    receiver := state.GetAccount(tx.Recipient)

    // Send Tx to self
    if bytes.Compare(tx.Recipient, tx.Sender()) == 0 {
        // Subtract the fee
        sender.SubAmount(rGas)
    } else {
        // Subtract the amount from the senders account
        sender.SubAmount(totAmount)
        state.UpdateStateObject(sender)
        fmt.Printf("3. root %x\n", state.Root())

        // Add the amount to receivers account which should conclude this transaction
        receiver.AddAmount(tx.Value)
        state.UpdateStateObject(receiver)
        fmt.Printf("2. root %x\n", state.Root())
    }

    ethutil.Config.Log.Infof("[TXPL] Processed Tx %x\n", tx.Hash())

    return
}

func (sm *StateManager) ApplyTransaction(coinbase []byte, state *State, block *Block, tx *Transaction) (totalGasUsed *big.Int, err error) {
    /*
        Applies transactions to the given state and creates new
        state objects where needed.

        If said objects needs to be created
        run the initialization script provided by the transaction and
        assume there's a return value. The return value will be set to
        the script section of the state object.
    */
    var (
        addTotalGas = func(gas *big.Int) { totalGasUsed.Add(totalGasUsed, gas) }
        gas         = new(big.Int)
        script      []byte
    )
    totalGasUsed = big.NewInt(0)
    snapshot := state.Snapshot()

    ca := state.GetAccount(coinbase)
    // Apply the transaction to the current state
    gas, err = sm.ProcessTransaction(tx, ca, state, false)
    addTotalGas(gas)
    fmt.Println("gas used by tx", gas)

    if tx.CreatesContract() {
        if err == nil {
            // Create a new state object and the transaction
            // as it's data provider.
            contract := sm.MakeStateObject(state, tx)
            if contract != nil {
                fmt.Println(Disassemble(contract.Init()))
                // Evaluate the initialization script
                // and use the return value as the
                // script section for the state object.
                script, gas, err = sm.EvalScript(state, contract.Init(), contract, tx, block)
                fmt.Println("gas used by eval", gas)
                addTotalGas(gas)
                fmt.Println("total =", totalGasUsed)

                fmt.Println("script len =", len(script))

                if err != nil {
                    err = fmt.Errorf("[STATE] Error during init script run %v", err)
                    return
                }
                contract.script = script
                state.UpdateStateObject(contract)
            } else {
                err = fmt.Errorf("[STATE] Unable to create contract")
            }
        } else {
            err = fmt.Errorf("[STATE] contract creation tx: %v for sender %x", err, tx.Sender())
        }
    } else {
        // Find the state object at the "recipient" address. If
        // there's an object attempt to run the script.
        stateObject := state.GetStateObject(tx.Recipient)
        if err == nil && stateObject != nil && len(stateObject.Script()) > 0 {
            _, gas, err = sm.EvalScript(state, stateObject.Script(), stateObject, tx, block)
            addTotalGas(gas)
        }
    }

    parent := sm.bc.GetBlock(block.PrevHash)
    total := new(big.Int).Add(block.GasUsed, totalGasUsed)
    limit := block.CalcGasLimit(parent)
    if total.Cmp(limit) > 0 {
        state.Revert(snapshot)
        err = GasLimitError(total, limit)
    }

    return
}

// Apply transactions uses the transaction passed to it and applies them onto
// the current processing state.
func (sm *StateManager) ApplyTransactions(coinbase []byte, state *State, block *Block, txs []*Transaction) ([]*Receipt, []*Transaction) {
    // Process each transaction/contract
    var receipts []*Receipt
    var validTxs []*Transaction
    var ignoredTxs []*Transaction // Transactions which go over the gasLimit

    totalUsedGas := big.NewInt(0)

    for _, tx := range txs {
        usedGas, err := sm.ApplyTransaction(coinbase, state, block, tx)
        if err != nil {
            if IsNonceErr(err) {
                continue
            }
            if IsGasLimitErr(err) {
                ignoredTxs = append(ignoredTxs, tx)
                // We need to figure out if we want to do something with thse txes
                ethutil.Config.Log.Debugln("Gastlimit:", err)
                continue
            }

            ethutil.Config.Log.Infoln(err)
        }

        accumelative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, usedGas))
        receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}

        receipts = append(receipts, receipt)
        validTxs = append(validTxs, tx)
    }

    fmt.Println("################# MADE\n", receipts, "\n############################")

    // Update the total gas used for the block (to be mined)
    block.GasUsed = totalUsedGas

    return receipts, validTxs
}