diff options
| -rw-r--r-- | utils/ethereum.go | 107 | ||||
| -rw-r--r-- | utils/types.go (renamed from ethereal/ui/types.go) | 34 |
2 files changed, 124 insertions, 17 deletions
diff --git a/utils/ethereum.go b/utils/ethereum.go new file mode 100644 index 000000000..c383c4c91 --- /dev/null +++ b/utils/ethereum.go @@ -0,0 +1,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 +} diff --git a/ethereal/ui/types.go b/utils/types.go index 9e12a8892..44264aa5e 100644 --- a/ethereal/ui/types.go +++ b/utils/types.go @@ -1,4 +1,4 @@ -package ethui +package utils import ( "encoding/hex" @@ -7,53 +7,53 @@ import ( ) // Block interface exposed to QML -type QBlock struct { +type PBlock struct { Number int Hash string } // Creates a new QML Block from a chain block -func NewQBlock(block *ethchain.Block) *QBlock { +func NewPBlock(block *ethchain.Block) *PBlock { info := block.BlockInfo() hash := hex.EncodeToString(block.Hash()) - return &QBlock{Number: int(info.Number), Hash: hash} + return &PBlock{Number: int(info.Number), Hash: hash} } -type QTx struct { +type PTx struct { Value, Hash, Address string Contract bool } -func NewQTx(tx *ethchain.Transaction) *QTx { +func NewPTx(tx *ethchain.Transaction) *PTx { hash := hex.EncodeToString(tx.Hash()) sender := hex.EncodeToString(tx.Recipient) isContract := len(tx.Data) > 0 - return &QTx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender, Contract: isContract} + return &PTx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender, Contract: isContract} } -type QKey struct { +type PKey struct { Address string } -type QKeyRing struct { +type PKeyRing struct { Keys []interface{} } -func NewQKeyRing(keys []interface{}) *QKeyRing { - return &QKeyRing{Keys: keys} +func NewPKeyRing(keys []interface{}) *PKeyRing { + return &PKeyRing{Keys: keys} } -type QStateObject struct { +type PStateObject struct { object *ethchain.StateObject } -func NewQStateObject(object *ethchain.StateObject) *QStateObject { - return &QStateObject{object: object} +func NewPStateObject(object *ethchain.StateObject) *PStateObject { + return &PStateObject{object: object} } -func (c *QStateObject) GetStorage(address string) string { +func (c *PStateObject) GetStorage(address string) string { // Because somehow, even if you return nil to QML it // still has some magical object so we can't rely on // undefined or null at the QML side @@ -66,7 +66,7 @@ func (c *QStateObject) GetStorage(address string) string { return "" } -func (c *QStateObject) Value() string { +func (c *PStateObject) Value() string { if c.object != nil { return c.object.Amount.String() } @@ -74,7 +74,7 @@ func (c *QStateObject) Value() string { return "" } -func (c *QStateObject) Address() string { +func (c *PStateObject) Address() string { if c.object != nil { return ethutil.Hex(c.object.Address()) } |