From 183dbcc6a0e56bf46f6406d47134f3b88eb5eef1 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 30 Apr 2014 14:42:57 +0200 Subject: [PATCH] fixed state object changes for eth api --- ethereal/assets/ethereum.js | 14 ++++---- ethereal/assets/qml/webapp.qml | 5 ++- ethereal/assets/samplecoin.html | 3 +- ethereal/ui/ext_app.go | 62 ++++++++++++++++++++++++++++----- ethereal/ui/library.go | 35 ++----------------- ethereal/ui/types.go | 37 +++++++++++++++++--- 6 files changed, 98 insertions(+), 58 deletions(-) diff --git a/ethereal/assets/ethereum.js b/ethereal/assets/ethereum.js index bb6346cab..916655d5e 100644 --- a/ethereal/assets/ethereum.js +++ b/ethereal/assets/ethereum.js @@ -42,13 +42,13 @@ window.eth = { }, watch: function(address, storageAddrOrCb, cb) { - var ev = "changed:"+address; - + var ev; if(cb === undefined) { cb = storageAddrOrCb; storageAddrOrCb = ""; + ev = "object:"+address; } else { - ev += ":"+storageAddrOrCb; + ev = "storage:"+address+":"+storageAddrOrCb; } eth.on(ev, cb) @@ -57,13 +57,13 @@ window.eth = { }, disconnect: function(address, storageAddrOrCb, cb) { - var ev = "changed:"+address; - + var ev; if(cb === undefined) { cb = storageAddrOrCb; - storageAddrOrCb = null; + storageAddrOrCb = ""; + ev = "object:"+address; } else { - ev += ":"+storageAddrOrCb; + ev = "storage:"+address+":"+storageAddrOrCb; } eth.off(ev, cb) diff --git a/ethereal/assets/qml/webapp.qml b/ethereal/assets/qml/webapp.qml index eebe8921f..2f3fef4d2 100644 --- a/ethereal/assets/qml/webapp.qml +++ b/ethereal/assets/qml/webapp.qml @@ -58,8 +58,7 @@ ApplicationWindow { case "transact": require(5) - // TODO this will change to 6 soon with sec being teh first argument - var tx = eth.transact(data.args[0], data.args[1],data.args[2],data.args[3],data.args[4]) + var tx = eth.transact(data.args[0], data.args[1], data.args[2],data.args[3],data.args[4],data.args[5]) postData(data._seed, tx) break case "create": @@ -116,7 +115,7 @@ ApplicationWindow { postEvent("block:new", block) } function onObjectChangeCb(stateObject) { - postEvent("object:change", stateObject) + postEvent("object:"+stateObject.address(), stateObject) } } diff --git a/ethereal/assets/samplecoin.html b/ethereal/assets/samplecoin.html index 73368a0b8..02efa8e01 100644 --- a/ethereal/assets/samplecoin.html +++ b/ethereal/assets/samplecoin.html @@ -9,7 +9,7 @@ function createTransaction() { var amount = document.querySelector("#amount").value; var data = "0x" + addr + "\n" + amount - eth.createTx(jefcoinAddr, 0, "10000000", "250", data, function(tx) { + eth.transact("", jefcoinAddr, 0, "10000000", "250", data, function(tx) { debug("received tx hash:", tx) }) } @@ -28,7 +28,6 @@ function init() { }); eth.watch(jefcoinAddr, function(stateObject) { - debug(stateObject); eth.getStorage(jefcoinAddr, key, function(storage) { document.querySelector("#currentAmount").innerHTML = "Amount: " + storage; }); diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go index b90a2192c..c02ffb7b2 100644 --- a/ethereal/ui/ext_app.go +++ b/ethereal/ui/ext_app.go @@ -5,8 +5,10 @@ import ( "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" + "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "math/big" + "strings" ) type AppContainer interface { @@ -116,10 +118,10 @@ out: func (app *ExtApplication) Watch(addr, storageAddr string) { var event string if len(storageAddr) == 0 { - event = "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr)) + event = "object:" + string(ethutil.FromHex(addr)) app.lib.eth.Reactor().Subscribe(event, app.changeChan) } else { - event = "object:" + string(ethutil.FromHex(addr)) + event = "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr)) app.lib.eth.Reactor().Subscribe(event, app.changeChan) } @@ -152,24 +154,66 @@ func (lib *QEthereum) GetKey() string { return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) } -func (lib *QEthereum) GetStateObject(address string) *Contract { +func (lib *QEthereum) GetStateObject(address string) *QStateObject { stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) if stateObject != nil { - return NewContract(stateObject) + return NewQStateObject(stateObject) } // See GetStorage for explanation on "nil" - return NewContract(nil) + return NewQStateObject(nil) } func (lib *QEthereum) Watch(addr, storageAddr string) { // lib.stateManager.Watch(ethutil.FromHex(addr), ethutil.FromHex(storageAddr)) } -func (lib *QEthereum) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { - return lib.Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr) +func (lib *QEthereum) CreateTx(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { + return lib.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr) } -func (lib *QEthereum) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { - return "", nil +func (lib *QEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { + var hash []byte + var contractCreation bool + if len(recipient) == 0 { + contractCreation = true + } else { + hash = ethutil.FromHex(recipient) + } + + keyPair := ethutil.Config.Db.GetKeys()[0] + value := ethutil.Big(valueStr) + gas := ethutil.Big(gasStr) + gasPrice := ethutil.Big(gasPriceStr) + var tx *ethchain.Transaction + // Compile and assemble the given data + if contractCreation { + // Compile script + mainScript, initScript, err := utils.CompileScript(dataStr) + 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, data) + } + 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/library.go b/ethereal/ui/library.go index ec5f29f95..70462a93d 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -10,35 +10,6 @@ import ( "strings" ) -type Contract struct { - object *ethchain.StateObject -} - -func NewContract(object *ethchain.StateObject) *Contract { - return &Contract{object: object} -} - -func (c *Contract) 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 - if c.object != nil { - val := c.object.GetMem(ethutil.Big("0x" + address)) - - return val.BigInt().String() - } - - return "" -} - -func (c *Contract) Value() string { - if c.object != nil { - return c.object.Amount.String() - } - - return "" -} - type EthLib struct { stateManager *ethchain.StateManager blockChain *ethchain.BlockChain @@ -76,14 +47,14 @@ func (lib *EthLib) GetKey() string { return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) } -func (lib *EthLib) GetStateObject(address string) *Contract { +func (lib *EthLib) GetStateObject(address string) *QStateObject { stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) if stateObject != nil { - return NewContract(stateObject) + return NewQStateObject(stateObject) } // See GetStorage for explanation on "nil" - return NewContract(nil) + return NewQStateObject(nil) } func (lib *EthLib) Watch(addr, storageAddr string) { diff --git a/ethereal/ui/types.go b/ethereal/ui/types.go index 5c39f0217..9e12a8892 100644 --- a/ethereal/ui/types.go +++ b/ethereal/ui/types.go @@ -46,11 +46,38 @@ func NewQKeyRing(keys []interface{}) *QKeyRing { } type QStateObject struct { - Address string - Amount string - Nonce int + object *ethchain.StateObject +} + +func NewQStateObject(object *ethchain.StateObject) *QStateObject { + return &QStateObject{object: object} } -func NewQStateObject(stateObject *ethchain.StateObject) *QStateObject { - return &QStateObject{ethutil.Hex(stateObject.Address()), stateObject.Amount.String(), int(stateObject.Nonce)} +func (c *QStateObject) 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 + if c.object != nil { + val := c.object.GetMem(ethutil.Big("0x" + address)) + + return val.BigInt().String() + } + + return "" +} + +func (c *QStateObject) Value() string { + if c.object != nil { + return c.object.Amount.String() + } + + return "" +} + +func (c *QStateObject) Address() string { + if c.object != nil { + return ethutil.Hex(c.object.Address()) + } + + return "" }