From c5215fd4fb9de7594fdb812f8f9e4c471ee8d003 Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 27 Mar 2014 19:41:42 +0100 Subject: Added gas and gas price. * library's `createTx` method changed so it accepts a gas price * dev console accepts code as well as the library --- ethereal/ui/library.go | 48 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 47 insertions(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 05fffd579..bd67f3c20 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -5,6 +5,7 @@ import ( "fmt" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" + "github.com/obscuren/mutan" "strings" ) @@ -14,6 +15,50 @@ type EthLib struct { txPool *ethchain.TxPool } +func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) string { + var hash []byte + var contractCreation bool + if len(recipient) == 0 { + contractCreation = true + } else { + var err error + hash, err = hex.DecodeString(recipient) + if err != nil { + return err.Error() + } + } + + keyPair := ethutil.Config.Db.GetKeys()[0] + value := ethutil.Big(valueStr) + gas := ethutil.Big(valueStr) + gasPrice := ethutil.Big(gasPriceStr) + var tx *ethchain.Transaction + // Compile and assemble the given data + if contractCreation { + asm, err := mutan.NewCompiler().Compile(strings.NewReader(data)) + if err != nil { + return err.Error() + } + + code := ethutil.Assemble(asm) + tx = ethchain.NewContractCreationTx(value, gasPrice, code) + } else { + tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, []string{}) + } + tx.Nonce = lib.stateManager.GetAddrState(keyPair.Address()).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()) +} + +/* func (lib *EthLib) CreateTx(receiver, a, data string) string { var hash []byte if len(receiver) == 0 { @@ -31,7 +76,7 @@ func (lib *EthLib) CreateTx(receiver, a, data string) string { amount := ethutil.Big(a) code := ethchain.Compile(strings.Split(data, "\n")) - tx := ethchain.NewTransaction(hash, amount, code) + tx := ethchain.NewTx(hash, amount, code) tx.Nonce = lib.stateManager.GetAddrState(keyPair.Address()).Nonce tx.Sign(keyPair.PrivateKey) @@ -46,6 +91,7 @@ func (lib *EthLib) CreateTx(receiver, a, data string) string { return ethutil.Hex(tx.Hash()) } +*/ func (lib *EthLib) GetBlock(hexHash string) *Block { hash, err := hex.DecodeString(hexHash) -- cgit v1.2.3 From ebbc5e7cb8b3886c8557f9f8623113f52f7f5e4a Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 30 Mar 2014 22:03:29 +0200 Subject: Updated to new mutan api --- ethereal/ui/library.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index bd67f3c20..692ec454c 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -35,7 +35,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin var tx *ethchain.Transaction // Compile and assemble the given data if contractCreation { - asm, err := mutan.NewCompiler().Compile(strings.NewReader(data)) + asm, err := mutan.Compile(strings.NewReader(data), false) if err != nil { return err.Error() } -- cgit v1.2.3 From 97b98b1250890977ea622af378fe864e4620e313 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 31 Mar 2014 00:22:50 +0200 Subject: Fixed an issue with sending gas to a contract --- ethereal/ui/library.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 692ec454c..6f8cb6f65 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -30,7 +30,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin keyPair := ethutil.Config.Db.GetKeys()[0] value := ethutil.Big(valueStr) - gas := ethutil.Big(valueStr) + gas := ethutil.Big(gasStr) gasPrice := ethutil.Big(gasPriceStr) var tx *ethchain.Transaction // Compile and assemble the given data @@ -40,7 +40,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin return err.Error() } - code := ethutil.Assemble(asm) + code := ethutil.Assemble(asm...) tx = ethchain.NewContractCreationTx(value, gasPrice, code) } else { tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, []string{}) -- cgit v1.2.3 From 5660d598df3d86f892975fcf9628133529598221 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 1 Apr 2014 10:40:34 +0200 Subject: Added tx output --- ethereal/ui/library.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 6f8cb6f65..7a8939bf1 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -15,7 +15,7 @@ type EthLib struct { txPool *ethchain.TxPool } -func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) string { +func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { var hash []byte var contractCreation bool if len(recipient) == 0 { @@ -24,7 +24,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin var err error hash, err = hex.DecodeString(recipient) if err != nil { - return err.Error() + return "", err } } @@ -37,7 +37,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin if contractCreation { asm, err := mutan.Compile(strings.NewReader(data), false) if err != nil { - return err.Error() + return "", err } code := ethutil.Assemble(asm...) @@ -55,7 +55,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin ethutil.Config.Log.Infof("Tx hash %x", tx.Hash()) } - return ethutil.Hex(tx.Hash()) + return ethutil.Hex(tx.Hash()), nil } /* -- cgit v1.2.3 From 1e94cb5286067da80c3227861a836c611f01e32b Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 9 Apr 2014 16:01:11 +0200 Subject: Nonce handling --- ethereal/ui/library.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 7a8939bf1..9a7469426 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -45,7 +45,9 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin } else { tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, []string{}) } - tx.Nonce = lib.stateManager.GetAddrState(keyPair.Address()).Nonce + acc := lib.stateManager.GetAddrState(keyPair.Address()) + tx.Nonce = acc.Nonce + //acc.Nonce++ tx.Sign(keyPair.PrivateKey) lib.txPool.QueueTransaction(tx) -- cgit v1.2.3 From e2bf5d1270b1dc33f308ab134e7e7d3f4f64b7d4 Mon Sep 17 00:00:00 2001 From: Maran Date: Thu, 10 Apr 2014 14:53:12 -0400 Subject: Implemented key importing/generation for the GUI --- ethereal/ui/gui.go | 34 +++++++++++++++++++++++++--------- ethereal/ui/library.go | 28 ++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 9 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 89736ac29..6184baee6 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -53,7 +53,6 @@ type Gui struct { txDb *ethdb.LDBDatabase addr []byte - } // Create GUI, but doesn't start it @@ -64,10 +63,16 @@ func New(ethereum *eth.Ethereum) *Gui { panic(err) } - key := ethutil.Config.Db.GetKeys()[0] - addr := key.Address() + data, _ := ethutil.Config.Db.Get([]byte("KeyRing")) + // On first run we won't have any keys yet, so this would crash. + // Therefor we check if we are ready to actually start this process + var addr []byte + if len(data) > 0 { + key := ethutil.Config.Db.GetKeys()[0] + addr = key.Address() - ethereum.StateManager().WatchAddr(addr) + ethereum.StateManager().WatchAddr(addr) + } return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr} } @@ -94,9 +99,18 @@ func (ui *Gui) Start(assetPath string) { context.SetVar("ui", uiLib) // Load the main QML interface - component, err := ui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml")) + data, _ := ethutil.Config.Db.Get([]byte("KeyRing")) + var err error + var component qml.Object + firstRun := len(data) == 0 + + if firstRun { + component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/first_run.qml")) + } else { + component, err = ui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml")) + } if err != nil { - ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") + ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") panic(err) } ui.engine.LoadFile(uiLib.AssetPath("qml/transactions.qml")) @@ -111,9 +125,11 @@ func (ui *Gui) Start(assetPath string) { ethutil.Config.Log.AddLogSystem(ui) // Loads previous blocks - go ui.setInitialBlockChain() - go ui.readPreviousTransactions() - go ui.update() + if firstRun == false { + go ui.setInitialBlockChain() + go ui.readPreviousTransactions() + go ui.update() + } ui.win.Show() ui.win.Wait() diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 9a7469426..b8ecf3b14 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -5,7 +5,9 @@ import ( "fmt" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" + "github.com/ethereum/go-ethereum/utils" "github.com/obscuren/mutan" + "github.com/obscuren/secp256k1-go" "strings" ) @@ -15,6 +17,32 @@ type EthLib struct { txPool *ethchain.TxPool } +func (lib *EthLib) ImportAndSetPrivKey(privKey string) bool { + fmt.Println(privKey) + mnemonic := strings.Split(privKey, " ") + if len(mnemonic) == 24 { + fmt.Println("Got mnemonic key, importing.") + key := ethutil.MnemonicDecode(mnemonic) + utils.ImportPrivateKey(key) + } else if len(mnemonic) == 1 { + fmt.Println("Got hex key, importing.") + utils.ImportPrivateKey(privKey) + } else { + fmt.Println("Did not recognise format, exiting.") + return false + } + return true +} + +func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { + pub, prv := secp256k1.GenerateKeyPair() + pair := ðutil.Key{PrivateKey: prv, PublicKey: pub} + ethutil.Config.Db.Put([]byte("KeyRing"), pair.RlpEncode()) + mne := ethutil.MnemonicEncode(ethutil.Hex(prv)) + mnemonicString := strings.Join(mne, " ") + return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub) +} + func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { var hash []byte var contractCreation bool -- cgit v1.2.3 From 3238894a3ba4767773849eabb7c0892554d32874 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 11 Apr 2014 12:50:31 -0400 Subject: Added wip debugger --- ethereal/ui/gui.go | 4 ++-- ethereal/ui/library.go | 37 +---------------------------- ethereal/ui/ui_lib.go | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 66 insertions(+), 38 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 89736ac29..32e7edbdc 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -53,7 +53,6 @@ type Gui struct { txDb *ethdb.LDBDatabase addr []byte - } // Create GUI, but doesn't start it @@ -96,12 +95,13 @@ func (ui *Gui) Start(assetPath string) { // Load the main QML interface component, err := ui.engine.LoadFile(uiLib.AssetPath("qml/wallet.qml")) if err != nil { - ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") + ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") panic(err) } ui.engine.LoadFile(uiLib.AssetPath("qml/transactions.qml")) ui.win = component.CreateWindow(nil) + uiLib.win = ui.win // Register the ui as a block processor //ui.eth.BlockManager.SecondaryBlockProcessor = ui diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 9a7469426..13400a2a0 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -43,7 +43,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin code := ethutil.Assemble(asm...) tx = ethchain.NewContractCreationTx(value, gasPrice, code) } else { - tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, []string{}) + tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, nil) } acc := lib.stateManager.GetAddrState(keyPair.Address()) tx.Nonce = acc.Nonce @@ -60,41 +60,6 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin return ethutil.Hex(tx.Hash()), nil } -/* -func (lib *EthLib) CreateTx(receiver, a, data string) string { - var hash []byte - if len(receiver) == 0 { - hash = ethchain.ContractAddr - } else { - var err error - hash, err = hex.DecodeString(receiver) - if err != nil { - return err.Error() - } - } - - k, _ := ethutil.Config.Db.Get([]byte("KeyRing")) - keyPair := ethutil.NewKeyFromBytes(k) - - amount := ethutil.Big(a) - code := ethchain.Compile(strings.Split(data, "\n")) - tx := ethchain.NewTx(hash, amount, code) - tx.Nonce = lib.stateManager.GetAddrState(keyPair.Address()).Nonce - - tx.Sign(keyPair.PrivateKey) - - lib.txPool.QueueTransaction(tx) - - if len(receiver) == 0 { - 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()) -} -*/ - func (lib *EthLib) GetBlock(hexHash string) *Block { hash, err := hex.DecodeString(hexHash) if err != nil { diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 5c3c98fb9..adba177d0 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -2,13 +2,18 @@ package ethui import ( "bitbucket.org/kardianos/osext" + "fmt" "github.com/ethereum/eth-go" + "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" "github.com/niemeyer/qml" + "github.com/obscuren/mutan" + "math/big" "os" "path" "path/filepath" "runtime" + "strings" ) // UI Library that has some basic functionality exposed @@ -17,6 +22,8 @@ type UiLib struct { eth *eth.Ethereum connected bool assetPath string + // The main application window + win *qml.Window } func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib { @@ -81,3 +88,59 @@ func DefaultAssetPath() string { return base } + +type memAddr struct { + Num string + Value string +} + +func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { + state := ui.eth.BlockChain().CurrentBlock.State() + + asm, err := mutan.Compile(strings.NewReader(data), false) + if err != nil { + fmt.Println(err) + } + + callerScript := ethutil.Assemble(asm...) + dis := ethchain.Disassemble(callerScript) + ui.win.Root().Call("clearAsm") + for _, str := range dis { + ui.win.Root().Call("setAsm", str) + } + callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasPriceStr), callerScript) + + // Contract addr as test address + keyPair := ethutil.Config.Db.GetKeys()[0] + account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Account + c := ethchain.MakeContract(callerTx, state) + callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), new(big.Int)) + + block := ui.eth.BlockChain().CurrentBlock + vm := ethchain.NewVm(state, ethchain.RuntimeVars{ + Origin: account.Address(), + BlockNumber: block.BlockInfo().Number, + PrevHash: block.PrevHash, + Coinbase: block.Coinbase, + Time: block.Time, + Diff: block.Difficulty, + TxData: nil, + }) + callerClosure.Call(vm, nil, func(op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack) { + ui.win.Root().Call("clearMem") + ui.win.Root().Call("clearStack") + + addr := 0 + for i := 0; i+32 <= mem.Len(); i += 32 { + ui.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])}) + addr++ + } + + for _, val := range stack.Data() { + ui.win.Root().Call("setStack", val.String()) + } + }) + state.Reset() + + return "", nil +} -- cgit v1.2.3 From cf1ae41bc0bedeb5208dc00696c538c13f2183c6 Mon Sep 17 00:00:00 2001 From: Maran Date: Fri, 11 Apr 2014 13:26:14 -0400 Subject: Improved (hopefully) the send transaction tab --- ethereal/ui/library.go | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index b8ecf3b14..d4800bf1d 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -63,15 +63,21 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin var tx *ethchain.Transaction // Compile and assemble the given data if contractCreation { - asm, err := mutan.Compile(strings.NewReader(data), false) - if err != nil { - return "", err + asm, errors := mutan.Compile(strings.NewReader(data), false) + if len(errors) > 0 { + var errs string + for _, er := range errors { + if er != nil { + errs += er.Error() + } + } + return "", fmt.Errorf(errs) } code := ethutil.Assemble(asm...) tx = ethchain.NewContractCreationTx(value, gasPrice, code) } else { - tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, []string{}) + tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, nil) } acc := lib.stateManager.GetAddrState(keyPair.Address()) tx.Nonce = acc.Nonce -- cgit v1.2.3 From a9a65859134b93cfe2818fdad290530822d6a7b4 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 11 Apr 2014 13:36:25 -0400 Subject: Debugger --- ethereal/ui/ui_lib.go | 56 ++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 16 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index adba177d0..fde2697b8 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -94,7 +94,40 @@ type memAddr struct { Value string } -func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { +type Debugger struct { + ui *UiLib + next chan bool +} + +func (d *Debugger) halting(op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack) { + d.ui.win.Root().Call("clearMem") + d.ui.win.Root().Call("clearStack") + + addr := 0 + for i := 0; i+32 <= mem.Len(); i += 32 { + d.ui.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])}) + addr++ + } + + for _, val := range stack.Data() { + d.ui.win.Root().Call("setStack", val.String()) + } + +out: + for { + select { + case <-d.next: + break out + default: + } + } +} + +func (d *Debugger) Next() { + d.next <- true +} + +func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) { state := ui.eth.BlockChain().CurrentBlock.State() asm, err := mutan.Compile(strings.NewReader(data), false) @@ -126,21 +159,12 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) Diff: block.Difficulty, TxData: nil, }) - callerClosure.Call(vm, nil, func(op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack) { - ui.win.Root().Call("clearMem") - ui.win.Root().Call("clearStack") - - addr := 0 - for i := 0; i+32 <= mem.Len(); i += 32 { - ui.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])}) - addr++ - } - for _, val := range stack.Data() { - ui.win.Root().Call("setStack", val.String()) - } - }) - state.Reset() + db := &Debugger{ui, make(chan bool)} + ui.engine.Context().SetVar("db", db) + go func() { + callerClosure.Call(vm, nil, db.halting) - return "", nil + state.Reset() + }() } -- cgit v1.2.3 From ab8d96258ea11c828a149dde176fe8e2efce0294 Mon Sep 17 00:00:00 2001 From: Maran Date: Fri, 11 Apr 2014 17:05:02 -0400 Subject: Added isContract to gui --- ethereal/ui/gui.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index fa4a5c833..c09c5954f 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -21,13 +21,15 @@ type Block struct { type Tx struct { Value, Hash, Address string + Contract bool } func NewTxFromTransaction(tx *ethchain.Transaction) *Tx { hash := hex.EncodeToString(tx.Hash()) sender := hex.EncodeToString(tx.Recipient) + isContract := len(tx.Data) > 0 - return &Tx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender} + return &Tx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender, Contract: isContract} } // Creates a new QML Block from a chain block -- cgit v1.2.3 From ce43a9500f38bae426eef6c3c9d33e006c32c26d Mon Sep 17 00:00:00 2001 From: obscuren Date: Sat, 12 Apr 2014 00:12:10 -0400 Subject: Debug steps --- ethereal/ui/gui.go | 4 ++- ethereal/ui/library.go | 1 + ethereal/ui/ui_lib.go | 89 ++++++++++++++++++++++++++------------------------ 3 files changed, 51 insertions(+), 43 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index fa4a5c833..d6510bbb6 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -113,10 +113,12 @@ func (ui *Gui) Start(assetPath string) { ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") panic(err) } - ui.engine.LoadFile(uiLib.AssetPath("qml/transactions.qml")) ui.win = component.CreateWindow(nil) uiLib.win = ui.win + db := &Debugger{ui.win, make(chan bool)} + ui.lib.Db = db + uiLib.Db = db // Register the ui as a block processor //ui.eth.BlockManager.SecondaryBlockProcessor = ui diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 08f99e7db..42aebcd87 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -15,6 +15,7 @@ type EthLib struct { stateManager *ethchain.StateManager blockChain *ethchain.BlockChain txPool *ethchain.TxPool + Db *Debugger } func (lib *EthLib) ImportAndSetPrivKey(privKey string) bool { diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index fde2697b8..86855290f 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -16,6 +16,11 @@ import ( "strings" ) +type memAddr struct { + Num string + Value string +} + // UI Library that has some basic functionality exposed type UiLib struct { engine *qml.Engine @@ -24,6 +29,7 @@ type UiLib struct { assetPath string // The main application window win *qml.Window + Db *Debugger } func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib { @@ -89,48 +95,11 @@ func DefaultAssetPath() string { return base } -type memAddr struct { - Num string - Value string -} - -type Debugger struct { - ui *UiLib - next chan bool -} - -func (d *Debugger) halting(op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack) { - d.ui.win.Root().Call("clearMem") - d.ui.win.Root().Call("clearStack") - - addr := 0 - for i := 0; i+32 <= mem.Len(); i += 32 { - d.ui.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])}) - addr++ - } - - for _, val := range stack.Data() { - d.ui.win.Root().Call("setStack", val.String()) - } - -out: - for { - select { - case <-d.next: - break out - default: - } - } -} - -func (d *Debugger) Next() { - d.next <- true -} - func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) { state := ui.eth.BlockChain().CurrentBlock.State() - asm, err := mutan.Compile(strings.NewReader(data), false) + mainInput, _ := ethutil.PreProcess(data) + asm, err := mutan.Compile(strings.NewReader(mainInput), false) if err != nil { fmt.Println(err) } @@ -160,11 +129,47 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) TxData: nil, }) - db := &Debugger{ui, make(chan bool)} - ui.engine.Context().SetVar("db", db) go func() { - callerClosure.Call(vm, nil, db.halting) + callerClosure.Call(vm, nil, ui.Db.halting) state.Reset() }() } + +func (ui *UiLib) Next() { + ui.Db.Next() +} + +type Debugger struct { + win *qml.Window + N chan bool +} + +func (d *Debugger) halting(pc int, op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack) { + d.win.Root().Call("setInstruction", pc) + d.win.Root().Call("clearMem") + d.win.Root().Call("clearStack") + + addr := 0 + for i := 0; i+32 <= mem.Len(); i += 32 { + d.win.Root().Call("setMem", memAddr{fmt.Sprintf("%03d", addr), fmt.Sprintf("% x", mem.Data()[i:i+32])}) + addr++ + } + + for _, val := range stack.Data() { + d.win.Root().Call("setStack", val.String()) + } + +out: + for { + select { + case <-d.N: + break out + default: + } + } +} + +func (d *Debugger) Next() { + d.N <- true +} -- cgit v1.2.3 From 91c75c9305e7554c21e84ed1a07ec0e750bb775a Mon Sep 17 00:00:00 2001 From: Maran Date: Mon, 14 Apr 2014 17:08:15 -0400 Subject: Adding log messages to debug panel --- ethereal/ui/ui_lib.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 86855290f..b2552cdce 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -102,6 +102,9 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) asm, err := mutan.Compile(strings.NewReader(mainInput), false) if err != nil { fmt.Println(err) + for _, e := range err { + ui.win.Root().Call("addDebugMessage", e.Error()) + } } callerScript := ethutil.Assemble(asm...) -- cgit v1.2.3 From 7cb065489c3d664f5924afad4f72e2a0a3a5c800 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 15 Apr 2014 16:13:04 -0400 Subject: added init and main functions to script --- ethereal/ui/library.go | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 42aebcd87..76032f400 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -44,6 +44,22 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub) } +// General compiler and preprocessor function +func compile(script string) ([]byte, error) { + asm, errors := mutan.Compile(strings.NewReader(script), false) + if len(errors) > 0 { + var errs string + for _, er := range errors { + if er != nil { + errs += er.Error() + } + } + return nil, fmt.Errorf("%v", errs) + } + + return ethutil.Assemble(asm...), nil +} + func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { var hash []byte var contractCreation bool @@ -64,19 +80,19 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin var tx *ethchain.Transaction // Compile and assemble the given data if contractCreation { - asm, errors := mutan.Compile(strings.NewReader(data), false) - if len(errors) > 0 { - var errs string - for _, er := range errors { - if er != nil { - errs += er.Error() - } - } - return "", fmt.Errorf(errs) + mainInput, initInput := ethutil.PreProcess(data) + mainScript, err := compile(mainInput) + if err != nil { + return "", err + } + initScript, err := compile(initInput) + if err != nil { + return "", err } - code := ethutil.Assemble(asm...) - tx = ethchain.NewContractCreationTx(value, gasPrice, code) + // TODO + fmt.Println(initScript) + tx = ethchain.NewContractCreationTx(value, gasPrice, mainScript) } else { tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, nil) } -- cgit v1.2.3 From 1cd7d4456b80c38f343cb54a624408c28c5acb13 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 16 Apr 2014 04:08:25 +0200 Subject: Updated to use new state object --- ethereal/ui/gui.go | 2 +- ethereal/ui/library.go | 25 +++---------------------- ethereal/ui/ui_lib.go | 18 ++++++++---------- 3 files changed, 12 insertions(+), 33 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 1065b716e..fd29c4820 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -170,7 +170,7 @@ func (ui *Gui) update() { txChan := make(chan ethchain.TxMsg, 1) ui.eth.TxPool().Subscribe(txChan) - account := ui.eth.StateManager().GetAddrState(ui.addr).Account + account := ui.eth.StateManager().GetAddrState(ui.addr).Object unconfirmedFunds := new(big.Int) ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(account.Amount))) for { diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 76032f400..6c6f7557a 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -6,7 +6,6 @@ import ( "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" "github.com/ethereum/go-ethereum/utils" - "github.com/obscuren/mutan" "github.com/obscuren/secp256k1-go" "strings" ) @@ -44,22 +43,6 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub) } -// General compiler and preprocessor function -func compile(script string) ([]byte, error) { - asm, errors := mutan.Compile(strings.NewReader(script), false) - if len(errors) > 0 { - var errs string - for _, er := range errors { - if er != nil { - errs += er.Error() - } - } - return nil, fmt.Errorf("%v", errs) - } - - return ethutil.Assemble(asm...), nil -} - func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { var hash []byte var contractCreation bool @@ -81,18 +64,16 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin // Compile and assemble the given data if contractCreation { mainInput, initInput := ethutil.PreProcess(data) - mainScript, err := compile(mainInput) + mainScript, err := utils.Compile(mainInput) if err != nil { return "", err } - initScript, err := compile(initInput) + initScript, err := utils.Compile(initInput) if err != nil { return "", err } - // TODO - fmt.Println(initScript) - tx = ethchain.NewContractCreationTx(value, gasPrice, mainScript) + tx = ethchain.NewContractCreationTx(value, gasPrice, mainScript, initScript) } else { tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, nil) } diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index b2552cdce..a0d2f557a 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -6,14 +6,13 @@ 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/niemeyer/qml" - "github.com/obscuren/mutan" "math/big" "os" "path" "path/filepath" "runtime" - "strings" ) type memAddr struct { @@ -99,25 +98,24 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) state := ui.eth.BlockChain().CurrentBlock.State() mainInput, _ := ethutil.PreProcess(data) - asm, err := mutan.Compile(strings.NewReader(mainInput), false) + callerScript, err := utils.Compile(mainInput) if err != nil { - fmt.Println(err) - for _, e := range err { - ui.win.Root().Call("addDebugMessage", e.Error()) - } + ethutil.Config.Log.Debugln(err) + + return } - callerScript := ethutil.Assemble(asm...) dis := ethchain.Disassemble(callerScript) ui.win.Root().Call("clearAsm") + for _, str := range dis { ui.win.Root().Call("setAsm", str) } - callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasPriceStr), callerScript) + callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasPriceStr), callerScript, nil) // Contract addr as test address keyPair := ethutil.Config.Db.GetKeys()[0] - account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Account + account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Object c := ethchain.MakeContract(callerTx, state) callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), new(big.Int)) -- cgit v1.2.3 From a0c97b663dcb8de940c17479877e3165834f0c8a Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 20 Apr 2014 02:05:20 +0200 Subject: Updated closure call --- ethereal/ui/ui_lib.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index a0d2f557a..95743fa5d 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -8,7 +8,6 @@ import ( "github.com/ethereum/eth-go/ethutil" "github.com/ethereum/go-ethereum/utils" "github.com/niemeyer/qml" - "math/big" "os" "path" "path/filepath" @@ -117,7 +116,7 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) keyPair := ethutil.Config.Db.GetKeys()[0] account := ui.eth.StateManager().GetAddrState(keyPair.Address()).Object c := ethchain.MakeContract(callerTx, state) - callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), new(big.Int)) + callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), ethutil.Big(gasPriceStr), ethutil.Big(valueStr)) block := ui.eth.BlockChain().CurrentBlock vm := ethchain.NewVm(state, ethchain.RuntimeVars{ -- cgit v1.2.3 From 6d5d539a859cae43a1e97acd6fc5675d45b09063 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 21 Apr 2014 00:57:57 +0200 Subject: Round one HTML external applications using QML(Qt5) WebKit2 w/o native bindings --- ethereal/ui/ui_lib.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 95743fa5d..096af16db 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -51,6 +51,22 @@ func (ui *UiLib) Open(path string) { }() } +func (ui *UiLib) OpenHtml(path string) { + component, err := ui.engine.LoadFile(ui.AssetPath("qml/webapp.qml")) + if err != nil { + ethutil.Config.Log.Debugln(err) + + return + } + win := component.CreateWindow(nil) + win.Set("url", path) + + go func() { + win.Show() + win.Wait() + }() +} + func (ui *UiLib) Connect(button qml.Object) { if !ui.connected { ui.eth.Start() -- cgit v1.2.3 From b962779a1318138e08c6e84a537fdbc6c9ebfd97 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 23 Apr 2014 11:51:48 +0200 Subject: Minor update and fixes to the gui and console --- ethereal/ui/gui.go | 1 + ethereal/ui/library.go | 9 ++++++--- ethereal/ui/ui_lib.go | 10 +++++++++- 3 files changed, 16 insertions(+), 4 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index fd29c4820..0e5d57c93 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -113,6 +113,7 @@ func (ui *Gui) Start(assetPath string) { } if err != nil { ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'") + panic(err) } diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 6c6f7557a..b097ddbb2 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -44,6 +44,7 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { } func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { + fmt.Println("Create tx") var hash []byte var contractCreation bool if len(recipient) == 0 { @@ -64,18 +65,21 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin // Compile and assemble the given data if contractCreation { mainInput, initInput := ethutil.PreProcess(data) + fmt.Println("Precompile done") + fmt.Println("main", mainInput) mainScript, err := utils.Compile(mainInput) if err != nil { return "", err } + fmt.Println("init", initInput) initScript, err := utils.Compile(initInput) if err != nil { return "", err } - tx = ethchain.NewContractCreationTx(value, gasPrice, mainScript, initScript) + tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript) } else { - tx = ethchain.NewTransactionMessage(hash, value, gasPrice, gas, nil) + tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, nil) } acc := lib.stateManager.GetAddrState(keyPair.Address()) tx.Nonce = acc.Nonce @@ -99,7 +103,6 @@ func (lib *EthLib) GetBlock(hexHash string) *Block { } block := lib.blockChain.GetBlock(hash) - fmt.Println(block) return &Block{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} } diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 096af16db..09f81c67e 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -59,6 +59,14 @@ func (ui *UiLib) OpenHtml(path string) { return } win := component.CreateWindow(nil) + if filepath.Ext(path) == "eth" { + fmt.Println("Ethereum package not yet supported") + + return + + // TODO + ethutil.OpenPackage(path) + } win.Set("url", path) go func() { @@ -126,7 +134,7 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) for _, str := range dis { ui.win.Root().Call("setAsm", str) } - callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasPriceStr), callerScript, nil) + callerTx := ethchain.NewContractCreationTx(ethutil.Big(valueStr), ethutil.Big(gasStr), ethutil.Big(gasPriceStr), callerScript, nil) // Contract addr as test address keyPair := ethutil.Config.Db.GetKeys()[0] -- cgit v1.2.3 From 43f1214f97e52863b1f1ef7913991bef3d00c58e Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 23 Apr 2014 15:54:34 +0200 Subject: Refactored code --- ethereal/ui/library.go | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index b097ddbb2..537cfa994 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -43,8 +43,7 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub) } -func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data string) (string, error) { - fmt.Println("Create tx") +func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { var hash []byte var contractCreation bool if len(recipient) == 0 { @@ -64,26 +63,24 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, data strin var tx *ethchain.Transaction // Compile and assemble the given data if contractCreation { - mainInput, initInput := ethutil.PreProcess(data) - fmt.Println("Precompile done") - fmt.Println("main", mainInput) - mainScript, err := utils.Compile(mainInput) - if err != nil { - return "", err - } - fmt.Println("init", initInput) - initScript, err := utils.Compile(initInput) + // Compile script + mainScript, initScript, err := utils.CompileScript(dataStr) if err != nil { return "", err } tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript) } else { - tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, nil) + 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 - //acc.Nonce++ tx.Sign(keyPair.PrivateKey) lib.txPool.QueueTransaction(tx) -- cgit v1.2.3 From bb72347acf8a82d1c20e8aae25c84e5dc75903dd Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 24 Apr 2014 00:01:22 +0200 Subject: Minor fixes and sample coin "improvements" --- ethereal/ui/gui.go | 14 +++++++++++++- ethereal/ui/library.go | 24 ++++++++++++++++++++++++ ethereal/ui/ui_lib.go | 2 +- 3 files changed, 38 insertions(+), 2 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 0e5d57c93..80498d718 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -8,7 +8,7 @@ import ( "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethdb" "github.com/ethereum/eth-go/ethutil" - "github.com/niemeyer/qml" + "github.com/go-qml/qml" "math/big" "strings" ) @@ -24,6 +24,18 @@ type Tx struct { Contract bool } +type Key struct { + Address string +} + +type KeyRing struct { + Keys []interface{} +} + +func NewKeyRing(keys []interface{}) *KeyRing { + return &KeyRing{Keys: keys} +} + func NewTxFromTransaction(tx *ethchain.Transaction) *Tx { hash := hex.EncodeToString(tx.Hash()) sender := hex.EncodeToString(tx.Recipient) diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 537cfa994..5ca2b4273 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -10,6 +10,20 @@ 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 { + val := c.object.GetMem(ethutil.Big("0x" + address)) + + return val.BigInt().String() +} + type EthLib struct { stateManager *ethchain.StateManager blockChain *ethchain.BlockChain @@ -43,6 +57,16 @@ func (lib *EthLib) CreateAndSetPrivKey() (string, string, string, string) { return mnemonicString, fmt.Sprintf("%x", pair.Address()), fmt.Sprintf("%x", prv), fmt.Sprintf("%x", pub) } +func (lib *EthLib) GetKey() string { + return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) +} + +func (lib *EthLib) GetStateObject(address string) *Contract { + stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) + + return NewContract(stateObject) +} + func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { var hash []byte var contractCreation bool diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 09f81c67e..9191e5ea9 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -7,7 +7,7 @@ import ( "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" "github.com/ethereum/go-ethereum/utils" - "github.com/niemeyer/qml" + "github.com/go-qml/qml" "os" "path" "path/filepath" -- cgit v1.2.3 From c535d0d24623caafcab084546f85f1f70cb2ac67 Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 24 Apr 2014 14:42:31 +0200 Subject: Added new block sub for webapp --- ethereal/ui/ui_lib.go | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 9191e5ea9..08e2267a7 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -70,8 +70,34 @@ func (ui *UiLib) OpenHtml(path string) { win.Set("url", path) go func() { + blockChan := make(chan ethutil.React, 1) + quitChan := make(chan bool) + + go func() { + out: + for { + select { + case <-quitChan: + ui.eth.Reactor().Unsubscribe("newBlock", blockChan) + break out + case block := <-blockChan: + if block, ok := block.Resource.(*ethchain.Block); ok { + b := &Block{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + win.ObjectByName("webView").Call("onNewBlockCb", b) + } + } + } + + // Clean up + close(blockChan) + close(quitChan) + }() + ui.eth.Reactor().Subscribe("newBlock", blockChan) + win.Show() win.Wait() + + quitChan <- true }() } -- cgit v1.2.3 From e16fd323e800297602a60b7a0e7b7897a55d2fa0 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sat, 26 Apr 2014 01:47:04 +0200 Subject: Leverage the new watch & address:changed functionality --- ethereal/ui/gui.go | 52 ++++++---------------------------------------- ethereal/ui/library.go | 8 ++++++-- ethereal/ui/types.go | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++ ethereal/ui/ui_lib.go | 13 +++++++++--- 4 files changed, 78 insertions(+), 51 deletions(-) create mode 100644 ethereal/ui/types.go (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 80498d718..d3a179496 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -2,7 +2,6 @@ package ethui import ( "bytes" - "encoding/hex" "fmt" "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethchain" @@ -13,45 +12,6 @@ import ( "strings" ) -// Block interface exposed to QML -type Block struct { - Number int - Hash string -} - -type Tx struct { - Value, Hash, Address string - Contract bool -} - -type Key struct { - Address string -} - -type KeyRing struct { - Keys []interface{} -} - -func NewKeyRing(keys []interface{}) *KeyRing { - return &KeyRing{Keys: keys} -} - -func NewTxFromTransaction(tx *ethchain.Transaction) *Tx { - hash := hex.EncodeToString(tx.Hash()) - sender := hex.EncodeToString(tx.Recipient) - isContract := len(tx.Data) > 0 - - return &Tx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender, Contract: isContract} -} - -// Creates a new QML Block from a chain block -func NewBlockFromBlock(block *ethchain.Block) *Block { - info := block.BlockInfo() - hash := hex.EncodeToString(block.Hash()) - - return &Block{Number: int(info.Number), Hash: hash} -} - type Gui struct { // The main application window win *qml.Window @@ -96,9 +56,9 @@ func (ui *Gui) Start(assetPath string) { // Register ethereum functions qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{ - Init: func(p *Block, obj qml.Object) { p.Number = 0; p.Hash = "" }, + Init: func(p *QBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, }, { - Init: func(p *Tx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, + Init: func(p *QTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, }}) ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.1")) @@ -169,13 +129,13 @@ func (ui *Gui) readPreviousTransactions() { for it.Next() { tx := ethchain.NewTransactionFromBytes(it.Value()) - ui.win.Root().Call("addTx", NewTxFromTransaction(tx)) + ui.win.Root().Call("addTx", NewQTx(tx)) } it.Release() } func (ui *Gui) ProcessBlock(block *ethchain.Block) { - ui.win.Root().Call("addBlock", NewBlockFromBlock(block)) + ui.win.Root().Call("addBlock", NewQBlock(block)) } // Simple go routine function that updates the list of peers in the GUI @@ -193,13 +153,13 @@ func (ui *Gui) update() { if txMsg.Type == ethchain.TxPre { if bytes.Compare(tx.Sender(), ui.addr) == 0 { - ui.win.Root().Call("addTx", NewTxFromTransaction(tx)) + ui.win.Root().Call("addTx", NewQTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) ui.eth.StateManager().GetAddrState(ui.addr).Nonce += 1 unconfirmedFunds.Sub(unconfirmedFunds, tx.Value) } else if bytes.Compare(tx.Recipient, ui.addr) == 0 { - ui.win.Root().Call("addTx", NewTxFromTransaction(tx)) + ui.win.Root().Call("addTx", NewQTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) unconfirmedFunds.Add(unconfirmedFunds, tx.Value) diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 5ca2b4273..7f667f2c1 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -67,6 +67,10 @@ func (lib *EthLib) GetStateObject(address string) *Contract { return NewContract(stateObject) } +func (lib *EthLib) Watch(addr string) { + lib.stateManager.Watch(ethutil.FromHex(addr)) +} + func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { var hash []byte var contractCreation bool @@ -117,7 +121,7 @@ func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr st return ethutil.Hex(tx.Hash()), nil } -func (lib *EthLib) GetBlock(hexHash string) *Block { +func (lib *EthLib) GetBlock(hexHash string) *QBlock { hash, err := hex.DecodeString(hexHash) if err != nil { return nil @@ -125,5 +129,5 @@ func (lib *EthLib) GetBlock(hexHash string) *Block { block := lib.blockChain.GetBlock(hash) - return &Block{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + return &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} } diff --git a/ethereal/ui/types.go b/ethereal/ui/types.go new file mode 100644 index 000000000..5c39f0217 --- /dev/null +++ b/ethereal/ui/types.go @@ -0,0 +1,56 @@ +package ethui + +import ( + "encoding/hex" + "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethutil" +) + +// Block interface exposed to QML +type QBlock struct { + Number int + Hash string +} + +// Creates a new QML Block from a chain block +func NewQBlock(block *ethchain.Block) *QBlock { + info := block.BlockInfo() + hash := hex.EncodeToString(block.Hash()) + + return &QBlock{Number: int(info.Number), Hash: hash} +} + +type QTx struct { + Value, Hash, Address string + Contract bool +} + +func NewQTx(tx *ethchain.Transaction) *QTx { + 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} +} + +type QKey struct { + Address string +} + +type QKeyRing struct { + Keys []interface{} +} + +func NewQKeyRing(keys []interface{}) *QKeyRing { + return &QKeyRing{Keys: keys} +} + +type QStateObject struct { + Address string + Amount string + Nonce int +} + +func NewQStateObject(stateObject *ethchain.StateObject) *QStateObject { + return &QStateObject{ethutil.Hex(stateObject.Address()), stateObject.Amount.String(), int(stateObject.Nonce)} +} diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 08e2267a7..6217c0065 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -69,8 +69,10 @@ func (ui *UiLib) OpenHtml(path string) { } win.Set("url", path) + webView := win.ObjectByName("webView") go func() { blockChan := make(chan ethutil.React, 1) + addrChan := make(chan ethutil.React, 1) quitChan := make(chan bool) go func() { @@ -82,8 +84,12 @@ func (ui *UiLib) OpenHtml(path string) { break out case block := <-blockChan: if block, ok := block.Resource.(*ethchain.Block); ok { - b := &Block{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} - win.ObjectByName("webView").Call("onNewBlockCb", b) + b := &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + webView.Call("onNewBlockCb", b) + } + case stateObject := <-addrChan: + if stateObject, ok := stateObject.Resource.(*ethchain.StateObject); ok { + webView.Call("onObjectChangeCb", NewQStateObject(stateObject)) } } } @@ -93,6 +99,7 @@ func (ui *UiLib) OpenHtml(path string) { close(quitChan) }() ui.eth.Reactor().Subscribe("newBlock", blockChan) + ui.eth.Reactor().Subscribe("addressChanged", addrChan) win.Show() win.Wait() @@ -169,7 +176,7 @@ func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) callerClosure := ethchain.NewClosure(account, c, c.Script(), state, ethutil.Big(gasStr), ethutil.Big(gasPriceStr), ethutil.Big(valueStr)) block := ui.eth.BlockChain().CurrentBlock - vm := ethchain.NewVm(state, ethchain.RuntimeVars{ + vm := ethchain.NewVm(state, ui.eth.StateManager(), ethchain.RuntimeVars{ Origin: account.Address(), BlockNumber: block.BlockInfo().Number, PrevHash: block.PrevHash, -- cgit v1.2.3 From 0e8ca84b67465c0211a0cb46fc7bb6b9c4988dfd Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 27 Apr 2014 16:52:48 +0200 Subject: Updated version number --- ethereal/ui/gui.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index d3a179496..8ec09459b 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -61,7 +61,7 @@ func (ui *Gui) Start(assetPath string) { Init: func(p *QTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, }}) - ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.1")) + ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.2")) ethutil.Config.Log.Infoln("[GUI] Starting GUI") // Create a new QML engine ui.engine = qml.NewEngine() -- cgit v1.2.3 From 68e5568804cc99d217e7a3aaca796406e428f221 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 28 Apr 2014 00:25:01 +0200 Subject: Draft mut(an)ed(itor) --- ethereal/ui/ui_lib.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 6217c0065..309ab7928 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -108,6 +108,25 @@ func (ui *UiLib) OpenHtml(path string) { }() } +func (ui *UiLib) Muted(content string) { + component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml")) + if err != nil { + ethutil.Config.Log.Debugln(err) + + return + } + win := component.CreateWindow(nil) + go func() { + path := "file://" + ui.AssetPath("muted/index.html") + win.Set("url", path) + debuggerPath := "file://" + ui.AssetPath("muted/debugger.html") + win.Set("debugUrl", debuggerPath) + + win.Show() + win.Wait() + }() +} + func (ui *UiLib) Connect(button qml.Object) { if !ui.connected { ui.eth.Start() -- cgit v1.2.3 From a0f35d324822fc66951f8a33526ff3d15b0de09d Mon Sep 17 00:00:00 2001 From: Casey Kuhlman Date: Mon, 28 Apr 2014 11:37:44 +0200 Subject: PreProcess moved to Mutan package --- ethereal/ui/ui_lib.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 309ab7928..a9bde74b0 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -6,6 +6,7 @@ import ( "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" + "github.com/obscuren/mutan" "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "os" @@ -172,7 +173,7 @@ func DefaultAssetPath() string { func (ui *UiLib) DebugTx(recipient, valueStr, gasStr, gasPriceStr, data string) { state := ui.eth.BlockChain().CurrentBlock.State() - mainInput, _ := ethutil.PreProcess(data) + mainInput, _ := mutan.PreProcess(data) callerScript, err := utils.Compile(mainInput) if err != nil { ethutil.Config.Log.Debugln(err) -- cgit v1.2.3 From 922974c760278b6d49cb6f286b663d60f77d5248 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 28 Apr 2014 23:24:42 +0200 Subject: Added muted --- ethereal/ui/ui_lib.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index a9bde74b0..07cd0ac8a 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -120,8 +120,8 @@ func (ui *UiLib) Muted(content string) { go func() { path := "file://" + ui.AssetPath("muted/index.html") win.Set("url", path) - debuggerPath := "file://" + ui.AssetPath("muted/debugger.html") - win.Set("debugUrl", debuggerPath) + //debuggerPath := "file://" + ui.AssetPath("muted/debugger.html") + //win.Set("debugUrl", debuggerPath) win.Show() win.Wait() -- cgit v1.2.3 From 64c2550b3154df7f2c75dda559d91046cb559ffd Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 30 Apr 2014 01:44:02 +0200 Subject: Split off External applications from main library External applications now accept containers which function as the frontend where the ExtApplication functions as the backend. Containers execute within their own engine and have their own context and are destroyed when released. --- ethereal/ui/ext_app.go | 175 ++++++++++++++++++++++++++++++++++++++++++ ethereal/ui/html_container.go | 73 ++++++++++++++++++ ethereal/ui/library.go | 33 ++++++-- ethereal/ui/ui_lib.go | 62 +++------------ 4 files changed, 286 insertions(+), 57 deletions(-) create mode 100644 ethereal/ui/ext_app.go create mode 100644 ethereal/ui/html_container.go (limited to 'ethereal/ui') diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go new file mode 100644 index 000000000..b90a2192c --- /dev/null +++ b/ethereal/ui/ext_app.go @@ -0,0 +1,175 @@ +package ethui + +import ( + "fmt" + "github.com/ethereum/eth-go" + "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethutil" + "github.com/go-qml/qml" + "math/big" +) + +type AppContainer interface { + Create() error + Destroy() + + Window() *qml.Window + Engine() *qml.Engine + + NewBlock(*ethchain.Block) + ObjectChanged(*ethchain.StateObject) + StorageChanged(*ethchain.StateObject, []byte, *big.Int) +} + +type ExtApplication struct { + *QEthereum + + blockChan chan ethutil.React + changeChan chan ethutil.React + quitChan chan bool + + container AppContainer + lib *UiLib + registeredEvents []string +} + +func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { + app := &ExtApplication{ + NewQEthereum(lib.eth), + make(chan ethutil.React, 1), + make(chan ethutil.React, 1), + make(chan bool), + container, + lib, + nil, + } + + return app +} + +func (app *ExtApplication) run() { + // Set the "eth" api on to the containers context + context := app.container.Engine().Context() + context.SetVar("eth", app) + context.SetVar("ui", app.lib) + + err := app.container.Create() + if err != nil { + fmt.Println(err) + + return + } + + // Call the main loop + go app.mainLoop() + + // Subscribe to events + reactor := app.lib.eth.Reactor() + reactor.Subscribe("newBlock", app.blockChan) + + win := app.container.Window() + win.Show() + win.Wait() + + app.stop() +} + +func (app *ExtApplication) stop() { + // Clean up + reactor := app.lib.eth.Reactor() + reactor.Unsubscribe("newBlock", app.blockChan) + for _, event := range app.registeredEvents { + reactor.Unsubscribe(event, app.changeChan) + } + + // Kill the main loop + app.quitChan <- true + + close(app.blockChan) + close(app.quitChan) + close(app.changeChan) + + app.container.Destroy() +} + +func (app *ExtApplication) mainLoop() { +out: + for { + select { + case <-app.quitChan: + break out + case block := <-app.blockChan: + if block, ok := block.Resource.(*ethchain.Block); ok { + app.container.NewBlock(block) + } + case object := <-app.changeChan: + if stateObject, ok := object.Resource.(*ethchain.StateObject); ok { + app.container.ObjectChanged(stateObject) + } else if _, ok := object.Resource.(*big.Int); ok { + // + } + } + } + +} + +func (app *ExtApplication) Watch(addr, storageAddr string) { + var event string + if len(storageAddr) == 0 { + event = "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr)) + app.lib.eth.Reactor().Subscribe(event, app.changeChan) + } else { + event = "object:" + string(ethutil.FromHex(addr)) + app.lib.eth.Reactor().Subscribe(event, app.changeChan) + } + + app.registeredEvents = append(app.registeredEvents, event) +} + +type QEthereum struct { + stateManager *ethchain.StateManager + blockChain *ethchain.BlockChain + txPool *ethchain.TxPool +} + +func NewQEthereum(eth *eth.Ethereum) *QEthereum { + return &QEthereum{ + eth.StateManager(), + eth.BlockChain(), + eth.TxPool(), + } +} + +func (lib *QEthereum) GetBlock(hexHash string) *QBlock { + hash := ethutil.FromHex(hexHash) + + block := lib.blockChain.GetBlock(hash) + + return &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} +} + +func (lib *QEthereum) GetKey() string { + return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) +} + +func (lib *QEthereum) GetStateObject(address string) *Contract { + stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) + if stateObject != nil { + return NewContract(stateObject) + } + + // See GetStorage for explanation on "nil" + return NewContract(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) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { + return "", nil +} diff --git a/ethereal/ui/html_container.go b/ethereal/ui/html_container.go new file mode 100644 index 000000000..8e3ef0fc7 --- /dev/null +++ b/ethereal/ui/html_container.go @@ -0,0 +1,73 @@ +package ethui + +import ( + "errors" + "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethutil" + "github.com/go-qml/qml" + "math/big" + "path/filepath" +) + +type HtmlApplication struct { + win *qml.Window + webView qml.Object + engine *qml.Engine + lib *UiLib + path string +} + +func NewHtmlApplication(path string, lib *UiLib) *HtmlApplication { + engine := qml.NewEngine() + + return &HtmlApplication{engine: engine, lib: lib, path: path} + +} + +func (app *HtmlApplication) Create() error { + component, err := app.engine.LoadFile(app.lib.AssetPath("qml/webapp.qml")) + if err != nil { + return err + } + + if filepath.Ext(app.path) == "eth" { + return errors.New("Ethereum package not yet supported") + + // TODO + ethutil.OpenPackage(app.path) + } + + win := component.CreateWindow(nil) + win.Set("url", app.path) + webView := win.ObjectByName("webView") + + app.win = win + app.webView = webView + + return nil +} + +func (app *HtmlApplication) Engine() *qml.Engine { + return app.engine +} + +func (app *HtmlApplication) Window() *qml.Window { + return app.win +} + +func (app *HtmlApplication) NewBlock(block *ethchain.Block) { + b := &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + app.webView.Call("onNewBlockCb", b) +} + +func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) { + app.webView.Call("onObjectChangeCb", NewQStateObject(stateObject)) +} + +func (app *HtmlApplication) StorageChanged(stateObject *ethchain.StateObject, addr []byte, value *big.Int) { + app.webView.Call("onStorageChangeCb", nil) +} + +func (app *HtmlApplication) Destroy() { + app.engine.Destroy() +} diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 7f667f2c1..ec5f29f95 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -19,9 +19,24 @@ func NewContract(object *ethchain.StateObject) *Contract { } func (c *Contract) GetStorage(address string) string { - val := c.object.GetMem(ethutil.Big("0x" + address)) + // 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 val.BigInt().String() + } + + return "" +} + +func (c *Contract) Value() string { + if c.object != nil { + return c.object.Amount.String() + } + + return "" } type EthLib struct { @@ -63,15 +78,23 @@ func (lib *EthLib) GetKey() string { func (lib *EthLib) GetStateObject(address string) *Contract { stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) + if stateObject != nil { + return NewContract(stateObject) + } - return NewContract(stateObject) + // See GetStorage for explanation on "nil" + return NewContract(nil) } -func (lib *EthLib) Watch(addr string) { - lib.stateManager.Watch(ethutil.FromHex(addr)) +func (lib *EthLib) Watch(addr, storageAddr string) { + // lib.stateManager.Watch(ethutil.FromHex(addr), ethutil.FromHex(storageAddr)) } func (lib *EthLib) CreateTx(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { + return lib.Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr) +} + +func (lib *EthLib) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) { var hash []byte var contractCreation bool if len(recipient) == 0 { diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 07cd0ac8a..0feb522bc 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -6,9 +6,9 @@ import ( "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethutil" - "github.com/obscuren/mutan" "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" + "github.com/obscuren/mutan" "os" "path" "path/filepath" @@ -53,60 +53,18 @@ func (ui *UiLib) Open(path string) { } func (ui *UiLib) OpenHtml(path string) { - component, err := ui.engine.LoadFile(ui.AssetPath("qml/webapp.qml")) - if err != nil { - ethutil.Config.Log.Debugln(err) + container := NewHtmlApplication(path, ui) + app := NewExtApplication(container, ui) - return - } - win := component.CreateWindow(nil) - if filepath.Ext(path) == "eth" { - fmt.Println("Ethereum package not yet supported") - - return + go app.run() +} - // TODO - ethutil.OpenPackage(path) +func (ui *UiLib) Watch(addr, storageAddr string) { + if len(storageAddr) == 0 { + ui.eth.Reactor().Subscribe("storage:"+string(ethutil.FromHex(addr))+":"+string(ethutil.FromHex(storageAddr)), nil) + } else { + ui.eth.Reactor().Subscribe("object:"+string(ethutil.FromHex(addr)), nil) } - win.Set("url", path) - - webView := win.ObjectByName("webView") - go func() { - blockChan := make(chan ethutil.React, 1) - addrChan := make(chan ethutil.React, 1) - quitChan := make(chan bool) - - go func() { - out: - for { - select { - case <-quitChan: - ui.eth.Reactor().Unsubscribe("newBlock", blockChan) - break out - case block := <-blockChan: - if block, ok := block.Resource.(*ethchain.Block); ok { - b := &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} - webView.Call("onNewBlockCb", b) - } - case stateObject := <-addrChan: - if stateObject, ok := stateObject.Resource.(*ethchain.StateObject); ok { - webView.Call("onObjectChangeCb", NewQStateObject(stateObject)) - } - } - } - - // Clean up - close(blockChan) - close(quitChan) - }() - ui.eth.Reactor().Subscribe("newBlock", blockChan) - ui.eth.Reactor().Subscribe("addressChanged", addrChan) - - win.Show() - win.Wait() - - quitChan <- true - }() } func (ui *UiLib) Muted(content string) { -- cgit v1.2.3 From 183dbcc6a0e56bf46f6406d47134f3b88eb5eef1 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 30 Apr 2014 14:42:57 +0200 Subject: fixed state object changes for eth api --- ethereal/ui/ext_app.go | 62 ++++++++++++++++++++++++++++++++++++++++++-------- ethereal/ui/library.go | 35 +++------------------------- ethereal/ui/types.go | 37 ++++++++++++++++++++++++++---- 3 files changed, 88 insertions(+), 46 deletions(-) (limited to 'ethereal/ui') 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 "" } -- cgit v1.2.3 From da7828f336cb323c78810d2963f8353787c03077 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 30 Apr 2014 17:13:12 +0200 Subject: Fixed tx nonce --- ethereal/ui/gui.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 8ec09459b..c821fa824 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -146,17 +146,20 @@ func (ui *Gui) update() { account := ui.eth.StateManager().GetAddrState(ui.addr).Object unconfirmedFunds := new(big.Int) ui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(account.Amount))) + + addrState := ui.eth.StateManager().GetAddrState(ui.addr) + for { select { case txMsg := <-txChan: tx := txMsg.Tx if txMsg.Type == ethchain.TxPre { - if bytes.Compare(tx.Sender(), ui.addr) == 0 { + if bytes.Compare(tx.Sender(), ui.addr) == 0 && addrState.Nonce <= tx.Nonce { ui.win.Root().Call("addTx", NewQTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) - ui.eth.StateManager().GetAddrState(ui.addr).Nonce += 1 + addrState.Nonce += 1 unconfirmedFunds.Sub(unconfirmedFunds, tx.Value) } else if bytes.Compare(tx.Recipient, ui.addr) == 0 { ui.win.Root().Call("addTx", NewQTx(tx)) -- cgit v1.2.3 From 471bd398f380bc26ba3144a0834092036565e429 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 2 May 2014 12:07:24 +0200 Subject: Moved Ext ethereum api Moved the external ethereum api which can be used by any 3rd party application. --- ethereal/ui/types.go | 83 ---------------------------------------------------- 1 file changed, 83 deletions(-) delete mode 100644 ethereal/ui/types.go (limited to 'ethereal/ui') diff --git a/ethereal/ui/types.go b/ethereal/ui/types.go deleted file mode 100644 index 9e12a8892..000000000 --- a/ethereal/ui/types.go +++ /dev/null @@ -1,83 +0,0 @@ -package ethui - -import ( - "encoding/hex" - "github.com/ethereum/eth-go/ethchain" - "github.com/ethereum/eth-go/ethutil" -) - -// Block interface exposed to QML -type QBlock struct { - Number int - Hash string -} - -// Creates a new QML Block from a chain block -func NewQBlock(block *ethchain.Block) *QBlock { - info := block.BlockInfo() - hash := hex.EncodeToString(block.Hash()) - - return &QBlock{Number: int(info.Number), Hash: hash} -} - -type QTx struct { - Value, Hash, Address string - Contract bool -} - -func NewQTx(tx *ethchain.Transaction) *QTx { - 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} -} - -type QKey struct { - Address string -} - -type QKeyRing struct { - Keys []interface{} -} - -func NewQKeyRing(keys []interface{}) *QKeyRing { - return &QKeyRing{Keys: keys} -} - -type QStateObject struct { - object *ethchain.StateObject -} - -func NewQStateObject(object *ethchain.StateObject) *QStateObject { - return &QStateObject{object: object} -} - -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 "" -} -- cgit v1.2.3 From 5a692b9f2bf265251b6f1faf171f55489b65b3de Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 2 May 2014 12:08:15 +0200 Subject: Moved API --- ethereal/ui/ext_app.go | 96 +------------------------------------------ ethereal/ui/gui.go | 13 +++--- ethereal/ui/html_container.go | 5 ++- ethereal/ui/library.go | 10 ++--- 4 files changed, 17 insertions(+), 107 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go index c02ffb7b2..1021afea9 100644 --- a/ethereal/ui/ext_app.go +++ b/ethereal/ui/ext_app.go @@ -2,13 +2,11 @@ package ethui import ( "fmt" - "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 { @@ -24,7 +22,7 @@ type AppContainer interface { } type ExtApplication struct { - *QEthereum + *utils.PEthereum blockChan chan ethutil.React changeChan chan ethutil.React @@ -37,7 +35,7 @@ type ExtApplication struct { func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { app := &ExtApplication{ - NewQEthereum(lib.eth), + utils.NewPEthereum(lib.eth), make(chan ethutil.React, 1), make(chan ethutil.React, 1), make(chan bool), @@ -127,93 +125,3 @@ func (app *ExtApplication) Watch(addr, storageAddr string) { app.registeredEvents = append(app.registeredEvents, event) } - -type QEthereum struct { - stateManager *ethchain.StateManager - blockChain *ethchain.BlockChain - txPool *ethchain.TxPool -} - -func NewQEthereum(eth *eth.Ethereum) *QEthereum { - return &QEthereum{ - eth.StateManager(), - eth.BlockChain(), - eth.TxPool(), - } -} - -func (lib *QEthereum) GetBlock(hexHash string) *QBlock { - hash := ethutil.FromHex(hexHash) - - block := lib.blockChain.GetBlock(hash) - - return &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} -} - -func (lib *QEthereum) GetKey() string { - return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) -} - -func (lib *QEthereum) GetStateObject(address string) *QStateObject { - stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) - if stateObject != nil { - return NewQStateObject(stateObject) - } - - // See GetStorage for explanation on "nil" - return NewQStateObject(nil) -} - -func (lib *QEthereum) Watch(addr, storageAddr string) { - // lib.stateManager.Watch(ethutil.FromHex(addr), ethutil.FromHex(storageAddr)) -} - -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(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/gui.go b/ethereal/ui/gui.go index c821fa824..8e6433207 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -7,6 +7,7 @@ import ( "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethdb" "github.com/ethereum/eth-go/ethutil" + "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "math/big" "strings" @@ -56,9 +57,9 @@ func (ui *Gui) Start(assetPath string) { // Register ethereum functions qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{ - Init: func(p *QBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, + Init: func(p *utils.PBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, }, { - Init: func(p *QTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, + Init: func(p *utils.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, }}) ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.2")) @@ -129,13 +130,13 @@ func (ui *Gui) readPreviousTransactions() { for it.Next() { tx := ethchain.NewTransactionFromBytes(it.Value()) - ui.win.Root().Call("addTx", NewQTx(tx)) + ui.win.Root().Call("addTx", utils.NewPTx(tx)) } it.Release() } func (ui *Gui) ProcessBlock(block *ethchain.Block) { - ui.win.Root().Call("addBlock", NewQBlock(block)) + ui.win.Root().Call("addBlock", utils.NewPBlock(block)) } // Simple go routine function that updates the list of peers in the GUI @@ -156,13 +157,13 @@ func (ui *Gui) update() { if txMsg.Type == ethchain.TxPre { if bytes.Compare(tx.Sender(), ui.addr) == 0 && addrState.Nonce <= tx.Nonce { - ui.win.Root().Call("addTx", NewQTx(tx)) + ui.win.Root().Call("addTx", utils.NewPTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) addrState.Nonce += 1 unconfirmedFunds.Sub(unconfirmedFunds, tx.Value) } else if bytes.Compare(tx.Recipient, ui.addr) == 0 { - ui.win.Root().Call("addTx", NewQTx(tx)) + ui.win.Root().Call("addTx", utils.NewPTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) unconfirmedFunds.Add(unconfirmedFunds, tx.Value) diff --git a/ethereal/ui/html_container.go b/ethereal/ui/html_container.go index 8e3ef0fc7..16cc531f2 100644 --- a/ethereal/ui/html_container.go +++ b/ethereal/ui/html_container.go @@ -4,6 +4,7 @@ import ( "errors" "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" "path/filepath" @@ -56,12 +57,12 @@ func (app *HtmlApplication) Window() *qml.Window { } func (app *HtmlApplication) NewBlock(block *ethchain.Block) { - b := &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + b := &utils.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} app.webView.Call("onNewBlockCb", b) } func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) { - app.webView.Call("onObjectChangeCb", NewQStateObject(stateObject)) + app.webView.Call("onObjectChangeCb", utils.NewPStateObject(stateObject)) } func (app *HtmlApplication) StorageChanged(stateObject *ethchain.StateObject, addr []byte, value *big.Int) { diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 70462a93d..231fd96e7 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -47,14 +47,14 @@ func (lib *EthLib) GetKey() string { return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) } -func (lib *EthLib) GetStateObject(address string) *QStateObject { +func (lib *EthLib) GetStateObject(address string) *utils.PStateObject { stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) if stateObject != nil { - return NewQStateObject(stateObject) + return utils.NewPStateObject(stateObject) } // See GetStorage for explanation on "nil" - return NewQStateObject(nil) + return utils.NewPStateObject(nil) } func (lib *EthLib) Watch(addr, storageAddr string) { @@ -115,7 +115,7 @@ func (lib *EthLib) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr st return ethutil.Hex(tx.Hash()), nil } -func (lib *EthLib) GetBlock(hexHash string) *QBlock { +func (lib *EthLib) GetBlock(hexHash string) *utils.PBlock { hash, err := hex.DecodeString(hexHash) if err != nil { return nil @@ -123,5 +123,5 @@ func (lib *EthLib) GetBlock(hexHash string) *QBlock { block := lib.blockChain.GetBlock(hash) - return &QBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + return &utils.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} } -- cgit v1.2.3 From ed64434dcc10347ad9846182ece2d71238138de9 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 2 May 2014 13:55:58 +0200 Subject: Moved public interface --- ethereal/ui/ext_app.go | 6 +++--- ethereal/ui/gui.go | 14 +++++++------- ethereal/ui/html_container.go | 6 +++--- ethereal/ui/library.go | 11 ++++++----- 4 files changed, 19 insertions(+), 18 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go index 1021afea9..a215709d0 100644 --- a/ethereal/ui/ext_app.go +++ b/ethereal/ui/ext_app.go @@ -3,8 +3,8 @@ package ethui import ( "fmt" "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "math/big" ) @@ -22,7 +22,7 @@ type AppContainer interface { } type ExtApplication struct { - *utils.PEthereum + *ethpub.PEthereum blockChan chan ethutil.React changeChan chan ethutil.React @@ -35,7 +35,7 @@ type ExtApplication struct { func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { app := &ExtApplication{ - utils.NewPEthereum(lib.eth), + ethpub.NewPEthereum(lib.eth), make(chan ethutil.React, 1), make(chan ethutil.React, 1), make(chan bool), diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go index 8e6433207..522c081a3 100644 --- a/ethereal/ui/gui.go +++ b/ethereal/ui/gui.go @@ -6,8 +6,8 @@ import ( "github.com/ethereum/eth-go" "github.com/ethereum/eth-go/ethchain" "github.com/ethereum/eth-go/ethdb" + "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "math/big" "strings" @@ -57,9 +57,9 @@ func (ui *Gui) Start(assetPath string) { // Register ethereum functions qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{ - Init: func(p *utils.PBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, + Init: func(p *ethpub.PBlock, obj qml.Object) { p.Number = 0; p.Hash = "" }, }, { - Init: func(p *utils.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, + Init: func(p *ethpub.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" }, }}) ethutil.Config.SetClientString(fmt.Sprintf("/Ethereal v%s", "0.2")) @@ -130,13 +130,13 @@ func (ui *Gui) readPreviousTransactions() { for it.Next() { tx := ethchain.NewTransactionFromBytes(it.Value()) - ui.win.Root().Call("addTx", utils.NewPTx(tx)) + ui.win.Root().Call("addTx", ethpub.NewPTx(tx)) } it.Release() } func (ui *Gui) ProcessBlock(block *ethchain.Block) { - ui.win.Root().Call("addBlock", utils.NewPBlock(block)) + ui.win.Root().Call("addBlock", ethpub.NewPBlock(block)) } // Simple go routine function that updates the list of peers in the GUI @@ -157,13 +157,13 @@ func (ui *Gui) update() { if txMsg.Type == ethchain.TxPre { if bytes.Compare(tx.Sender(), ui.addr) == 0 && addrState.Nonce <= tx.Nonce { - ui.win.Root().Call("addTx", utils.NewPTx(tx)) + ui.win.Root().Call("addTx", ethpub.NewPTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) addrState.Nonce += 1 unconfirmedFunds.Sub(unconfirmedFunds, tx.Value) } else if bytes.Compare(tx.Recipient, ui.addr) == 0 { - ui.win.Root().Call("addTx", utils.NewPTx(tx)) + ui.win.Root().Call("addTx", ethpub.NewPTx(tx)) ui.txDb.Put(tx.Hash(), tx.RlpEncode()) unconfirmedFunds.Add(unconfirmedFunds, tx.Value) diff --git a/ethereal/ui/html_container.go b/ethereal/ui/html_container.go index 16cc531f2..e3e48bfcc 100644 --- a/ethereal/ui/html_container.go +++ b/ethereal/ui/html_container.go @@ -3,8 +3,8 @@ package ethui import ( "errors" "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/utils" "github.com/go-qml/qml" "math/big" "path/filepath" @@ -57,12 +57,12 @@ func (app *HtmlApplication) Window() *qml.Window { } func (app *HtmlApplication) NewBlock(block *ethchain.Block) { - b := &utils.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + b := ðpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} app.webView.Call("onNewBlockCb", b) } func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) { - app.webView.Call("onObjectChangeCb", utils.NewPStateObject(stateObject)) + app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject)) } func (app *HtmlApplication) StorageChanged(stateObject *ethchain.StateObject, addr []byte, value *big.Int) { diff --git a/ethereal/ui/library.go b/ethereal/ui/library.go index 231fd96e7..1328cd6b7 100644 --- a/ethereal/ui/library.go +++ b/ethereal/ui/library.go @@ -4,6 +4,7 @@ import ( "encoding/hex" "fmt" "github.com/ethereum/eth-go/ethchain" + "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" "github.com/ethereum/go-ethereum/utils" "github.com/obscuren/secp256k1-go" @@ -47,14 +48,14 @@ func (lib *EthLib) GetKey() string { return ethutil.Hex(ethutil.Config.Db.GetKeys()[0].Address()) } -func (lib *EthLib) GetStateObject(address string) *utils.PStateObject { +func (lib *EthLib) GetStateObject(address string) *ethpub.PStateObject { stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address)) if stateObject != nil { - return utils.NewPStateObject(stateObject) + return ethpub.NewPStateObject(stateObject) } // See GetStorage for explanation on "nil" - return utils.NewPStateObject(nil) + return ethpub.NewPStateObject(nil) } func (lib *EthLib) Watch(addr, storageAddr string) { @@ -115,7 +116,7 @@ func (lib *EthLib) Transact(recipient, valueStr, gasStr, gasPriceStr, dataStr st return ethutil.Hex(tx.Hash()), nil } -func (lib *EthLib) GetBlock(hexHash string) *utils.PBlock { +func (lib *EthLib) GetBlock(hexHash string) *ethpub.PBlock { hash, err := hex.DecodeString(hexHash) if err != nil { return nil @@ -123,5 +124,5 @@ func (lib *EthLib) GetBlock(hexHash string) *utils.PBlock { block := lib.blockChain.GetBlock(hash) - return &utils.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} + return ðpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())} } -- cgit v1.2.3 From dd45197bcd174e16adc3b738bf390cc3018a5a28 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 5 May 2014 11:56:05 +0200 Subject: Added storage watch --- ethereal/ui/ext_app.go | 7 +++---- ethereal/ui/html_container.go | 5 ++--- 2 files changed, 5 insertions(+), 7 deletions(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go index a215709d0..de5f15db6 100644 --- a/ethereal/ui/ext_app.go +++ b/ethereal/ui/ext_app.go @@ -6,7 +6,6 @@ import ( "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" "github.com/go-qml/qml" - "math/big" ) type AppContainer interface { @@ -18,7 +17,7 @@ type AppContainer interface { NewBlock(*ethchain.Block) ObjectChanged(*ethchain.StateObject) - StorageChanged(*ethchain.StateObject, []byte, *big.Int) + StorageChanged(*ethchain.StorageState) } type ExtApplication struct { @@ -105,8 +104,8 @@ out: case object := <-app.changeChan: if stateObject, ok := object.Resource.(*ethchain.StateObject); ok { app.container.ObjectChanged(stateObject) - } else if _, ok := object.Resource.(*big.Int); ok { - // + } else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok { + app.container.StorageChanged(storageObject) } } } diff --git a/ethereal/ui/html_container.go b/ethereal/ui/html_container.go index e3e48bfcc..4f12aaaf6 100644 --- a/ethereal/ui/html_container.go +++ b/ethereal/ui/html_container.go @@ -6,7 +6,6 @@ import ( "github.com/ethereum/eth-go/ethpub" "github.com/ethereum/eth-go/ethutil" "github.com/go-qml/qml" - "math/big" "path/filepath" ) @@ -65,8 +64,8 @@ func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) { app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject)) } -func (app *HtmlApplication) StorageChanged(stateObject *ethchain.StateObject, addr []byte, value *big.Int) { - app.webView.Call("onStorageChangeCb", nil) +func (app *HtmlApplication) StorageChanged(storageObject *ethchain.StorageState) { + app.webView.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject)) } func (app *HtmlApplication) Destroy() { -- cgit v1.2.3 From e94e5ac75dbbc4ec52228ae11377a4fa71ab95ab Mon Sep 17 00:00:00 2001 From: Maran Date: Mon, 5 May 2014 14:16:14 +0200 Subject: Implemented rpc for ethereal and ethereum --- ethereal/ui/ext_app.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethereal/ui') diff --git a/ethereal/ui/ext_app.go b/ethereal/ui/ext_app.go index a215709d0..110ad37d7 100644 --- a/ethereal/ui/ext_app.go +++ b/ethereal/ui/ext_app.go @@ -35,7 +35,7 @@ type ExtApplication struct { func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication { app := &ExtApplication{ - ethpub.NewPEthereum(lib.eth), + ethpub.NewPEthereum(lib.eth.StateManager(), lib.eth.BlockChain(), lib.eth.TxPool()), make(chan ethutil.React, 1), make(chan ethutil.React, 1), make(chan bool), -- cgit v1.2.3