path: root/xeth/xeth.go

package xeth

/*
 * eXtended ETHereum
 */

import (
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethutil"
    "github.com/ethereum/go-ethereum/logger"
    "github.com/ethereum/go-ethereum/state"
)

var pipelogger = logger.NewLogger("XETH")

type VmVars struct {
    State *state.StateDB
}

type XEth struct {
    obj            core.EthManager
    blockProcessor *core.BlockProcessor
    chainManager   *core.ChainManager
    world          *World

    Vm VmVars
}

func New(obj core.EthManager) *XEth {
    pipe := &XEth{
        obj:            obj,
        blockProcessor: obj.BlockProcessor(),
        chainManager:   obj.ChainManager(),
    }
    pipe.world = NewWorld(pipe)

    return pipe
}

/*
 * State / Account accessors
 */
func (self *XEth) Balance(addr []byte) *ethutil.Value {
    return ethutil.NewValue(self.World().safeGet(addr).Balance)
}

func (self *XEth) Nonce(addr []byte) uint64 {
    return self.World().safeGet(addr).Nonce
}

func (self *XEth) Block(hash []byte) *types.Block {
    return self.chainManager.GetBlock(hash)
}

func (self *XEth) Storage(addr, storageAddr []byte) *ethutil.Value {
    return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr))
}

func (self *XEth) Exists(addr []byte) bool {
    return self.World().Get(addr) != nil
}

// Converts the given private key to an address
func (self *XEth) ToAddress(priv []byte) []byte {
    pair, err := crypto.NewKeyPairFromSec(priv)
    if err != nil {
        return nil
    }

    return pair.Address()
}

/*
 * Execution helpers
 */
func (self *XEth) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
    return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price)
}

func (self *XEth) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
    var (
        initiator = state.NewStateObject(self.obj.KeyManager().KeyPair().Address(), self.obj.Db())
        block     = self.chainManager.CurrentBlock()
    )

    self.Vm.State = self.World().State().Copy()

    vmenv := NewEnv(self.chainManager, self.Vm.State, block, value.BigInt(), initiator.Address())
    return vmenv.Call(initiator, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt())
}

/*
 * Transactional methods
 */
func (self *XEth) TransactString(key *crypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
    // Check if an address is stored by this address
    var hash []byte
    addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes()
    if len(addr) > 0 {
        hash = addr
    } else if ethutil.IsHex(rec) {
        hash = ethutil.Hex2Bytes(rec[2:])
    } else {
        hash = ethutil.Hex2Bytes(rec)
    }

    return self.Transact(key, hash, value, gas, price, data)
}

func (self *XEth) Transact(key *crypto.KeyPair, to []byte, value, gas, price *ethutil.Value, data []byte) (*types.Transaction, error) {
    var hash []byte
    var contractCreation bool
    if types.IsContractAddr(to) {
        contractCreation = true
    } else {
        // Check if an address is stored by this address
        addr := self.World().Config().Get("NameReg").Storage(to).Bytes()
        if len(addr) > 0 {
            hash = addr
        } else {
            hash = to
        }
    }

    var tx *types.Transaction
    if contractCreation {
        tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
    } else {
        tx = types.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
    }

    state := self.chainManager.TransState()
    nonce := state.GetNonce(key.Address())

    tx.SetNonce(nonce)
    tx.Sign(key.PrivateKey)

    // Do some pre processing for our "pre" events  and hooks
    block := self.chainManager.NewBlock(key.Address())
    coinbase := state.GetOrNewStateObject(key.Address())
    coinbase.SetGasPool(block.GasLimit())
    self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)

    err := self.obj.TxPool().Add(tx)
    if err != nil {
        return nil, err
    }
    state.SetNonce(key.Address(), nonce+1)

    if contractCreation {
        addr := core.AddressFromMessage(tx)
        pipelogger.Infof("Contract addr %x\n", addr)
    }

    return tx, nil
}

func (self *XEth) PushTx(tx *types.Transaction) ([]byte, error) {
    err := self.obj.TxPool().Add(tx)
    if err != nil {
        return nil, err
    }

    if tx.To() == nil {
        addr := core.AddressFromMessage(tx)
        pipelogger.Infof("Contract addr %x\n", addr)
        return addr, nil
    }
    return tx.Hash(), nil
}

func (self *XEth) CompileMutan(code string) ([]byte, error) {
    data, err := ethutil.Compile(code, false)
    if err != nil {
        return nil, err
    }

    return data, nil
}