aboutsummaryrefslogtreecommitdiffstats
path: root/utils/ethereum.go
blob: c383c4c91abcbcb9a110c7c96b41c2f396799862 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package utils

import (
    "github.com/ethereum/eth-go"
    "github.com/ethereum/eth-go/ethchain"
    "github.com/ethereum/eth-go/ethutil"
)

type PEthereum struct {
    stateManager *ethchain.StateManager
    blockChain   *ethchain.BlockChain
    txPool       *ethchain.TxPool
}

func NewPEthereum(eth *eth.Ethereum) *PEthereum {
    return &PEthereum{
        eth.StateManager(),
        eth.BlockChain(),
        eth.TxPool(),
    }
}

func (lib *PEthereum) GetBlock(hexHash string) *PBlock {
    hash := ethutil.FromHex(hexHash)

    block := lib.blockChain.GetBlock(hash)

    return &PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
}

func (lib *PEthereum) GetKey() string {
    return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address())
}

func (lib *PEthereum) GetStateObject(address string) *PStateObject {
    stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address))
    if stateObject != nil {
        return NewPStateObject(stateObject)
    }

    // See GetStorage for explanation on "nil"
    return NewPStateObject(nil)
}

func (lib *PEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
    return lib.createTx(key, recipient, valueStr, gasStr, gasPriceStr, dataStr, "")
}

func (lib *PEthereum) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr string) (string, error) {
    return lib.createTx(key, "", valueStr, gasStr, gasPriceStr, initStr, bodyStr)
}

func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, initStr, scriptStr string) (string, error) {
    var hash []byte
    var contractCreation bool
    if len(recipient) == 0 {
        contractCreation = true
    } else {
        hash = ethutil.FromHex(recipient)
    }

    keyPair, err := ethchain.NewKeyPairFromSec([]byte(key))
    if err != nil {
        return "", err
    }

    value := ethutil.Big(valueStr)
    gas := ethutil.Big(gasStr)
    gasPrice := ethutil.Big(gasPriceStr)
    var tx *ethchain.Transaction
    // Compile and assemble the given data
    if contractCreation {
        initScript, err := Compile(initStr)
        if err != nil {
            return "", err
        }
        mainScript, err := Compile(scriptStr)
        if err != nil {
            return "", err
        }

        tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript)
    } else {
        /*
            lines := strings.Split(dataStr, "\n")
            var data []byte
            for _, line := range lines {
                data = append(data, ethutil.BigToBytes(ethutil.Big(line), 256)...)
            }
        */

        tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, []byte(initStr))
    }

    acc := lib.stateManager.GetAddrState(keyPair.Address())
    tx.Nonce = acc.Nonce
    tx.Sign(keyPair.PrivateKey)
    lib.txPool.QueueTransaction(tx)

    if contractCreation {
        ethutil.Config.Log.Infof("Contract addr %x", tx.Hash()[12:])
    } else {
        ethutil.Config.Log.Infof("Tx hash %x", tx.Hash())
    }

    return ethutil.Hex(tx.Hash()), nil
}