merge upstream
This commit is contained in:
zelig
commit
89630d2826
|
|
@ -9,4 +9,3 @@
|
|||
*un~
|
||||
.DS_Store
|
||||
*/**/.DS_Store
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,4 @@
|
|||
before_install: sudo apt-get install libgmp3-dev
|
||||
language: go
|
||||
go:
|
||||
- 1.2
|
||||
|
|
@ -168,7 +168,7 @@ func (block *Block) CalcGasLimit(parent *Block) *big.Int {
|
|||
result := new(big.Int).Add(previous, curInt)
|
||||
result.Div(result, big.NewInt(1024))
|
||||
|
||||
min := ethutil.BigPow(10, 4)
|
||||
min := big.NewInt(125000)
|
||||
|
||||
return ethutil.BigMax(min, result)
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -271,7 +271,7 @@ func AddTestNetFunds(block *Block) {
|
|||
for _, addr := range []string{
|
||||
"51ba59315b3a95761d0863b05ccc7a7f54703d99",
|
||||
"e4157b34ea9615cfbde6b4fda419828124b70c78",
|
||||
"1e12515ce3e0f817a4ddef9ca55788a1d66bd2df",
|
||||
"b9c015918bdaba24b4ff057a92a3873d6eb201be",
|
||||
"6c386a4b26f73c802f34673f7248bb118f97424a",
|
||||
"cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
|
||||
"2ef47100e0787b915105fd5e3f4ff6752079d5cb",
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ func (pow *EasyPow) Search(block *Block, reactChan chan ethutil.React) []byte {
|
|||
for {
|
||||
select {
|
||||
case <-reactChan:
|
||||
powlogger.Infoln("Breaking from mining")
|
||||
return nil
|
||||
default:
|
||||
i++
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ func (self *State) GetOrNewStateObject(addr []byte) *StateObject {
|
|||
}
|
||||
|
||||
func (self *State) NewStateObject(addr []byte) *StateObject {
|
||||
statelogger.Infof("(+) %x\n", addr)
|
||||
//statelogger.Infof("(+) %x\n", addr)
|
||||
|
||||
stateObject := NewStateObject(addr)
|
||||
self.stateObjects[string(addr)] = stateObject
|
||||
|
|
@ -206,84 +206,3 @@ func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte
|
|||
|
||||
m.storageChanges[string(stateObject.Address())][string(storageAddr)] = storage
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
// Resets the trie and all siblings
|
||||
func (s *State) Reset() {
|
||||
s.trie.Undo()
|
||||
|
||||
// Reset all nested states
|
||||
for _, state := range s.states {
|
||||
state.Reset()
|
||||
}
|
||||
}
|
||||
|
||||
// Syncs the trie and all siblings
|
||||
func (s *State) Sync() {
|
||||
// Sync all nested states
|
||||
for _, state := range s.states {
|
||||
state.Sync()
|
||||
}
|
||||
|
||||
s.trie.Sync()
|
||||
}
|
||||
func (s *State) GetStateObject(addr []byte) *StateObject {
|
||||
data := s.trie.Get(string(addr))
|
||||
if data == "" {
|
||||
return nil
|
||||
}
|
||||
|
||||
stateObject := NewStateObjectFromBytes(addr, []byte(data))
|
||||
|
||||
// Check if there's a cached state for this contract
|
||||
cachedStateObject := s.states[string(addr)]
|
||||
if cachedStateObject != nil {
|
||||
//fmt.Printf("get cached #%d %x addr: %x\n", cachedStateObject.trie.Cache().Len(), cachedStateObject.Root(), addr[0:4])
|
||||
stateObject.state = cachedStateObject
|
||||
}
|
||||
|
||||
return stateObject
|
||||
}
|
||||
|
||||
// Updates any given state object
|
||||
func (s *State) UpdateStateObject(object *StateObject) {
|
||||
addr := object.Address()
|
||||
|
||||
if object.state != nil && s.states[string(addr)] == nil {
|
||||
s.states[string(addr)] = object.state
|
||||
}
|
||||
|
||||
ethutil.Config.Db.Put(ethutil.Sha3Bin(object.Script()), object.Script())
|
||||
|
||||
s.trie.Update(string(addr), string(object.RlpEncode()))
|
||||
|
||||
s.manifest.AddObjectChange(object)
|
||||
}
|
||||
|
||||
func (s *State) GetAccount(addr []byte) (account *StateObject) {
|
||||
data := s.trie.Get(string(addr))
|
||||
if data == "" {
|
||||
account = NewAccount(addr, big.NewInt(0))
|
||||
} else {
|
||||
account = NewStateObjectFromBytes(addr, []byte(data))
|
||||
}
|
||||
|
||||
// Check if there's a cached state for this contract
|
||||
cachedStateObject := s.states[string(addr)]
|
||||
if cachedStateObject != nil {
|
||||
account.state = cachedStateObject
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (s *State) Copy() *State {
|
||||
state := NewState(s.trie.Copy())
|
||||
for k, subState := range s.states {
|
||||
state.states[k] = subState.Copy()
|
||||
}
|
||||
|
||||
return state
|
||||
}
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package ethchain
|
|||
import (
|
||||
"bytes"
|
||||
"container/list"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethcrypto"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
|
|
@ -125,6 +126,8 @@ done:
|
|||
break done
|
||||
default:
|
||||
statelogger.Infoln(err)
|
||||
err = nil
|
||||
//return nil, nil, nil, err
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -202,7 +205,7 @@ func (sm *StateManager) Process(block *Block, dontReact bool) (err error) {
|
|||
}
|
||||
|
||||
if !block.State().Cmp(state) {
|
||||
statelogger.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().trie.Root, state.trie.Root)
|
||||
err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().trie.Root, state.trie.Root)
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -237,7 +240,10 @@ func (sm *StateManager) ApplyDiff(state *State, parent, block *Block) (receipts
|
|||
coinbase.SetGasPool(block.CalcGasLimit(parent))
|
||||
|
||||
// Process the transactions on to current block
|
||||
receipts, _, _, _ = sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
|
||||
receipts, _, _, err = sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return receipts, nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,10 @@ func MakeContract(tx *Transaction, state *State) *StateObject {
|
|||
}
|
||||
|
||||
func NewStateObject(addr []byte) *StateObject {
|
||||
return &StateObject{address: addr, Amount: new(big.Int), gasPool: new(big.Int)}
|
||||
object := &StateObject{address: addr, Amount: new(big.Int), gasPool: new(big.Int)}
|
||||
object.state = NewState(ethutil.NewTrie(ethutil.Config.Db, ""))
|
||||
|
||||
return object
|
||||
}
|
||||
|
||||
func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject {
|
||||
|
|
|
|||
|
|
@ -16,12 +16,12 @@ func TestSnapshot(t *testing.T) {
|
|||
state.UpdateStateObject(stateObject)
|
||||
stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(42))
|
||||
|
||||
snapshot := state.Snapshot()
|
||||
snapshot := state.Copy()
|
||||
|
||||
stateObject = state.GetStateObject([]byte("aa"))
|
||||
stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(43))
|
||||
|
||||
state.Revert(snapshot)
|
||||
state.Set(snapshot)
|
||||
|
||||
stateObject = state.GetStateObject([]byte("aa"))
|
||||
if !stateObject.GetStorage(ethutil.Big("0")).Cmp(ethutil.NewValue(42)) {
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
package ethchain
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"math/big"
|
||||
)
|
||||
|
||||
|
|
@ -224,15 +226,11 @@ func (self *StateTransition) transferValue(sender, receiver *StateObject) error
|
|||
return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Amount)
|
||||
}
|
||||
|
||||
//if self.value.Cmp(ethutil.Big0) > 0 {
|
||||
// Subtract the amount from the senders account
|
||||
sender.SubAmount(self.value)
|
||||
// Add the amount to receivers account which should conclude this transaction
|
||||
receiver.AddAmount(self.value)
|
||||
|
||||
//statelogger.Debugf("%x => %x (%v)\n", sender.Address()[:4], receiver.Address()[:4], self.value)
|
||||
//}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -255,8 +253,50 @@ func (self *StateTransition) Eval(script []byte, context *StateObject) (ret []by
|
|||
Value: self.value,
|
||||
})
|
||||
vm.Verbose = true
|
||||
ret, _, err = closure.Call(vm, self.data, nil)
|
||||
deepErr = vm.err != nil
|
||||
|
||||
ret, err, deepErr = Call(vm, closure, self.data)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func Call(vm *Vm, closure *Closure, data []byte) (ret []byte, err error, deepErr bool) {
|
||||
ret, _, err = closure.Call(vm, data, nil)
|
||||
deepErr = vm.err != nil
|
||||
|
||||
Paranoia := ethutil.Config.Paranoia
|
||||
if Paranoia {
|
||||
var (
|
||||
context = closure.object
|
||||
trie = context.state.trie
|
||||
trie2 = ethutil.NewTrie(ethutil.Config.Db, "")
|
||||
)
|
||||
|
||||
trie.NewIterator().Each(func(key string, v *ethutil.Value) {
|
||||
trie2.Update(key, v.Str())
|
||||
})
|
||||
|
||||
a := ethutil.NewValue(trie2.Root).Bytes()
|
||||
b := ethutil.NewValue(context.state.trie.Root).Bytes()
|
||||
if bytes.Compare(a, b) != 0 {
|
||||
// TODO FIXME ASAP
|
||||
context.state.trie = trie2
|
||||
/*
|
||||
statelogger.Debugf("(o): %x\n", trie.Root)
|
||||
trie.NewIterator().Each(func(key string, v *ethutil.Value) {
|
||||
v.Decode()
|
||||
statelogger.Debugf("%x : %x\n", key, v.Str())
|
||||
})
|
||||
|
||||
statelogger.Debugf("(c): %x\n", trie2.Root)
|
||||
trie2.NewIterator().Each(func(key string, v *ethutil.Value) {
|
||||
v.Decode()
|
||||
statelogger.Debugf("%x : %x\n", key, v.Str())
|
||||
})
|
||||
*/
|
||||
|
||||
//return nil, fmt.Errorf("PARANOIA: Different state object roots during copy"), false
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -347,6 +347,29 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
|
|||
} else {
|
||||
stack.Push(ethutil.BigFalse)
|
||||
}
|
||||
|
||||
case SLT:
|
||||
require(2)
|
||||
x, y := stack.Popn()
|
||||
vm.Printf(" %v < %v", y, x)
|
||||
// x < y
|
||||
if y.Cmp(x) < 0 {
|
||||
stack.Push(ethutil.BigTrue)
|
||||
} else {
|
||||
stack.Push(ethutil.BigFalse)
|
||||
}
|
||||
case SGT:
|
||||
require(2)
|
||||
x, y := stack.Popn()
|
||||
vm.Printf(" %v > %v", y, x)
|
||||
|
||||
// x > y
|
||||
if y.Cmp(x) > 0 {
|
||||
stack.Push(ethutil.BigTrue)
|
||||
} else {
|
||||
stack.Push(ethutil.BigFalse)
|
||||
}
|
||||
|
||||
case EQ:
|
||||
require(2)
|
||||
x, y := stack.Popn()
|
||||
|
|
@ -661,7 +684,8 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
|
|||
// Create a new callable closure
|
||||
closure := NewClosure(closure, stateObject, stateObject.script, vm.state, gas, closure.Price)
|
||||
// Executer the closure and get the return value (if any)
|
||||
ret, _, err := closure.Call(vm, args, hook)
|
||||
//ret, _, err := closure.Call(vm, args, hook)
|
||||
ret, err, _ := Call(vm, closure, args)
|
||||
if err != nil {
|
||||
stack.Push(ethutil.BigFalse)
|
||||
|
||||
|
|
@ -700,7 +724,8 @@ func (vm *Vm) RunClosure(closure *Closure, hook DebugHook) (ret []byte, err erro
|
|||
|
||||
return closure.Return(nil), nil
|
||||
default:
|
||||
vmlogger.Debugf("Invalid opcode %x\n", op)
|
||||
vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
|
||||
fmt.Println(Code(closure.Script))
|
||||
|
||||
return closure.Return(nil), fmt.Errorf("Invalid opcode %x", op)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,9 +5,7 @@ import (
|
|||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethdb"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/obscuren/mutan"
|
||||
"math/big"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
|
|
@ -17,7 +15,7 @@ func TestRun4(t *testing.T) {
|
|||
db, _ := ethdb.NewMemDatabase()
|
||||
state := NewState(ethutil.NewTrie(db, ""))
|
||||
|
||||
callerScript, err := mutan.Compile(strings.NewReader(`
|
||||
callerScript, err := ethutil.Compile(`
|
||||
this.store[this.origin()] = 10**20
|
||||
hello := "world"
|
||||
|
||||
|
|
@ -31,7 +29,7 @@ func TestRun4(t *testing.T) {
|
|||
this.store[to] = this.store[to] + value
|
||||
}
|
||||
}
|
||||
`), false)
|
||||
`)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
|
|
@ -55,7 +53,7 @@ func TestRun4(t *testing.T) {
|
|||
|
||||
vm := NewVm(state, nil, RuntimeVars{
|
||||
Origin: account.Address(),
|
||||
BlockNumber: 1,
|
||||
BlockNumber: big.NewInt(1),
|
||||
PrevHash: ethutil.FromHex("5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"),
|
||||
Coinbase: ethutil.FromHex("2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"),
|
||||
Time: 1,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,22 @@
|
|||
UNAME = $(shell uname)
|
||||
FILES=qml *.png
|
||||
GOPATH=$(PWD)
|
||||
|
||||
|
||||
# Default is building
|
||||
all:
|
||||
go get -d
|
||||
cp *.go $(GOPATH)/src/github.com/ethereum/go-ethereum
|
||||
cp -r ui $(GOPATH)/src/github.com/ethereum/go-ethereum
|
||||
go build
|
||||
|
||||
install:
|
||||
# Linux build
|
||||
ifeq ($(UNAME),Linux)
|
||||
cp -r assets/* /usr/share/ethereal
|
||||
cp go-ethereum /usr/local/bin/ethereal
|
||||
endif
|
||||
# OS X build
|
||||
ifeq ($(UNAME),Darwin)
|
||||
# Execute py script
|
||||
endif
|
||||
|
|
@ -0,0 +1,270 @@
|
|||
import QtQuick 2.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import QtQuick.Dialogs 1.0;
|
||||
import QtQuick.Window 2.1;
|
||||
import QtQuick.Controls.Styles 1.1
|
||||
import Ethereum 1.0
|
||||
|
||||
ApplicationWindow {
|
||||
visible: false
|
||||
title: "IceCREAM"
|
||||
minimumWidth: 1280
|
||||
minimumHeight: 700
|
||||
width: 1290
|
||||
height: 700
|
||||
|
||||
property alias codeText: codeEditor.text
|
||||
property alias dataText: rawDataField.text
|
||||
|
||||
MenuBar {
|
||||
Menu {
|
||||
title: "Debugger"
|
||||
MenuItem {
|
||||
text: "Run"
|
||||
shortcut: "Ctrl+r"
|
||||
onTriggered: debugCurrent()
|
||||
}
|
||||
|
||||
MenuItem {
|
||||
text: "Next"
|
||||
shortcut: "Ctrl+n"
|
||||
onTriggered: dbg.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SplitView {
|
||||
anchors.fill: parent
|
||||
property var asmModel: ListModel {
|
||||
id: asmModel
|
||||
}
|
||||
TableView {
|
||||
id: asmTableView
|
||||
width: 200
|
||||
TableViewColumn{ role: "value" ; title: "" ; width: 200 }
|
||||
model: asmModel
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
color: "#00000000"
|
||||
anchors.left: asmTableView.right
|
||||
anchors.right: parent.right
|
||||
SplitView {
|
||||
orientation: Qt.Vertical
|
||||
anchors.fill: parent
|
||||
|
||||
Rectangle {
|
||||
color: "#00000000"
|
||||
height: 330
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
|
||||
TextArea {
|
||||
id: codeEditor
|
||||
anchors.top: parent.top
|
||||
anchors.bottom: parent.bottom
|
||||
anchors.left: parent.left
|
||||
anchors.right: settings.left
|
||||
}
|
||||
|
||||
Column {
|
||||
id: settings
|
||||
spacing: 5
|
||||
width: 300
|
||||
height: parent.height
|
||||
anchors.right: parent.right
|
||||
anchors.top: parent.top
|
||||
anchors.bottom: parent.bottom
|
||||
|
||||
Label {
|
||||
text: "Arbitrary data"
|
||||
}
|
||||
TextArea {
|
||||
id: rawDataField
|
||||
anchors.left: parent.left
|
||||
anchors.right: parent.right
|
||||
height: 150
|
||||
}
|
||||
|
||||
Label {
|
||||
text: "Amount"
|
||||
}
|
||||
TextField {
|
||||
id: txValue
|
||||
width: 200
|
||||
placeholderText: "Amount"
|
||||
validator: RegExpValidator { regExp: /\d*/ }
|
||||
}
|
||||
Label {
|
||||
text: "Amount of gas"
|
||||
}
|
||||
TextField {
|
||||
id: txGas
|
||||
width: 200
|
||||
validator: RegExpValidator { regExp: /\d*/ }
|
||||
text: "10000"
|
||||
placeholderText: "Gas"
|
||||
}
|
||||
Label {
|
||||
text: "Gas price"
|
||||
}
|
||||
TextField {
|
||||
id: txGasPrice
|
||||
width: 200
|
||||
placeholderText: "Gas price"
|
||||
text: "1000000000000"
|
||||
validator: RegExpValidator { regExp: /\d*/ }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SplitView {
|
||||
orientation: Qt.Vertical
|
||||
id: inspectorPane
|
||||
height: 500
|
||||
|
||||
SplitView {
|
||||
orientation: Qt.Horizontal
|
||||
height: 150
|
||||
|
||||
TableView {
|
||||
id: stackTableView
|
||||
property var stackModel: ListModel {
|
||||
id: stackModel
|
||||
}
|
||||
height: parent.height
|
||||
width: 300
|
||||
TableViewColumn{ role: "value" ; title: "Temp" ; width: 200 }
|
||||
model: stackModel
|
||||
}
|
||||
|
||||
TableView {
|
||||
id: memoryTableView
|
||||
property var memModel: ListModel {
|
||||
id: memModel
|
||||
}
|
||||
height: parent.height
|
||||
width: parent.width - stackTableView.width
|
||||
TableViewColumn{ id:mnumColmn ; role: "num" ; title: "#" ; width: 50}
|
||||
TableViewColumn{ role: "value" ; title: "Memory" ; width: 750}
|
||||
model: memModel
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
height: 100
|
||||
width: parent.width
|
||||
TableView {
|
||||
id: storageTableView
|
||||
property var memModel: ListModel {
|
||||
id: storageModel
|
||||
}
|
||||
height: parent.height
|
||||
width: parent.width
|
||||
TableViewColumn{ id: key ; role: "key" ; title: "#" ; width: storageTableView.width / 2}
|
||||
TableViewColumn{ role: "value" ; title: "Storage" ; width: storageTableView.width / 2}
|
||||
model: storageModel
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
height: 200
|
||||
width: parent.width
|
||||
TableView {
|
||||
id: logTableView
|
||||
property var logModel: ListModel {
|
||||
id: logModel
|
||||
}
|
||||
height: parent.height
|
||||
width: parent.width
|
||||
TableViewColumn{ id: message ; role: "message" ; title: "log" ; width: logTableView.width }
|
||||
model: logModel
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
toolBar: ToolBar {
|
||||
RowLayout {
|
||||
spacing: 5
|
||||
|
||||
Button {
|
||||
property var enabled: true
|
||||
id: debugStart
|
||||
onClicked: {
|
||||
debugCurrent()
|
||||
}
|
||||
text: "Debug"
|
||||
}
|
||||
|
||||
Button {
|
||||
property var enabled: true
|
||||
id: debugNextButton
|
||||
onClicked: {
|
||||
dbg.next()
|
||||
}
|
||||
text: "Next"
|
||||
}
|
||||
CheckBox {
|
||||
id: breakEachLine
|
||||
objectName: "breakEachLine"
|
||||
text: "Break each instruction"
|
||||
checked: true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function debugCurrent() {
|
||||
dbg.debug(txValue.text, txGas.text, txGasPrice.text, codeEditor.text, rawDataField.text)
|
||||
}
|
||||
|
||||
function setAsm(asm) {
|
||||
asmModel.append({asm: asm})
|
||||
}
|
||||
|
||||
function clearAsm() {
|
||||
asmModel.clear()
|
||||
}
|
||||
|
||||
function setInstruction(num) {
|
||||
asmTableView.selection.clear()
|
||||
asmTableView.selection.select(num)
|
||||
}
|
||||
|
||||
function setMem(mem) {
|
||||
memModel.append({num: mem.num, value: mem.value})
|
||||
}
|
||||
function clearMem(){
|
||||
memModel.clear()
|
||||
}
|
||||
|
||||
function setStack(stack) {
|
||||
stackModel.append({value: stack})
|
||||
}
|
||||
function addDebugMessage(message){
|
||||
debuggerLog.append({value: message})
|
||||
}
|
||||
|
||||
function clearStack() {
|
||||
stackModel.clear()
|
||||
}
|
||||
|
||||
function clearStorage() {
|
||||
storageModel.clear()
|
||||
}
|
||||
|
||||
function setStorage(storage) {
|
||||
storageModel.append({key: storage.key, value: storage.value})
|
||||
}
|
||||
|
||||
function setLog(msg) {
|
||||
logModel.insert(0, {message: msg})
|
||||
}
|
||||
|
||||
function clearLog() {
|
||||
logModel.clear()
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,380 @@
|
|||
var bigInt = (function () {
|
||||
var base = 10000000, logBase = 7;
|
||||
var sign = {
|
||||
positive: false,
|
||||
negative: true
|
||||
};
|
||||
|
||||
var normalize = function (first, second) {
|
||||
var a = first.value, b = second.value;
|
||||
var length = a.length > b.length ? a.length : b.length;
|
||||
for (var i = 0; i < length; i++) {
|
||||
a[i] = a[i] || 0;
|
||||
b[i] = b[i] || 0;
|
||||
}
|
||||
for (var i = length - 1; i >= 0; i--) {
|
||||
if (a[i] === 0 && b[i] === 0) {
|
||||
a.pop();
|
||||
b.pop();
|
||||
} else break;
|
||||
}
|
||||
if (!a.length) a = [0], b = [0];
|
||||
first.value = a;
|
||||
second.value = b;
|
||||
};
|
||||
|
||||
var parse = function (text, first) {
|
||||
if (typeof text === "object") return text;
|
||||
text += "";
|
||||
var s = sign.positive, value = [];
|
||||
if (text[0] === "-") {
|
||||
s = sign.negative;
|
||||
text = text.slice(1);
|
||||
}
|
||||
var base = 10;
|
||||
if (text.slice(0, 2) == "0x") {
|
||||
base = 16;
|
||||
text = text.slice(2);
|
||||
}
|
||||
else {
|
||||
var texts = text.split("e");
|
||||
if (texts.length > 2) throw new Error("Invalid integer");
|
||||
if (texts[1]) {
|
||||
var exp = texts[1];
|
||||
if (exp[0] === "+") exp = exp.slice(1);
|
||||
exp = parse(exp);
|
||||
if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers");
|
||||
while (exp.notEquals(0)) {
|
||||
texts[0] += "0";
|
||||
exp = exp.prev();
|
||||
}
|
||||
}
|
||||
text = texts[0];
|
||||
}
|
||||
if (text === "-0") text = "0";
|
||||
text = text.toUpperCase();
|
||||
var isValid = (base == 16 ? /^[0-9A-F]*$/ : /^[0-9]+$/).test(text);
|
||||
if (!isValid) throw new Error("Invalid integer");
|
||||
if (base == 16) {
|
||||
var val = bigInt(0);
|
||||
while (text.length) {
|
||||
v = text.charCodeAt(0) - 48;
|
||||
if (v > 9)
|
||||
v -= 7;
|
||||
text = text.slice(1);
|
||||
val = val.times(16).plus(v);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
else {
|
||||
while (text.length) {
|
||||
var divider = text.length > logBase ? text.length - logBase : 0;
|
||||
value.push(+text.slice(divider));
|
||||
text = text.slice(0, divider);
|
||||
}
|
||||
var val = bigInt(value, s);
|
||||
if (first) normalize(first, val);
|
||||
return val;
|
||||
}
|
||||
};
|
||||
|
||||
var goesInto = function (a, b) {
|
||||
var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive);
|
||||
if (a.equals(0)) throw new Error("Cannot divide by 0");
|
||||
var n = 0;
|
||||
do {
|
||||
var inc = 1;
|
||||
var c = bigInt(a.value, sign.positive), t = c.times(10);
|
||||
while (t.lesser(b)) {
|
||||
c = t;
|
||||
inc *= 10;
|
||||
t = t.times(10);
|
||||
}
|
||||
while (c.lesserOrEquals(b)) {
|
||||
b = b.minus(c);
|
||||
n += inc;
|
||||
}
|
||||
} while (a.lesserOrEquals(b));
|
||||
|
||||
return {
|
||||
remainder: b.value,
|
||||
result: n
|
||||
};
|
||||
};
|
||||
|
||||
var bigInt = function (value, s) {
|
||||
var self = {
|
||||
value: value,
|
||||
sign: s
|
||||
};
|
||||
var o = {
|
||||
value: value,
|
||||
sign: s,
|
||||
negate: function (m) {
|
||||
var first = m || self;
|
||||
return bigInt(first.value, !first.sign);
|
||||
},
|
||||
abs: function (m) {
|
||||
var first = m || self;
|
||||
return bigInt(first.value, sign.positive);
|
||||
},
|
||||
add: function (n, m) {
|
||||
var s, first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m));
|
||||
else second = parse(n, first);
|
||||
s = first.sign;
|
||||
if (first.sign !== second.sign) {
|
||||
first = bigInt(first.value, sign.positive);
|
||||
second = bigInt(second.value, sign.positive);
|
||||
return s === sign.positive ?
|
||||
o.subtract(first, second) :
|
||||
o.subtract(second, first);
|
||||
}
|
||||
normalize(first, second);
|
||||
var a = first.value, b = second.value;
|
||||
var result = [],
|
||||
carry = 0;
|
||||
for (var i = 0; i < a.length || carry > 0; i++) {
|
||||
var sum = (a[i] || 0) + (b[i] || 0) + carry;
|
||||
carry = sum >= base ? 1 : 0;
|
||||
sum -= carry * base;
|
||||
result.push(sum);
|
||||
}
|
||||
return bigInt(result, s);
|
||||
},
|
||||
plus: function (n, m) {
|
||||
return o.add(n, m);
|
||||
},
|
||||
subtract: function (n, m) {
|
||||
var first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m));
|
||||
else second = parse(n, first);
|
||||
if (first.sign !== second.sign) return o.add(first, o.negate(second));
|
||||
if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first));
|
||||
if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first));
|
||||
var a = first.value, b = second.value;
|
||||
var result = [],
|
||||
borrow = 0;
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
var tmp = a[i] - borrow;
|
||||
borrow = tmp < b[i] ? 1 : 0;
|
||||
var minuend = (borrow * base) + tmp - b[i];
|
||||
result.push(minuend);
|
||||
}
|
||||
return bigInt(result, sign.positive);
|
||||
},
|
||||
minus: function (n, m) {
|
||||
return o.subtract(n, m);
|
||||
},
|
||||
multiply: function (n, m) {
|
||||
var s, first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m));
|
||||
else second = parse(n, first);
|
||||
s = first.sign !== second.sign;
|
||||
var a = first.value, b = second.value;
|
||||
var resultSum = [];
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
resultSum[i] = [];
|
||||
var j = i;
|
||||
while (j--) {
|
||||
resultSum[i].push(0);
|
||||
}
|
||||
}
|
||||
var carry = 0;
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
var x = a[i];
|
||||
for (var j = 0; j < b.length || carry > 0; j++) {
|
||||
var y = b[j];
|
||||
var product = y ? (x * y) + carry : carry;
|
||||
carry = product > base ? Math.floor(product / base) : 0;
|
||||
product -= carry * base;
|
||||
resultSum[i].push(product);
|
||||
}
|
||||
}
|
||||
var max = -1;
|
||||
for (var i = 0; i < resultSum.length; i++) {
|
||||
var len = resultSum[i].length;
|
||||
if (len > max) max = len;
|
||||
}
|
||||
var result = [], carry = 0;
|
||||
for (var i = 0; i < max || carry > 0; i++) {
|
||||
var sum = carry;
|
||||
for (var j = 0; j < resultSum.length; j++) {
|
||||
sum += resultSum[j][i] || 0;
|
||||
}
|
||||
carry = sum > base ? Math.floor(sum / base) : 0;
|
||||
sum -= carry * base;
|
||||
result.push(sum);
|
||||
}
|
||||
return bigInt(result, s);
|
||||
},
|
||||
times: function (n, m) {
|
||||
return o.multiply(n, m);
|
||||
},
|
||||
divmod: function (n, m) {
|
||||
var s, first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m));
|
||||
else second = parse(n, first);
|
||||
s = first.sign !== second.sign;
|
||||
if (bigInt(first.value, first.sign).equals(0)) return {
|
||||
quotient: bigInt([0], sign.positive),
|
||||
remainder: bigInt([0], sign.positive)
|
||||
};
|
||||
if (second.equals(0)) throw new Error("Cannot divide by zero");
|
||||
var a = first.value, b = second.value;
|
||||
var result = [], remainder = [];
|
||||
for (var i = a.length - 1; i >= 0; i--) {
|
||||
var n = [a[i]].concat(remainder);
|
||||
var quotient = goesInto(b, n);
|
||||
result.push(quotient.result);
|
||||
remainder = quotient.remainder;
|
||||
}
|
||||
result.reverse();
|
||||
return {
|
||||
quotient: bigInt(result, s),
|
||||
remainder: bigInt(remainder, first.sign)
|
||||
};
|
||||
},
|
||||
divide: function (n, m) {
|
||||
return o.divmod(n, m).quotient;
|
||||
},
|
||||
over: function (n, m) {
|
||||
return o.divide(n, m);
|
||||
},
|
||||
mod: function (n, m) {
|
||||
return o.divmod(n, m).remainder;
|
||||
},
|
||||
pow: function (n, m) {
|
||||
var first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m));
|
||||
else second = parse(n, first);
|
||||
var a = first, b = second;
|
||||
if (b.lesser(0)) return ZERO;
|
||||
if (b.equals(0)) return ONE;
|
||||
var result = bigInt(a.value, a.sign);
|
||||
|
||||
if (b.mod(2).equals(0)) {
|
||||
var c = result.pow(b.over(2));
|
||||
return c.times(c);
|
||||
} else {
|
||||
return result.times(result.pow(b.minus(1)));
|
||||
}
|
||||
},
|
||||
next: function (m) {
|
||||
var first = m || self;
|
||||
return o.add(first, 1);
|
||||
},
|
||||
prev: function (m) {
|
||||
var first = m || self;
|
||||
return o.subtract(first, 1);
|
||||
},
|
||||
compare: function (n, m) {
|
||||
var first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m, first));
|
||||
else second = parse(n, first);
|
||||
normalize(first, second);
|
||||
if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0;
|
||||
if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1;
|
||||
var multiplier = first.sign === sign.positive ? 1 : -1;
|
||||
var a = first.value, b = second.value;
|
||||
for (var i = a.length - 1; i >= 0; i--) {
|
||||
if (a[i] > b[i]) return 1 * multiplier;
|
||||
if (b[i] > a[i]) return -1 * multiplier;
|
||||
}
|
||||
return 0;
|
||||
},
|
||||
compareAbs: function (n, m) {
|
||||
var first = self, second;
|
||||
if (m) (first = parse(n)) && (second = parse(m, first));
|
||||
else second = parse(n, first);
|
||||
first.sign = second.sign = sign.positive;
|
||||
return o.compare(first, second);
|
||||
},
|
||||
equals: function (n, m) {
|
||||
return o.compare(n, m) === 0;
|
||||
},
|
||||
notEquals: function (n, m) {
|
||||
return !o.equals(n, m);
|
||||
},
|
||||
lesser: function (n, m) {
|
||||
return o.compare(n, m) < 0;
|
||||
},
|
||||
greater: function (n, m) {
|
||||
return o.compare(n, m) > 0;
|
||||
},
|
||||
greaterOrEquals: function (n, m) {
|
||||
return o.compare(n, m) >= 0;
|
||||
},
|
||||
lesserOrEquals: function (n, m) {
|
||||
return o.compare(n, m) <= 0;
|
||||
},
|
||||
isPositive: function (m) {
|
||||
var first = m || self;
|
||||
return first.sign === sign.positive;
|
||||
},
|
||||
isNegative: function (m) {
|
||||
var first = m || self;
|
||||
return first.sign === sign.negative;
|
||||
},
|
||||
isEven: function (m) {
|
||||
var first = m || self;
|
||||
return first.value[0] % 2 === 0;
|
||||
},
|
||||
isOdd: function (m) {
|
||||
var first = m || self;
|
||||
return first.value[0] % 2 === 1;
|
||||
},
|
||||
toString: function (m) {
|
||||
var first = m || self;
|
||||
var str = "", len = first.value.length;
|
||||
while (len--) {
|
||||
if (first.value[len].toString().length === 8) str += first.value[len];
|
||||
else str += (base.toString() + first.value[len]).slice(-logBase);
|
||||
}
|
||||
while (str[0] === "0") {
|
||||
str = str.slice(1);
|
||||
}
|
||||
if (!str.length) str = "0";
|
||||
var s = (first.sign === sign.positive || str == "0") ? "" : "-";
|
||||
return s + str;
|
||||
},
|
||||
toHex: function (m) {
|
||||
var first = m || self;
|
||||
var str = "";
|
||||
var l = this.abs();
|
||||
while (l > 0) {
|
||||
var qr = l.divmod(256);
|
||||
var b = qr.remainder.toJSNumber();
|
||||
str = (b >> 4).toString(16) + (b & 15).toString(16) + str;
|
||||
l = qr.quotient;
|
||||
}
|
||||
return (this.isNegative() ? "-" : "") + "0x" + str;
|
||||
},
|
||||
toJSNumber: function (m) {
|
||||
return +o.toString(m);
|
||||
},
|
||||
valueOf: function (m) {
|
||||
return o.toJSNumber(m);
|
||||
}
|
||||
};
|
||||
return o;
|
||||
};
|
||||
|
||||
var ZERO = bigInt([0], sign.positive);
|
||||
var ONE = bigInt([1], sign.positive);
|
||||
var MINUS_ONE = bigInt([1], sign.negative);
|
||||
|
||||
var fnReturn = function (a) {
|
||||
if (typeof a === "undefined") return ZERO;
|
||||
return parse(a);
|
||||
};
|
||||
fnReturn.zero = ZERO;
|
||||
fnReturn.one = ONE;
|
||||
fnReturn.minusOne = MINUS_ONE;
|
||||
return fnReturn;
|
||||
})();
|
||||
|
||||
if (typeof module !== "undefined") {
|
||||
module.exports = bigInt;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
// Main Ethereum library
|
||||
window.eth = {
|
||||
prototype: Object(),
|
||||
|
||||
// Retrieve block
|
||||
//
|
||||
// Either supply a number or a string. Type is determent for the lookup method
|
||||
// string - Retrieves the block by looking up the hash
|
||||
// number - Retrieves the block by looking up the block number
|
||||
getBlock: function(numberOrHash, cb) {
|
||||
var func;
|
||||
if(typeof numberOrHash == "string") {
|
||||
func = "getBlockByHash";
|
||||
} else {
|
||||
func = "getBlockByNumber";
|
||||
}
|
||||
postData({call: func, args: [numberOrHash]}, cb);
|
||||
},
|
||||
|
||||
// Create transaction
|
||||
//
|
||||
// Transact between two state objects
|
||||
transact: function(sec, recipient, value, gas, gasPrice, data, cb) {
|
||||
postData({call: "transact", args: [sec, recipient, value, gas, gasPrice, data]}, cb);
|
||||
},
|
||||
|
||||
create: function(sec, value, gas, gasPrice, init, body, cb) {
|
||||
postData({call: "create", args: [sec, value, gas, gasPrice, init, body]}, cb);
|
||||
},
|
||||
|
||||
getStorageAt: function(address, storageAddress, cb) {
|
||||
postData({call: "getStorage", args: [address, storageAddress]}, cb);
|
||||
},
|
||||
|
||||
getStateKeyVals: function(address, cb){
|
||||
postData({call: "getStateKeyVals", args: [address]}, cb);
|
||||
},
|
||||
|
||||
getKey: function(cb) {
|
||||
postData({call: "getKey"}, cb);
|
||||
},
|
||||
|
||||
getTxCountAt: function(address, cb) {
|
||||
postData({call: "getTxCountAt", args: [address]}, cb);
|
||||
},
|
||||
getIsMining: function(cb){
|
||||
postData({call: "getIsMining"}, cb)
|
||||
},
|
||||
getIsListening: function(cb){
|
||||
postData({call: "getIsListening"}, cb)
|
||||
},
|
||||
getCoinBase: function(cb){
|
||||
postData({call: "getCoinBase"}, cb);
|
||||
},
|
||||
getPeerCount: function(cb){
|
||||
postData({call: "getPeerCount"}, cb);
|
||||
},
|
||||
getBalanceAt: function(address, cb) {
|
||||
postData({call: "getBalance", args: [address]}, cb);
|
||||
},
|
||||
getTransactionsFor: function(address, cb) {
|
||||
postData({call: "getTransactionsFor", args: [address]}, cb);
|
||||
},
|
||||
|
||||
getSecretToAddress: function(sec, cb) {
|
||||
postData({call: "getSecretToAddress", args: [sec]}, cb);
|
||||
},
|
||||
|
||||
watch: function(address, storageAddrOrCb, cb) {
|
||||
var ev;
|
||||
if(cb === undefined) {
|
||||
cb = storageAddrOrCb;
|
||||
storageAddrOrCb = "";
|
||||
ev = "object:"+address;
|
||||
} else {
|
||||
ev = "storage:"+address+":"+storageAddrOrCb;
|
||||
}
|
||||
|
||||
eth.on(ev, cb)
|
||||
|
||||
postData({call: "watch", args: [address, storageAddrOrCb]});
|
||||
},
|
||||
|
||||
disconnect: function(address, storageAddrOrCb, cb) {
|
||||
var ev;
|
||||
if(cb === undefined) {
|
||||
cb = storageAddrOrCb;
|
||||
storageAddrOrCb = "";
|
||||
ev = "object:"+address;
|
||||
} else {
|
||||
ev = "storage:"+address+":"+storageAddrOrCb;
|
||||
}
|
||||
|
||||
eth.off(ev, cb)
|
||||
|
||||
postData({call: "disconnect", args: [address, storageAddrOrCb]});
|
||||
},
|
||||
|
||||
set: function(props) {
|
||||
postData({call: "set", args: props});
|
||||
},
|
||||
|
||||
on: function(event, cb) {
|
||||
if(eth._onCallbacks[event] === undefined) {
|
||||
eth._onCallbacks[event] = [];
|
||||
}
|
||||
|
||||
eth._onCallbacks[event].push(cb);
|
||||
|
||||
return this
|
||||
},
|
||||
|
||||
off: function(event, cb) {
|
||||
if(eth._onCallbacks[event] !== undefined) {
|
||||
var callbacks = eth._onCallbacks[event];
|
||||
for(var i = 0; i < callbacks.length; i++) {
|
||||
if(callbacks[i] === cb) {
|
||||
delete callbacks[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this
|
||||
},
|
||||
|
||||
trigger: function(event, data) {
|
||||
var callbacks = eth._onCallbacks[event];
|
||||
if(callbacks !== undefined) {
|
||||
for(var i = 0; i < callbacks.length; i++) {
|
||||
// Figure out whether the returned data was an array
|
||||
// array means multiple return arguments (multiple params)
|
||||
if(data instanceof Array) {
|
||||
callbacks[i].apply(this, data);
|
||||
} else {
|
||||
callbacks[i].call(this, data);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
|
||||
}
|
||||
window.eth._callbacks = {}
|
||||
window.eth._onCallbacks = {}
|
||||
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
function debug(/**/) {
|
||||
var args = arguments;
|
||||
var msg = ""
|
||||
for(var i = 0; i < args.length; i++){
|
||||
if(typeof args[i] === "object") {
|
||||
msg += " " + JSON.stringify(args[i])
|
||||
} else {
|
||||
msg += " " + args[i]
|
||||
}
|
||||
}
|
||||
|
||||
postData({call:"debug", args:[msg]})
|
||||
document.getElementById("debug").innerHTML += "<br>" + msg
|
||||
}
|
||||
|
||||
// Helper function for generating pseudo callbacks and sending data to the QML part of the application
|
||||
function postData(data, cb) {
|
||||
data._seed = Math.floor(Math.random() * 1000000)
|
||||
if(cb) {
|
||||
eth._callbacks[data._seed] = cb;
|
||||
}
|
||||
|
||||
if(data.args === undefined) {
|
||||
data.args = [];
|
||||
}
|
||||
|
||||
navigator.qt.postMessage(JSON.stringify(data));
|
||||
}
|
||||
|
||||
navigator.qt.onmessage = function(ev) {
|
||||
var data = JSON.parse(ev.data)
|
||||
|
||||
if(data._event !== undefined) {
|
||||
eth.trigger(data._event, data.data);
|
||||
} else {
|
||||
if(data._seed) {
|
||||
var cb = eth._callbacks[data._seed];
|
||||
if(cb) {
|
||||
// Figure out whether the returned data was an array
|
||||
// array means multiple return arguments (multiple params)
|
||||
if(data.data instanceof Array) {
|
||||
cb.apply(this, data.data)
|
||||
} else {
|
||||
cb.call(this, data.data)
|
||||
}
|
||||
|
||||
// Remove the "trigger" callback
|
||||
delete eth._callbacks[ev._seed];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
window.onerror = function(message, file, lineNumber, column, errorObj) {
|
||||
debug(file, message, lineNumber+":"+column, errorObj);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
String.prototype.pad = function(l, r) {
|
||||
if (r === undefined) {
|
||||
r = l
|
||||
if (!(this.substr(0, 2) == "0x" || /^\d+$/.test(this)))
|
||||
l = 0
|
||||
}
|
||||
var ret = this.bin();
|
||||
while (ret.length < l)
|
||||
ret = "\0" + ret
|
||||
while (ret.length < r)
|
||||
ret = ret + "\0"
|
||||
return ret;
|
||||
}
|
||||
|
||||
String.prototype.unpad = function() {
|
||||
var i = this.length;
|
||||
while (i && this[i - 1] == "\0")
|
||||
--i
|
||||
return this.substr(0, i)
|
||||
}
|
||||
|
||||
String.prototype.bin = function() {
|
||||
if (this.substr(0, 2) == "0x") {
|
||||
bytes = []
|
||||
var i = 2;
|
||||
|
||||
// Check if it's odd - pad with a zero if so.
|
||||
if (this.length % 2)
|
||||
bytes.push(parseInt(this.substr(i++, 1), 16))
|
||||
|
||||
for (; i < this.length - 1; i += 2)
|
||||
bytes.push(parseInt(this.substr(i, 2), 16));
|
||||
|
||||
return String.fromCharCode.apply(String, bytes);
|
||||
} else if (/^\d+$/.test(this))
|
||||
return bigInt(this.substr(0)).toHex().bin()
|
||||
|
||||
// Otherwise we'll return the "String" object instead of an actual string
|
||||
return this.substr(0, this.length)
|
||||
}
|
||||
|
||||
String.prototype.unbin = function() {
|
||||
var i, l, o = '';
|
||||
for(i = 0, l = this.length; i < l; i++) {
|
||||
var n = this.charCodeAt(i).toString(16);
|
||||
o += n.length < 2 ? '0' + n : n;
|
||||
}
|
||||
|
||||
return "0x" + o;
|
||||
}
|
||||
|
||||
String.prototype.dec = function() {
|
||||
return bigInt(this.substr(0)).toString()
|
||||
}
|
||||
|
||||
String.prototype.hex = function() {
|
||||
return bigInt(this.substr(0)).toHex()
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.2 KiB |
|
|
@ -0,0 +1,272 @@
|
|||
/* BASICS */
|
||||
|
||||
.CodeMirror {
|
||||
/* Set height, width, borders, and global font properties here */
|
||||
font-family: monospace;
|
||||
height: 300px;
|
||||
}
|
||||
.CodeMirror-scroll {
|
||||
/* Set scrolling behaviour here */
|
||||
overflow: auto;
|
||||
}
|
||||
|
||||
/* PADDING */
|
||||
|
||||
.CodeMirror-lines {
|
||||
padding: 4px 0; /* Vertical padding around content */
|
||||
}
|
||||
.CodeMirror pre {
|
||||
padding: 0 4px; /* Horizontal padding of content */
|
||||
}
|
||||
|
||||
.CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
|
||||
background-color: white; /* The little square between H and V scrollbars */
|
||||
}
|
||||
|
||||
/* GUTTER */
|
||||
|
||||
.CodeMirror-gutters {
|
||||
border-right: 1px solid #ddd;
|
||||
background-color: #f7f7f7;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.CodeMirror-linenumbers {}
|
||||
.CodeMirror-linenumber {
|
||||
padding: 0 3px 0 5px;
|
||||
min-width: 20px;
|
||||
text-align: right;
|
||||
color: #999;
|
||||
-moz-box-sizing: content-box;
|
||||
box-sizing: content-box;
|
||||
}
|
||||
|
||||
/* CURSOR */
|
||||
|
||||
.CodeMirror div.CodeMirror-cursor {
|
||||
border-left: 1px solid black;
|
||||
}
|
||||
/* Shown when moving in bi-directional text */
|
||||
.CodeMirror div.CodeMirror-secondarycursor {
|
||||
border-left: 1px solid silver;
|
||||
}
|
||||
.CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
|
||||
width: auto;
|
||||
border: 0;
|
||||
background: #7e7;
|
||||
}
|
||||
/* Can style cursor different in overwrite (non-insert) mode */
|
||||
div.CodeMirror-overwrite div.CodeMirror-cursor {}
|
||||
|
||||
.cm-tab { display: inline-block; }
|
||||
|
||||
.CodeMirror-ruler {
|
||||
border-left: 1px solid #ccc;
|
||||
position: absolute;
|
||||
}
|
||||
|
||||
/* DEFAULT THEME */
|
||||
|
||||
.cm-s-default .cm-keyword {color: #708;}
|
||||
.cm-s-default .cm-atom {color: #219;}
|
||||
.cm-s-default .cm-number {color: #164;}
|
||||
.cm-s-default .cm-def {color: #00f;}
|
||||
.cm-s-default .cm-variable,
|
||||
.cm-s-default .cm-punctuation,
|
||||
.cm-s-default .cm-property,
|
||||
.cm-s-default .cm-operator {}
|
||||
.cm-s-default .cm-variable-2 {color: #05a;}
|
||||
.cm-s-default .cm-variable-3 {color: #085;}
|
||||
.cm-s-default .cm-comment {color: #a50;}
|
||||
.cm-s-default .cm-string {color: #a11;}
|
||||
.cm-s-default .cm-string-2 {color: #f50;}
|
||||
.cm-s-default .cm-meta {color: #555;}
|
||||
.cm-s-default .cm-qualifier {color: #555;}
|
||||
.cm-s-default .cm-builtin {color: #30a;}
|
||||
.cm-s-default .cm-bracket {color: #997;}
|
||||
.cm-s-default .cm-tag {color: #170;}
|
||||
.cm-s-default .cm-attribute {color: #00c;}
|
||||
.cm-s-default .cm-header {color: blue;}
|
||||
.cm-s-default .cm-quote {color: #090;}
|
||||
.cm-s-default .cm-hr {color: #999;}
|
||||
.cm-s-default .cm-link {color: #00c;}
|
||||
|
||||
.cm-negative {color: #d44;}
|
||||
.cm-positive {color: #292;}
|
||||
.cm-header, .cm-strong {font-weight: bold;}
|
||||
.cm-em {font-style: italic;}
|
||||
.cm-link {text-decoration: underline;}
|
||||
|
||||
.cm-s-default .cm-error {color: #f00;}
|
||||
.cm-invalidchar {color: #f00;}
|
||||
|
||||
div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
|
||||
div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
|
||||
.CodeMirror-activeline-background {background: #e8f2ff;}
|
||||
|
||||
/* STOP */
|
||||
|
||||
/* The rest of this file contains styles related to the mechanics of
|
||||
the editor. You probably shouldn't touch them. */
|
||||
|
||||
.CodeMirror {
|
||||
line-height: 1;
|
||||
position: relative;
|
||||
overflow: hidden;
|
||||
background: white;
|
||||
color: black;
|
||||
}
|
||||
|
||||
.CodeMirror-scroll {
|
||||
/* 30px is the magic margin used to hide the element's real scrollbars */
|
||||
/* See overflow: hidden in .CodeMirror */
|
||||
margin-bottom: -30px; margin-right: -30px;
|
||||
padding-bottom: 30px;
|
||||
height: 100%;
|
||||
outline: none; /* Prevent dragging from highlighting the element */
|
||||
position: relative;
|
||||
-moz-box-sizing: content-box;
|
||||
box-sizing: content-box;
|
||||
}
|
||||
.CodeMirror-sizer {
|
||||
position: relative;
|
||||
border-right: 30px solid transparent;
|
||||
-moz-box-sizing: content-box;
|
||||
box-sizing: content-box;
|
||||
}
|
||||
|
||||
/* The fake, visible scrollbars. Used to force redraw during scrolling
|
||||
before actuall scrolling happens, thus preventing shaking and
|
||||
flickering artifacts. */
|
||||
.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
|
||||
position: absolute;
|
||||
z-index: 6;
|
||||
display: none;
|
||||
}
|
||||
.CodeMirror-vscrollbar {
|
||||
right: 0; top: 0;
|
||||
overflow-x: hidden;
|
||||
overflow-y: scroll;
|
||||
}
|
||||
.CodeMirror-hscrollbar {
|
||||
bottom: 0; left: 0;
|
||||
overflow-y: hidden;
|
||||
overflow-x: scroll;
|
||||
}
|
||||
.CodeMirror-scrollbar-filler {
|
||||
right: 0; bottom: 0;
|
||||
}
|
||||
.CodeMirror-gutter-filler {
|
||||
left: 0; bottom: 0;
|
||||
}
|
||||
|
||||
.CodeMirror-gutters {
|
||||
position: absolute; left: 0; top: 0;
|
||||
padding-bottom: 30px;
|
||||
z-index: 3;
|
||||
}
|
||||
.CodeMirror-gutter {
|
||||
white-space: normal;
|
||||
height: 100%;
|
||||
-moz-box-sizing: content-box;
|
||||
box-sizing: content-box;
|
||||
padding-bottom: 30px;
|
||||
margin-bottom: -32px;
|
||||
display: inline-block;
|
||||
/* Hack to make IE7 behave */
|
||||
*zoom:1;
|
||||
*display:inline;
|
||||
}
|
||||
.CodeMirror-gutter-elt {
|
||||
position: absolute;
|
||||
cursor: default;
|
||||
z-index: 4;
|
||||
}
|
||||
|
||||
.CodeMirror-lines {
|
||||
cursor: text;
|
||||
}
|
||||
.CodeMirror pre {
|
||||
/* Reset some styles that the rest of the page might have set */
|
||||
-moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
|
||||
border-width: 0;
|
||||
background: transparent;
|
||||
font-family: inherit;
|
||||
font-size: inherit;
|
||||
margin: 0;
|
||||
white-space: pre;
|
||||
word-wrap: normal;
|
||||
line-height: inherit;
|
||||
color: inherit;
|
||||
z-index: 2;
|
||||
position: relative;
|
||||
overflow: visible;
|
||||
}
|
||||
.CodeMirror-wrap pre {
|
||||
word-wrap: break-word;
|
||||
white-space: pre-wrap;
|
||||
word-break: normal;
|
||||
}
|
||||
|
||||
.CodeMirror-linebackground {
|
||||
position: absolute;
|
||||
left: 0; right: 0; top: 0; bottom: 0;
|
||||
z-index: 0;
|
||||
}
|
||||
|
||||
.CodeMirror-linewidget {
|
||||
position: relative;
|
||||
z-index: 2;
|
||||
overflow: auto;
|
||||
}
|
||||
|
||||
.CodeMirror-widget {}
|
||||
|
||||
.CodeMirror-wrap .CodeMirror-scroll {
|
||||
overflow-x: hidden;
|
||||
}
|
||||
|
||||
.CodeMirror-measure {
|
||||
position: absolute;
|
||||
width: 100%;
|
||||
height: 0;
|
||||
overflow: hidden;
|
||||
visibility: hidden;
|
||||
}
|
||||
.CodeMirror-measure pre { position: static; }
|
||||
|
||||
.CodeMirror div.CodeMirror-cursor {
|
||||
position: absolute;
|
||||
border-right: none;
|
||||
width: 0;
|
||||
}
|
||||
|
||||
div.CodeMirror-cursors {
|
||||
visibility: hidden;
|
||||
position: relative;
|
||||
z-index: 1;
|
||||
}
|
||||
.CodeMirror-focused div.CodeMirror-cursors {
|
||||
visibility: visible;
|
||||
}
|
||||
|
||||
.CodeMirror-selected { background: #d9d9d9; }
|
||||
.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
|
||||
.CodeMirror-crosshair { cursor: crosshair; }
|
||||
|
||||
.cm-searching {
|
||||
background: #ffa;
|
||||
background: rgba(255, 255, 0, .4);
|
||||
}
|
||||
|
||||
/* IE7 hack to prevent it from returning funny offsetTops on the spans */
|
||||
.CodeMirror span { *vertical-align: text-bottom; }
|
||||
|
||||
/* Used to force a border model for a node */
|
||||
.cm-force-border { padding-right: .1px; }
|
||||
|
||||
@media print {
|
||||
/* Hide the cursor when printing */
|
||||
.CodeMirror div.CodeMirror-cursors {
|
||||
visibility: hidden;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
<!doctype>
|
||||
<html>
|
||||
<head>
|
||||
<style type="text/css">
|
||||
html, body {
|
||||
margin: 0; padding: 0;
|
||||
min-height: 100%;
|
||||
}
|
||||
|
||||
#debugger {
|
||||
height: 100%;
|
||||
font-family: "Monaco"
|
||||
}
|
||||
#debugger .line {
|
||||
overflow: none;
|
||||
}
|
||||
#debugger .col1, #debugger .col2 {
|
||||
float: left;
|
||||
padding: 3px;
|
||||
}
|
||||
#debugger .col1 {
|
||||
width: 10px;
|
||||
padding-left: 10px
|
||||
-webkit-touch-callout: none;
|
||||
-webkit-user-select: none;
|
||||
-khtml-user-select: none;
|
||||
-moz-user-select: none;
|
||||
-ms-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
#debugger .col2 {
|
||||
width: 90%;
|
||||
}
|
||||
.prompt {
|
||||
color: "#5089D4";
|
||||
}
|
||||
</style>
|
||||
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div id="debugger">
|
||||
<div class="line">
|
||||
<div class="col1 prompt">
|
||||
>
|
||||
</div>
|
||||
<div class="col2" contenteditable>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
.cm-s-eclipse span.cm-meta {color: #FF1717;}
|
||||
.cm-s-eclipse span.cm-keyword { line-height: 1em; font-weight: bold; color: #7F0055; }
|
||||
.cm-s-eclipse span.cm-atom {color: #219;}
|
||||
.cm-s-eclipse span.cm-number {color: #164;}
|
||||
.cm-s-eclipse span.cm-def {color: #00f;}
|
||||
.cm-s-eclipse span.cm-variable {color: black;}
|
||||
.cm-s-eclipse span.cm-variable-2 {color: #0000C0;}
|
||||
.cm-s-eclipse span.cm-variable-3 {color: #0000C0;}
|
||||
.cm-s-eclipse span.cm-property {color: black;}
|
||||
.cm-s-eclipse span.cm-operator {color: black;}
|
||||
.cm-s-eclipse span.cm-comment {color: #3F7F5F;}
|
||||
.cm-s-eclipse span.cm-string {color: #2A00FF;}
|
||||
.cm-s-eclipse span.cm-string-2 {color: #f50;}
|
||||
.cm-s-eclipse span.cm-qualifier {color: #555;}
|
||||
.cm-s-eclipse span.cm-builtin {color: #30a;}
|
||||
.cm-s-eclipse span.cm-bracket {color: #cc7;}
|
||||
.cm-s-eclipse span.cm-tag {color: #170;}
|
||||
.cm-s-eclipse span.cm-attribute {color: #00c;}
|
||||
.cm-s-eclipse span.cm-link {color: #219;}
|
||||
.cm-s-eclipse span.cm-error {color: #f00;}
|
||||
|
||||
.cm-s-eclipse .CodeMirror-activeline-background {background: #e8f2ff !important;}
|
||||
.cm-s-eclipse .CodeMirror-matchingbracket {outline:1px solid grey; color:black !important;}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
<!doctype>
|
||||
<html>
|
||||
<head>
|
||||
<title>Mutan Editor</title>
|
||||
<link rel="stylesheet" href="codemirror.css">
|
||||
<link rel="stylesheet" href="eclipse.css">
|
||||
<script src="lib/codemirror.js"></script>
|
||||
<script src="lib/matchbrackets.js"></script>
|
||||
<script src="lib/go.js"></script>
|
||||
<script src="muted.js"></script>
|
||||
|
||||
<style type="text/css">
|
||||
html, body {
|
||||
margin: 0; padding: 0;
|
||||
min-height: 100%;
|
||||
}
|
||||
|
||||
#debugger {
|
||||
height: 30%;
|
||||
font-family: "Monaco";
|
||||
border-top: 5px solid grey;
|
||||
}
|
||||
#debugger .line {
|
||||
overflow: none;
|
||||
}
|
||||
#debugger .col1, #debugger .col2 {
|
||||
float: left;
|
||||
padding: 3px;
|
||||
}
|
||||
#debugger .col1 {
|
||||
width: 10px;
|
||||
padding-left: 10px
|
||||
-webkit-touch-callout: none;
|
||||
-webkit-user-select: none;
|
||||
-khtml-user-select: none;
|
||||
-moz-user-select: none;
|
||||
-ms-user-select: none;
|
||||
user-select: none;
|
||||
}
|
||||
#debugger .col2 {
|
||||
width: 90%;
|
||||
}
|
||||
.prompt {
|
||||
color: "#5089D4";
|
||||
}
|
||||
|
||||
.CodeMirror {
|
||||
height: 70%;
|
||||
font-size: 14pt;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<textarea id="editor"></textarea>
|
||||
|
||||
<div id="debugger">
|
||||
<div class="line">
|
||||
<div class="col1 prompt">
|
||||
>
|
||||
</div>
|
||||
<div class="col2" contenteditable>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
var textArea = document.querySelector("#editor")
|
||||
var editor = CodeMirror.fromTextArea(textArea, {
|
||||
theme: "eclipse",
|
||||
mode: "text/html",
|
||||
lineNumbers: true,
|
||||
mode: "text/x-go",
|
||||
indentUnit: 8,
|
||||
tabSize: 8,
|
||||
indentWithTabs: true,
|
||||
});
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,182 @@
|
|||
(function(mod) {
|
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"));
|
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror"], mod);
|
||||
else // Plain browser env
|
||||
mod(CodeMirror);
|
||||
})(function(CodeMirror) {
|
||||
"use strict";
|
||||
|
||||
CodeMirror.defineMode("go", function(config) {
|
||||
var indentUnit = config.indentUnit;
|
||||
|
||||
var keywords = {
|
||||
"break":true, "case":true, "chan":true, "const":true, "continue":true,
|
||||
"default":true, "defer":true, "else":true, "fallthrough":true, "for":true,
|
||||
"func":true, "go":true, "goto":true, "if":true, "import":true,
|
||||
"interface":true, "map":true, "package":true, "range":true, "return":true,
|
||||
"select":true, "struct":true, "switch":true, "type":true, "var":true,
|
||||
"bool":true, "byte":true, "complex64":true, "complex128":true,
|
||||
"float32":true, "float64":true, "int8":true, "int16":true, "int32":true,
|
||||
"int64":true, "string":true, "uint8":true, "uint16":true, "uint32":true,
|
||||
"uint64":true, "int":true, "uint":true, "uintptr":true, "big": true,
|
||||
"main": true, "init": true, "this":true
|
||||
};
|
||||
|
||||
var atoms = {
|
||||
"true":true, "false":true, "iota":true, "nil":true, "append":true,
|
||||
"cap":true, "close":true, "complex":true, "copy":true, "imag":true,
|
||||
"len":true, "make":true, "new":true, "panic":true, "print":true,
|
||||
"println":true, "real":true, "recover":true,
|
||||
};
|
||||
|
||||
var isOperatorChar = /[+\-*&^%:=<>!|\/]/;
|
||||
|
||||
var curPunc;
|
||||
|
||||
function tokenBase(stream, state) {
|
||||
var ch = stream.next();
|
||||
if (ch == '"' || ch == "'" || ch == "`") {
|
||||
state.tokenize = tokenString(ch);
|
||||
return state.tokenize(stream, state);
|
||||
}
|
||||
if (/[\d\.]/.test(ch)) {
|
||||
if (ch == ".") {
|
||||
stream.match(/^[0-9]+([eE][\-+]?[0-9]+)?/);
|
||||
} else if (ch == "0") {
|
||||
stream.match(/^[xX][0-9a-fA-F]+/) || stream.match(/^0[0-7]+/);
|
||||
} else {
|
||||
stream.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/);
|
||||
}
|
||||
return "number";
|
||||
}
|
||||
if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
|
||||
curPunc = ch;
|
||||
return null;
|
||||
}
|
||||
if (ch == "/") {
|
||||
if (stream.eat("*")) {
|
||||
state.tokenize = tokenComment;
|
||||
return tokenComment(stream, state);
|
||||
}
|
||||
if (stream.eat("/")) {
|
||||
stream.skipToEnd();
|
||||
return "comment";
|
||||
}
|
||||
}
|
||||
if (isOperatorChar.test(ch)) {
|
||||
stream.eatWhile(isOperatorChar);
|
||||
return "operator";
|
||||
}
|
||||
stream.eatWhile(/[\w\$_]/);
|
||||
var cur = stream.current();
|
||||
if (keywords.propertyIsEnumerable(cur)) {
|
||||
if (cur == "case" || cur == "default") curPunc = "case";
|
||||
return "keyword";
|
||||
}
|
||||
if (atoms.propertyIsEnumerable(cur)) return "atom";
|
||||
return "variable";
|
||||
}
|
||||
|
||||
function tokenString(quote) {
|
||||
return function(stream, state) {
|
||||
var escaped = false, next, end = false;
|
||||
while ((next = stream.next()) != null) {
|
||||
if (next == quote && !escaped) {end = true; break;}
|
||||
escaped = !escaped && next == "\\";
|
||||
}
|
||||
if (end || !(escaped || quote == "`"))
|
||||
state.tokenize = tokenBase;
|
||||
return "string";
|
||||
};
|
||||
}
|
||||
|
||||
function tokenComment(stream, state) {
|
||||
var maybeEnd = false, ch;
|
||||
while (ch = stream.next()) {
|
||||
if (ch == "/" && maybeEnd) {
|
||||
state.tokenize = tokenBase;
|
||||
break;
|
||||
}
|
||||
maybeEnd = (ch == "*");
|
||||
}
|
||||
return "comment";
|
||||
}
|
||||
|
||||
function Context(indented, column, type, align, prev) {
|
||||
this.indented = indented;
|
||||
this.column = column;
|
||||
this.type = type;
|
||||
this.align = align;
|
||||
this.prev = prev;
|
||||
}
|
||||
function pushContext(state, col, type) {
|
||||
return state.context = new Context(state.indented, col, type, null, state.context);
|
||||
}
|
||||
function popContext(state) {
|
||||
var t = state.context.type;
|
||||
if (t == ")" || t == "]" || t == "}")
|
||||
state.indented = state.context.indented;
|
||||
return state.context = state.context.prev;
|
||||
}
|
||||
|
||||
// Interface
|
||||
|
||||
return {
|
||||
startState: function(basecolumn) {
|
||||
return {
|
||||
tokenize: null,
|
||||
context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
|
||||
indented: 0,
|
||||
startOfLine: true
|
||||
};
|
||||
},
|
||||
|
||||
token: function(stream, state) {
|
||||
var ctx = state.context;
|
||||
if (stream.sol()) {
|
||||
if (ctx.align == null) ctx.align = false;
|
||||
state.indented = stream.indentation();
|
||||
state.startOfLine = true;
|
||||
if (ctx.type == "case") ctx.type = "}";
|
||||
}
|
||||
if (stream.eatSpace()) return null;
|
||||
curPunc = null;
|
||||
var style = (state.tokenize || tokenBase)(stream, state);
|
||||
if (style == "comment") return style;
|
||||
if (ctx.align == null) ctx.align = true;
|
||||
|
||||
if (curPunc == "{") pushContext(state, stream.column(), "}");
|
||||
else if (curPunc == "[") pushContext(state, stream.column(), "]");
|
||||
else if (curPunc == "(") pushContext(state, stream.column(), ")");
|
||||
else if (curPunc == "case") ctx.type = "case";
|
||||
else if (curPunc == "}" && ctx.type == "}") ctx = popContext(state);
|
||||
else if (curPunc == ctx.type) popContext(state);
|
||||
state.startOfLine = false;
|
||||
return style;
|
||||
},
|
||||
|
||||
indent: function(state, textAfter) {
|
||||
if (state.tokenize != tokenBase && state.tokenize != null) return 0;
|
||||
var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
|
||||
if (ctx.type == "case" && /^(?:case|default)\b/.test(textAfter)) {
|
||||
state.context.type = "}";
|
||||
return ctx.indented;
|
||||
}
|
||||
var closing = firstChar == ctx.type;
|
||||
if (ctx.align) return ctx.column + (closing ? 0 : 1);
|
||||
else return ctx.indented + (closing ? 0 : indentUnit);
|
||||
},
|
||||
|
||||
electricChars: "{}):",
|
||||
fold: "brace",
|
||||
blockCommentStart: "/*",
|
||||
blockCommentEnd: "*/",
|
||||
lineComment: "//"
|
||||
};
|
||||
});
|
||||
|
||||
CodeMirror.defineMIME("text/x-go", "go");
|
||||
|
||||
});
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
(function(mod) {
|
||||
if (typeof exports == "object" && typeof module == "object") // CommonJS
|
||||
mod(require("../../lib/codemirror"));
|
||||
else if (typeof define == "function" && define.amd) // AMD
|
||||
define(["../../lib/codemirror"], mod);
|
||||
else // Plain browser env
|
||||
mod(CodeMirror);
|
||||
})(function(CodeMirror) {
|
||||
var ie_lt8 = /MSIE \d/.test(navigator.userAgent) &&
|
||||
(document.documentMode == null || document.documentMode < 8);
|
||||
|
||||
var Pos = CodeMirror.Pos;
|
||||
|
||||
var matching = {"(": ")>", ")": "(<", "[": "]>", "]": "[<", "{": "}>", "}": "{<"};
|
||||
|
||||
function findMatchingBracket(cm, where, strict, config) {
|
||||
var line = cm.getLineHandle(where.line), pos = where.ch - 1;
|
||||
var match = (pos >= 0 && matching[line.text.charAt(pos)]) || matching[line.text.charAt(++pos)];
|
||||
if (!match) return null;
|
||||
var dir = match.charAt(1) == ">" ? 1 : -1;
|
||||
if (strict && (dir > 0) != (pos == where.ch)) return null;
|
||||
var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
|
||||
|
||||
var found = scanForBracket(cm, Pos(where.line, pos + (dir > 0 ? 1 : 0)), dir, style || null, config);
|
||||
if (found == null) return null;
|
||||
return {from: Pos(where.line, pos), to: found && found.pos,
|
||||
match: found && found.ch == match.charAt(0), forward: dir > 0};
|
||||
}
|
||||
|
||||
// bracketRegex is used to specify which type of bracket to scan
|
||||
// should be a regexp, e.g. /[[\]]/
|
||||
//
|
||||
// Note: If "where" is on an open bracket, then this bracket is ignored.
|
||||
//
|
||||
// Returns false when no bracket was found, null when it reached
|
||||
// maxScanLines and gave up
|
||||
function scanForBracket(cm, where, dir, style, config) {
|
||||
var maxScanLen = (config && config.maxScanLineLength) || 10000;
|
||||
var maxScanLines = (config && config.maxScanLines) || 1000;
|
||||
|
||||
var stack = [];
|
||||
var re = config && config.bracketRegex ? config.bracketRegex : /[(){}[\]]/;
|
||||
var lineEnd = dir > 0 ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
|
||||
: Math.max(cm.firstLine() - 1, where.line - maxScanLines);
|
||||
for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
|
||||
var line = cm.getLine(lineNo);
|
||||
if (!line) continue;
|
||||
var pos = dir > 0 ? 0 : line.length - 1, end = dir > 0 ? line.length : -1;
|
||||
if (line.length > maxScanLen) continue;
|
||||
if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
|
||||
for (; pos != end; pos += dir) {
|
||||
var ch = line.charAt(pos);
|
||||
if (re.test(ch) && (style === undefined || cm.getTokenTypeAt(Pos(lineNo, pos + 1)) == style)) {
|
||||
var match = matching[ch];
|
||||
if ((match.charAt(1) == ">") == (dir > 0)) stack.push(ch);
|
||||
else if (!stack.length) return {pos: Pos(lineNo, pos), ch: ch};
|
||||
else stack.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine()) ? false : null;
|
||||
}
|
||||
|
||||
function matchBrackets(cm, autoclear, config) {
|
||||
// Disable brace matching in long lines, since it'll cause hugely slow updates
|
||||
var maxHighlightLen = cm.state.matchBrackets.maxHighlightLineLength || 1000;
|
||||
var marks = [], ranges = cm.listSelections();
|
||||
for (var i = 0; i < ranges.length; i++) {
|
||||
var match = ranges[i].empty() && findMatchingBracket(cm, ranges[i].head, false, config);
|
||||
if (match && cm.getLine(match.from.line).length <= maxHighlightLen) {
|
||||
var style = match.match ? "CodeMirror-matchingbracket" : "CodeMirror-nonmatchingbracket";
|
||||
marks.push(cm.markText(match.from, Pos(match.from.line, match.from.ch + 1), {className: style}));
|
||||
if (match.to && cm.getLine(match.to.line).length <= maxHighlightLen)
|
||||
marks.push(cm.markText(match.to, Pos(match.to.line, match.to.ch + 1), {className: style}));
|
||||
}
|
||||
}
|
||||
|
||||
if (marks.length) {
|
||||
// Kludge to work around the IE bug from issue #1193, where text
|
||||
// input stops going to the textare whever this fires.
|
||||
if (ie_lt8 && cm.state.focused) cm.display.input.focus();
|
||||
|
||||
var clear = function() {
|
||||
cm.operation(function() {
|
||||
for (var i = 0; i < marks.length; i++) marks[i].clear();
|
||||
});
|
||||
};
|
||||
if (autoclear) setTimeout(clear, 800);
|
||||
else return clear;
|
||||
}
|
||||
}
|
||||
|
||||
var currentlyHighlighted = null;
|
||||
function doMatchBrackets(cm) {
|
||||
cm.operation(function() {
|
||||
if (currentlyHighlighted) {currentlyHighlighted(); currentlyHighlighted = null;}
|
||||
currentlyHighlighted = matchBrackets(cm, false, cm.state.matchBrackets);
|
||||
});
|
||||
}
|
||||
|
||||
CodeMirror.defineOption("matchBrackets", false, function(cm, val, old) {
|
||||
if (old && old != CodeMirror.Init)
|
||||
cm.off("cursorActivity", doMatchBrackets);
|
||||
if (val) {
|
||||
cm.state.matchBrackets = typeof val == "object" ? val : {};
|
||||
cm.on("cursorActivity", doMatchBrackets);
|
||||
}
|
||||
});
|
||||
|
||||
CodeMirror.defineExtension("matchBrackets", function() {matchBrackets(this, true);});
|
||||
CodeMirror.defineExtension("findMatchingBracket", function(pos, strict, config){
|
||||
return findMatchingBracket(this, pos, strict, config);
|
||||
});
|
||||
CodeMirror.defineExtension("scanForBracket", function(pos, dir, style, config){
|
||||
return scanForBracket(this, pos, dir, style, config);
|
||||
});
|
||||
});
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
// Helper function for generating pseudo callbacks and sending data to the QML part of the application
|
||||
function postData(data, cb) {
|
||||
data._seed = Math.floor(Math.random() * 1000000)
|
||||
if(cb) {
|
||||
Muted._callbacks[data._seed] = cb;
|
||||
}
|
||||
|
||||
if(data.args === undefined) {
|
||||
data.args = [];
|
||||
}
|
||||
|
||||
navigator.qt.postMessage(JSON.stringify(data));
|
||||
}
|
||||
|
||||
window.Muted = {
|
||||
prototype: Object(),
|
||||
}
|
||||
|
||||
window.Muted._callbacks = {}
|
||||
window.Muted._onCallbacks = {}
|
||||
|
||||
function debug(/**/) {
|
||||
console.log("hello world")
|
||||
|
||||
var args = arguments;
|
||||
var msg = ""
|
||||
for(var i = 0; i < args.length; i++){
|
||||
if(typeof args[i] == "object") {
|
||||
msg += " " + JSON.stringify(args[i])
|
||||
} else {
|
||||
msg += args[i]
|
||||
}
|
||||
}
|
||||
|
||||
document.querySelector("#debugger").innerHTML += "<div class='line'><div class='col1'></div><div class='col2'>"+msg+"</div></div>";
|
||||
}
|
||||
console.log = function() {
|
||||
var args = []
|
||||
for(var i = 0; i < arguments.length; i++) {
|
||||
args.push(arguments[i]);
|
||||
}
|
||||
postData({call:"log", args:args})
|
||||
}
|
||||
|
||||
navigator.qt.onmessage = function(ev) {
|
||||
var data = JSON.parse(ev.data)
|
||||
|
||||
if(data._event !== undefined) {
|
||||
Muted.trigger(data._event, data.data);
|
||||
} else {
|
||||
if(data._seed) {
|
||||
var cb = Muted._callbacks[data._seed];
|
||||
if(cb) {
|
||||
// Call the callback
|
||||
cb(data.data);
|
||||
// Remove the "trigger" callback
|
||||
delete Muted._callbacks[ev._seed];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.7 KiB |
|
|
@ -0,0 +1,22 @@
|
|||
import QtQuick 2.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import Ethereum 1.0
|
||||
|
||||
ApplicationWindow {
|
||||
minimumWidth: 500
|
||||
maximumWidth: 500
|
||||
maximumHeight: 400
|
||||
minimumHeight: 400
|
||||
|
||||
function onNewBlockCb(block) {
|
||||
console.log("Please overwrite onNewBlock(block):", block)
|
||||
}
|
||||
function onObjectChangeCb(stateObject) {
|
||||
console.log("Please overwrite onObjectChangeCb(object)", stateObject)
|
||||
}
|
||||
function onStorageChangeCb(storageObject) {
|
||||
var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
|
||||
console.log("Please overwrite onStorageChangeCb(object)", ev)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,155 @@
|
|||
import QtQuick 2.0
|
||||
import Ethereum 1.0
|
||||
|
||||
// Which ones do we actually need?
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import QtQuick.Dialogs 1.0;
|
||||
import QtQuick.Window 2.1;
|
||||
import QtQuick.Controls.Styles 1.1
|
||||
import QtQuick.Dialogs 1.1
|
||||
|
||||
ApplicationWindow {
|
||||
id: wizardRoot
|
||||
width: 500
|
||||
height: 400
|
||||
title: "Ethereal first run setup"
|
||||
|
||||
Column {
|
||||
spacing: 5
|
||||
anchors.leftMargin: 10
|
||||
anchors.left: parent.left
|
||||
|
||||
Text {
|
||||
visible: true
|
||||
text: "<h2>Ethereal setup</h2>"
|
||||
}
|
||||
|
||||
Column {
|
||||
id: restoreColumn
|
||||
spacing: 5
|
||||
Text {
|
||||
visible: true
|
||||
font.pointSize: 14
|
||||
text: "Restore your Ethereum account"
|
||||
id: restoreLabel
|
||||
}
|
||||
|
||||
TextField {
|
||||
id: txPrivKey
|
||||
width: 480
|
||||
placeholderText: "Private key or mnemonic words"
|
||||
focus: true
|
||||
onTextChanged: {
|
||||
if(this.text.length == 64){
|
||||
detailLabel.text = "Private (hex) key detected."
|
||||
actionButton.enabled = true
|
||||
}
|
||||
else if(this.text.split(" ").length == 24){
|
||||
detailLabel.text = "Mnemonic key detected."
|
||||
actionButton.enabled = true
|
||||
}else{
|
||||
detailLabel.text = ""
|
||||
actionButton.enabled = false
|
||||
}
|
||||
}
|
||||
}
|
||||
Row {
|
||||
spacing: 10
|
||||
Button {
|
||||
id: actionButton
|
||||
text: "Restore"
|
||||
enabled: false
|
||||
onClicked: {
|
||||
var success = lib.importAndSetPrivKey(txPrivKey.text)
|
||||
if(success){
|
||||
importedDetails.visible = true
|
||||
restoreColumn.visible = false
|
||||
newKey.visible = false
|
||||
wizardRoot.height = 120
|
||||
}
|
||||
}
|
||||
}
|
||||
Text {
|
||||
id: detailLabel
|
||||
font.pointSize: 12
|
||||
anchors.topMargin: 10
|
||||
}
|
||||
}
|
||||
}
|
||||
Column {
|
||||
id: importedDetails
|
||||
visible: false
|
||||
Text {
|
||||
text: "<b>Your account has been imported. Please close the application and restart it again to let the changes take effect.</b>"
|
||||
wrapMode: Text.WordWrap
|
||||
width: 460
|
||||
}
|
||||
}
|
||||
Column {
|
||||
spacing: 5
|
||||
id: newDetailsColumn
|
||||
visible: false
|
||||
Text {
|
||||
font.pointSize: 14
|
||||
text: "Your account details"
|
||||
}
|
||||
Label {
|
||||
text: "Address"
|
||||
}
|
||||
TextField {
|
||||
id: addressInput
|
||||
readOnly:true
|
||||
width: 480
|
||||
}
|
||||
Label {
|
||||
text: "Private key"
|
||||
}
|
||||
TextField {
|
||||
id: privkeyInput
|
||||
readOnly:true
|
||||
width: 480
|
||||
}
|
||||
Label {
|
||||
text: "Mnemonic words"
|
||||
}
|
||||
TextField {
|
||||
id: mnemonicInput
|
||||
readOnly:true
|
||||
width: 480
|
||||
}
|
||||
Label {
|
||||
text: "<b>A new account has been created. Please take the time to write down the <i>24 words</i>. You can use those to restore your account at a later date.</b>"
|
||||
wrapMode: Text.WordWrap
|
||||
width: 480
|
||||
}
|
||||
Label {
|
||||
text: "Please restart the application once you have completed the steps above."
|
||||
wrapMode: Text.WordWrap
|
||||
width: 480
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Button {
|
||||
anchors.right: parent.right
|
||||
anchors.bottom: parent.bottom
|
||||
anchors.rightMargin: 10
|
||||
anchors.bottomMargin: 10
|
||||
id: newKey
|
||||
text: "I don't have an account yet"
|
||||
onClicked: {
|
||||
var res = lib.createAndSetPrivKey()
|
||||
mnemonicInput.text = res[0]
|
||||
addressInput.text = res[1]
|
||||
privkeyInput.text = res[2]
|
||||
|
||||
// Hide restore
|
||||
restoreColumn.visible = false
|
||||
|
||||
// Show new details
|
||||
newDetailsColumn.visible = true
|
||||
newKey.visible = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
import QtQuick 2.0
|
||||
import QtWebKit 3.0
|
||||
import QtWebKit.experimental 1.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import QtQuick.Window 2.1;
|
||||
import Ethereum 1.0
|
||||
|
||||
ApplicationWindow {
|
||||
id: window
|
||||
title: "muted"
|
||||
width: 900
|
||||
height: 600
|
||||
minimumHeight: 300
|
||||
|
||||
property alias url: webView.url
|
||||
property alias webView: webView
|
||||
|
||||
|
||||
Item {
|
||||
id: root
|
||||
anchors.fill: parent
|
||||
WebView {
|
||||
objectName: "webView"
|
||||
id: webView
|
||||
anchors {
|
||||
top: root.top
|
||||
right: root.right
|
||||
left: root.left
|
||||
bottom: root.bottom
|
||||
//bottom: sizeGrip.top
|
||||
}
|
||||
|
||||
experimental.preferences.javascriptEnabled: true
|
||||
experimental.preferences.navigatorQtObjectEnabled: true
|
||||
experimental.onMessageReceived: {
|
||||
var data = JSON.parse(message.data)
|
||||
|
||||
switch(data.call) {
|
||||
case "log":
|
||||
console.log.apply(this, data.args)
|
||||
break;
|
||||
}
|
||||
}
|
||||
function postData(seed, data) {
|
||||
webview.experimental.postMessage(JSON.stringify({data: data, _seed: seed}))
|
||||
}
|
||||
function postEvent(event, data) {
|
||||
webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Rectangle {
|
||||
id: sizeGrip
|
||||
color: "gray"
|
||||
height: 5
|
||||
anchors {
|
||||
left: root.left
|
||||
right: root.right
|
||||
}
|
||||
y: Math.round(root.height * 2 / 3)
|
||||
|
||||
MouseArea {
|
||||
anchors.fill: parent
|
||||
drag.target: sizeGrip
|
||||
drag.minimumY: 0
|
||||
drag.maximumY: root.height - sizeGrip.height
|
||||
drag.axis: Drag.YAxis
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
import QtQuick 2.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import Ethereum 1.0
|
||||
|
||||
QmlApp {
|
||||
minimumWidth: 350
|
||||
maximumWidth: 350
|
||||
maximumHeight: 80
|
||||
minimumHeight: 80
|
||||
|
||||
title: "Generic Coin"
|
||||
|
||||
property string contractAddr: "f299f6c74515620e4c4cd8fe3d205b5c4f2e25c8"
|
||||
property string addr: "2ef47100e0787b915105fd5e3f4ff6752079d5cb"
|
||||
|
||||
Component.onCompleted: {
|
||||
eth.watch(contractAddr, addr)
|
||||
eth.watch(addr, contractAddr)
|
||||
setAmount()
|
||||
}
|
||||
|
||||
function onStorageChangeCb(storageObject) {
|
||||
setAmount()
|
||||
}
|
||||
|
||||
function setAmount(){
|
||||
var state = eth.getStateObject(contractAddr)
|
||||
var storage = state.getStorage(addr)
|
||||
amountLabel.text = storage
|
||||
}
|
||||
Column {
|
||||
spacing: 5
|
||||
Row {
|
||||
spacing: 20
|
||||
Label {
|
||||
id: genLabel
|
||||
text: "Generic coin balance:"
|
||||
}
|
||||
Label {
|
||||
id: amountLabel
|
||||
}
|
||||
}
|
||||
Row {
|
||||
spacing: 20
|
||||
TextField {
|
||||
id: address
|
||||
placeholderText: "Address"
|
||||
}
|
||||
TextField {
|
||||
id: amount
|
||||
placeholderText: "Amount"
|
||||
}
|
||||
}
|
||||
Button {
|
||||
text: "Send coins"
|
||||
onClicked: {
|
||||
var privKey = eth.getKey().privateKey
|
||||
if(privKey){
|
||||
var result = eth.transact(privKey, contractAddr, 0,"100000","250", "0x" + address.text + "\n" + amount.text)
|
||||
resultTx.text = result.hash
|
||||
}
|
||||
}
|
||||
}
|
||||
Label {
|
||||
id: resultTx
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
import QtQuick 2.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
|
||||
Rectangle {
|
||||
id: transactionView
|
||||
visible: false
|
||||
Text { text: "TX VIEW" }
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,246 @@
|
|||
import QtQuick 2.0
|
||||
import QtWebKit 3.0
|
||||
import QtWebKit.experimental 1.0
|
||||
import QtQuick.Controls 1.0;
|
||||
import QtQuick.Layouts 1.0;
|
||||
import QtQuick.Window 2.1;
|
||||
import Ethereum 1.0
|
||||
|
||||
ApplicationWindow {
|
||||
id: window
|
||||
title: "Ethereum"
|
||||
width: 900
|
||||
height: 600
|
||||
minimumHeight: 300
|
||||
|
||||
property alias url: webview.url
|
||||
property alias webView: webview
|
||||
|
||||
Item {
|
||||
objectName: "root"
|
||||
id: root
|
||||
anchors.fill: parent
|
||||
state: "inspectorShown"
|
||||
|
||||
WebView {
|
||||
objectName: "webView"
|
||||
id: webview
|
||||
anchors.fill: parent
|
||||
/*
|
||||
anchors {
|
||||
left: parent.left
|
||||
right: parent.right
|
||||
bottom: sizeGrip.top
|
||||
top: parent.top
|
||||
}
|
||||
*/
|
||||
onTitleChanged: { window.title = title }
|
||||
experimental.preferences.javascriptEnabled: true
|
||||
experimental.preferences.navigatorQtObjectEnabled: true
|
||||
experimental.preferences.developerExtrasEnabled: true
|
||||
experimental.userScripts: [ui.assetPath("ext/pre.js"), ui.assetPath("ext/big.js"), ui.assetPath("ext/string.js"), ui.assetPath("ext/ethereum.js")]
|
||||
experimental.onMessageReceived: {
|
||||
console.log("[onMessageReceived]: ", message.data)
|
||||
// TODO move to messaging.js
|
||||
var data = JSON.parse(message.data)
|
||||
|
||||
try {
|
||||
switch(data.call) {
|
||||
case "getCoinBase":
|
||||
postData(data._seed, eth.getCoinBase())
|
||||
|
||||
break
|
||||
case "getIsListening":
|
||||
postData(data._seed, eth.getIsListening())
|
||||
|
||||
break
|
||||
case "getIsMining":
|
||||
postData(data._seed, eth.getIsMining())
|
||||
|
||||
break
|
||||
case "getPeerCount":
|
||||
postData(data._seed, eth.getPeerCount())
|
||||
|
||||
break
|
||||
|
||||
case "getTxCountAt":
|
||||
require(1)
|
||||
postData(data._seed, eth.getTxCountAt(data.args[0]))
|
||||
|
||||
break
|
||||
case "getBlockByNumber":
|
||||
var block = eth.getBlock(data.args[0])
|
||||
postData(data._seed, block)
|
||||
|
||||
break
|
||||
case "getBlockByHash":
|
||||
var block = eth.getBlock(data.args[0])
|
||||
postData(data._seed, block)
|
||||
|
||||
break
|
||||
case "transact":
|
||||
require(5)
|
||||
|
||||
var tx = eth.transact(data.args[0], data.args[1], data.args[2],data.args[3],data.args[4],data.args[5])
|
||||
postData(data._seed, tx)
|
||||
|
||||
break
|
||||
case "create":
|
||||
postData(data._seed, null)
|
||||
|
||||
break
|
||||
case "getStorage":
|
||||
require(2);
|
||||
|
||||
var stateObject = eth.getStateObject(data.args[0])
|
||||
var storage = stateObject.getStorage(data.args[1])
|
||||
postData(data._seed, storage)
|
||||
|
||||
break
|
||||
case "getStateKeyVals":
|
||||
require(1);
|
||||
var stateObject = eth.getStateObject(data.args[0]).stateKeyVal(true)
|
||||
postData(data._seed,stateObject)
|
||||
|
||||
break
|
||||
case "getTransactionsFor":
|
||||
require(1);
|
||||
var txs = eth.getTransactionsFor(data.args[0], true)
|
||||
postData(data._seed, txs)
|
||||
|
||||
break
|
||||
case "getBalance":
|
||||
require(1);
|
||||
|
||||
postData(data._seed, eth.getStateObject(data.args[0]).value());
|
||||
|
||||
break
|
||||
case "getKey":
|
||||
var key = eth.getKey().privateKey;
|
||||
|
||||
postData(data._seed, key)
|
||||
break
|
||||
case "watch":
|
||||
require(1)
|
||||
eth.watch(data.args[0], data.args[1]);
|
||||
break
|
||||
case "disconnect":
|
||||
require(1)
|
||||
postData(data._seed, null)
|
||||
break;
|
||||
case "set":
|
||||
console.log("'Set' has been depcrecated")
|
||||
/*
|
||||
for(var key in data.args) {
|
||||
if(webview.hasOwnProperty(key)) {
|
||||
window[key] = data.args[key];
|
||||
}
|
||||
}
|
||||
*/
|
||||
break;
|
||||
case "getSecretToAddress":
|
||||
require(1)
|
||||
postData(data._seed, eth.secretToAddress(data.args[0]))
|
||||
break;
|
||||
case "debug":
|
||||
console.log(data.args[0]);
|
||||
break;
|
||||
}
|
||||
} catch(e) {
|
||||
console.log(data.call + ": " + e)
|
||||
|
||||
postData(data._seed, null);
|
||||
}
|
||||
}
|
||||
|
||||
function require(args, num) {
|
||||
if(args.length < num) {
|
||||
throw("required argument count of "+num+" got "+args.length);
|
||||
}
|
||||
}
|
||||
function postData(seed, data) {
|
||||
webview.experimental.postMessage(JSON.stringify({data: data, _seed: seed}))
|
||||
}
|
||||
function postEvent(event, data) {
|
||||
webview.experimental.postMessage(JSON.stringify({data: data, _event: event}))
|
||||
}
|
||||
|
||||
function onNewBlockCb(block) {
|
||||
postEvent("block:new", block)
|
||||
}
|
||||
function onObjectChangeCb(stateObject) {
|
||||
postEvent("object:"+stateObject.address(), stateObject)
|
||||
}
|
||||
function onStorageChangeCb(storageObject) {
|
||||
var ev = ["storage", storageObject.stateAddress, storageObject.address].join(":");
|
||||
postEvent(ev, [storageObject.address, storageObject.value])
|
||||
}
|
||||
}
|
||||
Rectangle {
|
||||
id: toggleInspector
|
||||
color: "#bcbcbc"
|
||||
visible: true
|
||||
height: 12
|
||||
width: 12
|
||||
anchors {
|
||||
right: root.right
|
||||
}
|
||||
MouseArea {
|
||||
onClicked: {
|
||||
if(inspector.visible == true){
|
||||
inspector.visible = false
|
||||
}else{
|
||||
inspector.visible = true
|
||||
}
|
||||
}
|
||||
onDoubleClicked: {
|
||||
console.log('refreshing')
|
||||
webView.reload()
|
||||
}
|
||||
anchors.fill: parent
|
||||
}
|
||||
}
|
||||
|
||||
Rectangle {
|
||||
id: sizeGrip
|
||||
color: "gray"
|
||||
visible: false
|
||||
height: 10
|
||||
anchors {
|
||||
left: root.left
|
||||
right: root.right
|
||||
}
|
||||
y: Math.round(root.height * 2 / 3)
|
||||
|
||||
MouseArea {
|
||||
anchors.fill: parent
|
||||
drag.target: sizeGrip
|
||||
drag.minimumY: 0
|
||||
drag.maximumY: root.height
|
||||
drag.axis: Drag.YAxis
|
||||
}
|
||||
}
|
||||
|
||||
WebView {
|
||||
id: inspector
|
||||
visible: false
|
||||
url: webview.experimental.remoteInspectorUrl
|
||||
anchors {
|
||||
left: root.left
|
||||
right: root.right
|
||||
top: sizeGrip.bottom
|
||||
bottom: root.bottom
|
||||
}
|
||||
}
|
||||
|
||||
states: [
|
||||
State {
|
||||
name: "inspectorShown"
|
||||
PropertyChanges {
|
||||
target: inspector
|
||||
url: webview.experimental.remoteInspectorUrl
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
Binary file not shown.
|
After Width: | Height: | Size: 85 KiB |
|
|
@ -0,0 +1,34 @@
|
|||
/* Space out content a bit */
|
||||
body {
|
||||
padding-top: 20px;
|
||||
padding-bottom: 20px;
|
||||
}
|
||||
|
||||
/* Everything but the jumbotron gets side spacing for mobile first
|
||||
* views */
|
||||
.header,
|
||||
.marketing,
|
||||
.footer {
|
||||
padding-right: 15px;
|
||||
padding-left: 15px;
|
||||
}
|
||||
|
||||
/* Custom page header */
|
||||
.header {
|
||||
border-bottom: 1px solid #e5e5e5;
|
||||
}
|
||||
/* Make the masthead heading the same height as the navigation */
|
||||
.header h3 {
|
||||
padding-bottom: 19px;
|
||||
margin-top: 0;
|
||||
margin-bottom: 0;
|
||||
line-height: 40px;
|
||||
}
|
||||
|
||||
.jumbotron {
|
||||
text-align: center;
|
||||
border-bottom: 1px solid #e5e5e5;
|
||||
|
||||
margin: 0 auto;
|
||||
width: 300px;
|
||||
}
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
<html>
|
||||
<head>
|
||||
<title>jeffcoin</title>
|
||||
|
||||
<link rel="stylesheet" href="bootstrap.min.css">
|
||||
<link rel="stylesheet" href="bootstrap-theme.min.css">
|
||||
<link rel="stylesheet" href="samplecoin.css">
|
||||
<meta name="viewport" content="minimum-scale=1; maximum-scale=1; initial-scale=1;">
|
||||
|
||||
<script type="text/javascript">
|
||||
|
||||
var jefcoinAddr = "22fa3ebce6ef9ca661a960104d3087eec040011e"
|
||||
var mAddr = ""
|
||||
|
||||
function createTransaction() {
|
||||
var addr = ("0x" + document.querySelector("#addr").value).pad(32);
|
||||
var amount = document.querySelector("#amount").value.pad(32);
|
||||
|
||||
var data = (addr + amount).unbin();
|
||||
eth.transact(mAddr, jefcoinAddr, 0, "50000", "1000000", data, function(receipt) {
|
||||
debug("received tx hash:", reciept.address)
|
||||
})
|
||||
}
|
||||
|
||||
function init() {
|
||||
eth.getKey(function(sec) {
|
||||
mAddr = sec;
|
||||
eth.getSecretToAddress(sec, function(addr) {
|
||||
eth.getStorageAt(jefcoinAddr, addr, function(storage) {
|
||||
document.querySelector("#current-amount").innerHTML = storage;
|
||||
});
|
||||
|
||||
eth.watch(jefcoinAddr, addr, function(addr, value) {
|
||||
document.querySelector("#current-amount").innerHTML = value
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
</script>
|
||||
</head>
|
||||
|
||||
<body onload="init();">
|
||||
<div class="container">
|
||||
<div class="header">
|
||||
<h3 class="text-muted">JeffCoin</h3>
|
||||
</div>
|
||||
|
||||
<div class="jumbotron ">
|
||||
<img src="icon.png">
|
||||
<div>Amount: <strong id="current-amount"></strong></div>
|
||||
|
||||
<div id="transactions">
|
||||
<div class="form-group">
|
||||
<input id="addr" class="form-control" type="text" placeholder="Receiver address"></input><br>
|
||||
<input id="amount" class="form-control" type="text" placeholder="Amount"></input><br>
|
||||
</div>
|
||||
|
||||
<button class="btn btn-default" onclick="createTransaction();">Send Tx</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div id="debug" style="border: 1px solid black; min-height: 30px;"></div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 4.0 KiB |
|
|
@ -0,0 +1,43 @@
|
|||
<html>
|
||||
<head>
|
||||
<title>Utils</title>
|
||||
</head>
|
||||
<body onload="init();">
|
||||
<label>Nonce for 2ef47100e0787b915105fd5e3f4ff6752079d5cb</label>
|
||||
<p id="nonce"></p>
|
||||
|
||||
<label>Connected peers</label>
|
||||
<p id="peers"></p>
|
||||
|
||||
<label>Is mining</label>
|
||||
<p id="isMining"></p>
|
||||
|
||||
<label>Is listening</label>
|
||||
<p id="isListen"></p>
|
||||
|
||||
<label>Coinbase</label>
|
||||
<p id="coinbase"></p>
|
||||
|
||||
<script type="text/javascript">
|
||||
|
||||
function init() {
|
||||
eth.getTxCountAt("2ef47100e0787b915105fd5e3f4ff6752079d5cb", function(nonce){
|
||||
document.querySelector("#nonce").innerHTML = nonce;
|
||||
})
|
||||
eth.getPeerCount(function(peerLength){
|
||||
document.querySelector("#peers").innerHTML = peerLength;
|
||||
})
|
||||
eth.getIsMining(function(mining){
|
||||
document.querySelector("#isMining").innerHTML = mining;
|
||||
})
|
||||
eth.getIsListening(function(listen){
|
||||
document.querySelector("#isListen").innerHTML = listen;
|
||||
})
|
||||
eth.getCoinBase(function(address){
|
||||
document.querySelector("#coinbase").innerHTML = address;
|
||||
})
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bitbucket.org/kardianos/osext"
|
||||
"flag"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"os"
|
||||
"os/user"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
)
|
||||
|
||||
var Identifier string
|
||||
var KeyRing string
|
||||
var KeyStore string
|
||||
var StartRpc bool
|
||||
var RpcPort int
|
||||
var UseUPnP bool
|
||||
var OutboundPort string
|
||||
var ShowGenesis bool
|
||||
var AddPeer string
|
||||
var MaxPeer int
|
||||
var GenAddr bool
|
||||
var UseSeed bool
|
||||
var SecretFile string
|
||||
var ExportDir string
|
||||
var NonInteractive bool
|
||||
var Datadir string
|
||||
var LogFile string
|
||||
var ConfigFile string
|
||||
var DebugFile string
|
||||
var LogLevel int
|
||||
|
||||
// flags specific to gui client
|
||||
var AssetPath string
|
||||
|
||||
func defaultAssetPath() string {
|
||||
var assetPath string
|
||||
// If the current working directory is the go-ethereum dir
|
||||
// assume a debug build and use the source directory as
|
||||
// asset directory.
|
||||
pwd, _ := os.Getwd()
|
||||
if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal") {
|
||||
assetPath = path.Join(pwd, "assets")
|
||||
} else {
|
||||
switch runtime.GOOS {
|
||||
case "darwin":
|
||||
// Get Binary Directory
|
||||
exedir, _ := osext.ExecutableFolder()
|
||||
assetPath = filepath.Join(exedir, "../Resources")
|
||||
case "linux":
|
||||
assetPath = "/usr/share/ethereal"
|
||||
case "window":
|
||||
fallthrough
|
||||
default:
|
||||
assetPath = "."
|
||||
}
|
||||
}
|
||||
return assetPath
|
||||
}
|
||||
|
||||
func defaultDataDir() string {
|
||||
usr, _ := user.Current()
|
||||
return path.Join(usr.HomeDir, ".ethereal")
|
||||
}
|
||||
|
||||
var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
|
||||
|
||||
func Init() {
|
||||
flag.Usage = func() {
|
||||
fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
|
||||
flag.PrintDefaults()
|
||||
}
|
||||
|
||||
flag.StringVar(&Identifier, "id", "", "Custom client identifier")
|
||||
flag.StringVar(&KeyRing, "keyring", "", "identifier for keyring to use")
|
||||
flag.StringVar(&KeyStore, "keystore", "db", "system to store keyrings: db|file (db)")
|
||||
flag.StringVar(&OutboundPort, "port", "30303", "listening port")
|
||||
flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
|
||||
flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers")
|
||||
flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
|
||||
flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
|
||||
flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
|
||||
flag.BoolVar(&UseSeed, "seed", true, "seed peers")
|
||||
flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
|
||||
flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
|
||||
flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
|
||||
flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
|
||||
flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
|
||||
flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
|
||||
flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
|
||||
flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
|
||||
|
||||
flag.StringVar(&AssetPath, "asset_path", defaultAssetPath(), "absolute path to GUI assets directory")
|
||||
|
||||
flag.Parse()
|
||||
}
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"github.com/ethereum/go-ethereum/ethereal/ui"
|
||||
"github.com/ethereum/go-ethereum/utils"
|
||||
"github.com/go-qml/qml"
|
||||
"os"
|
||||
"runtime"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Leave QT on top at ALL times. Qt Needs to be initialized from the main thread
|
||||
qml.Init(nil)
|
||||
|
||||
runtime.GOMAXPROCS(runtime.NumCPU())
|
||||
|
||||
var interrupted = false
|
||||
utils.RegisterInterrupt(func(os.Signal) {
|
||||
interrupted = true
|
||||
})
|
||||
|
||||
utils.HandleInterrupt()
|
||||
|
||||
// precedence: code-internal flag default < config file < environment variables < command line
|
||||
Init() // parsing command line
|
||||
utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
|
||||
|
||||
utils.InitDataDir(Datadir)
|
||||
|
||||
utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
|
||||
|
||||
db := utils.NewDatabase()
|
||||
|
||||
keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
|
||||
|
||||
// create, import, export keys
|
||||
utils.KeyTasks(keyManager, KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
|
||||
|
||||
ethereum := utils.NewEthereum(db, keyManager, UseUPnP, OutboundPort, MaxPeer)
|
||||
|
||||
if ShowGenesis {
|
||||
utils.ShowGenesis(ethereum)
|
||||
}
|
||||
|
||||
if StartRpc {
|
||||
utils.StartRpc(ethereum, RpcPort)
|
||||
}
|
||||
|
||||
gui := ethui.New(ethereum, KeyRing, LogLevel)
|
||||
|
||||
utils.RegisterInterrupt(func(os.Signal) {
|
||||
gui.Stop()
|
||||
})
|
||||
utils.StartEthereum(ethereum, UseSeed)
|
||||
// gui blocks the main thread
|
||||
gui.Start(AssetPath)
|
||||
// we need to run the interrupt callbacks in case gui is closed
|
||||
// this skips if we got here by actual interrupt stopping the GUI
|
||||
if !interrupted {
|
||||
utils.RunInterruptCallbacks(os.Interrupt)
|
||||
}
|
||||
// this blocks the thread
|
||||
ethereum.WaitForShutdown()
|
||||
ethlog.Flush()
|
||||
}
|
||||
|
|
@ -0,0 +1,234 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/go-qml/qml"
|
||||
"math/big"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type DebuggerWindow struct {
|
||||
win *qml.Window
|
||||
engine *qml.Engine
|
||||
lib *UiLib
|
||||
Db *Debugger
|
||||
}
|
||||
|
||||
func NewDebuggerWindow(lib *UiLib) *DebuggerWindow {
|
||||
engine := qml.NewEngine()
|
||||
component, err := engine.LoadFile(lib.AssetPath("debugger/debugger.qml"))
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
win := component.CreateWindow(nil)
|
||||
db := &Debugger{win, make(chan bool), make(chan bool), true, false, true}
|
||||
|
||||
return &DebuggerWindow{engine: engine, win: win, lib: lib, Db: db}
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) Show() {
|
||||
context := self.engine.Context()
|
||||
context.SetVar("dbg", self)
|
||||
|
||||
go func() {
|
||||
self.win.Show()
|
||||
self.win.Wait()
|
||||
}()
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) SetCode(code string) {
|
||||
self.win.Set("codeText", code)
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) SetData(data string) {
|
||||
self.win.Set("dataText", data)
|
||||
}
|
||||
func (self *DebuggerWindow) SetAsm(data string) {
|
||||
dis := ethchain.Disassemble(ethutil.Hex2Bytes(data))
|
||||
for _, str := range dis {
|
||||
self.win.Root().Call("setAsm", str)
|
||||
}
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) Debug(valueStr, gasStr, gasPriceStr, scriptStr, dataStr string) {
|
||||
if !self.Db.done {
|
||||
self.Db.Q <- true
|
||||
}
|
||||
self.Db.breakOnInstr = self.win.Root().ObjectByName("breakEachLine").Bool("checked")
|
||||
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
self.Logf("compile FAULT: %v", r)
|
||||
}
|
||||
}()
|
||||
|
||||
data := ethutil.StringToByteFunc(dataStr, func(s string) (ret []byte) {
|
||||
slice := strings.Split(dataStr, "\n")
|
||||
for _, dataItem := range slice {
|
||||
d := ethutil.FormatData(dataItem)
|
||||
ret = append(ret, d...)
|
||||
}
|
||||
return
|
||||
})
|
||||
|
||||
var err error
|
||||
script := ethutil.StringToByteFunc(scriptStr, func(s string) (ret []byte) {
|
||||
ret, err = ethutil.Compile(s)
|
||||
return
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
self.Logln(err)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
dis := ethchain.Disassemble(script)
|
||||
self.win.Root().Call("clearAsm")
|
||||
self.win.Root().Call("clearLog")
|
||||
|
||||
for _, str := range dis {
|
||||
self.win.Root().Call("setAsm", str)
|
||||
}
|
||||
|
||||
var (
|
||||
gas = ethutil.Big(gasStr)
|
||||
gasPrice = ethutil.Big(gasPriceStr)
|
||||
value = ethutil.Big(valueStr)
|
||||
// Contract addr as test address
|
||||
keyPair = self.lib.eth.KeyManager().KeyPair()
|
||||
callerTx = ethchain.NewContractCreationTx(ethutil.Big(valueStr), gas, gasPrice, script)
|
||||
)
|
||||
callerTx.Sign(keyPair.PrivateKey)
|
||||
|
||||
state := self.lib.eth.BlockChain().CurrentBlock.State()
|
||||
account := self.lib.eth.StateManager().TransState().GetAccount(keyPair.Address())
|
||||
contract := ethchain.MakeContract(callerTx, state)
|
||||
contract.Amount = value
|
||||
callerClosure := ethchain.NewClosure(account, contract, script, state, gas, gasPrice)
|
||||
|
||||
block := self.lib.eth.BlockChain().CurrentBlock
|
||||
vm := ethchain.NewVm(state, self.lib.eth.StateManager(), ethchain.RuntimeVars{
|
||||
Block: block,
|
||||
Origin: account.Address(),
|
||||
BlockNumber: block.Number,
|
||||
PrevHash: block.PrevHash,
|
||||
Coinbase: block.Coinbase,
|
||||
Time: block.Time,
|
||||
Diff: block.Difficulty,
|
||||
Value: ethutil.Big(valueStr),
|
||||
})
|
||||
vm.Verbose = true
|
||||
|
||||
self.Db.done = false
|
||||
self.Logf("callsize %d", len(script))
|
||||
go func() {
|
||||
ret, g, err := callerClosure.Call(vm, data, self.Db.halting)
|
||||
tot := new(big.Int).Mul(g, gasPrice)
|
||||
self.Logf("gas usage %v total price = %v (%v)", g, tot, ethutil.CurrencyToString(tot))
|
||||
if err != nil {
|
||||
self.Logln("exited with errors:", err)
|
||||
} else {
|
||||
if len(ret) > 0 {
|
||||
self.Logf("exited: % x", ret)
|
||||
} else {
|
||||
self.Logf("exited: nil")
|
||||
}
|
||||
}
|
||||
|
||||
state.Reset()
|
||||
|
||||
if !self.Db.interrupt {
|
||||
self.Db.done = true
|
||||
} else {
|
||||
self.Db.interrupt = false
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) Logf(format string, v ...interface{}) {
|
||||
self.win.Root().Call("setLog", fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) Logln(v ...interface{}) {
|
||||
str := fmt.Sprintln(v...)
|
||||
self.Logf("%s", str[:len(str)-1])
|
||||
}
|
||||
|
||||
func (self *DebuggerWindow) Next() {
|
||||
self.Db.Next()
|
||||
}
|
||||
|
||||
type Debugger struct {
|
||||
win *qml.Window
|
||||
N chan bool
|
||||
Q chan bool
|
||||
done, interrupt bool
|
||||
breakOnInstr bool
|
||||
}
|
||||
|
||||
type storeVal struct {
|
||||
Key, Value string
|
||||
}
|
||||
|
||||
func (d *Debugger) halting(pc int, op ethchain.OpCode, mem *ethchain.Memory, stack *ethchain.Stack, stateObject *ethchain.StateObject) bool {
|
||||
d.win.Root().Call("setInstruction", pc)
|
||||
d.win.Root().Call("clearMem")
|
||||
d.win.Root().Call("clearStack")
|
||||
d.win.Root().Call("clearStorage")
|
||||
|
||||
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())
|
||||
}
|
||||
|
||||
stateObject.State().EachStorage(func(key string, node *ethutil.Value) {
|
||||
d.win.Root().Call("setStorage", storeVal{fmt.Sprintf("% x", key), fmt.Sprintf("% x", node.Str())})
|
||||
})
|
||||
|
||||
if d.breakOnInstr {
|
||||
out:
|
||||
for {
|
||||
select {
|
||||
case <-d.N:
|
||||
break out
|
||||
case <-d.Q:
|
||||
d.interrupt = true
|
||||
d.clearBuffers()
|
||||
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func (d *Debugger) clearBuffers() {
|
||||
out:
|
||||
// drain
|
||||
for {
|
||||
select {
|
||||
case <-d.N:
|
||||
case <-d.Q:
|
||||
default:
|
||||
break out
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (d *Debugger) Next() {
|
||||
if !d.done {
|
||||
d.N <- true
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,132 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/go-qml/qml"
|
||||
)
|
||||
|
||||
type AppContainer interface {
|
||||
Create() error
|
||||
Destroy()
|
||||
|
||||
Window() *qml.Window
|
||||
Engine() *qml.Engine
|
||||
|
||||
NewBlock(*ethchain.Block)
|
||||
ObjectChanged(*ethchain.StateObject)
|
||||
StorageChanged(*ethchain.StorageState)
|
||||
NewWatcher(chan bool)
|
||||
}
|
||||
|
||||
type ExtApplication struct {
|
||||
*ethpub.PEthereum
|
||||
|
||||
blockChan chan ethutil.React
|
||||
changeChan chan ethutil.React
|
||||
quitChan chan bool
|
||||
watcherQuitChan chan bool
|
||||
|
||||
container AppContainer
|
||||
lib *UiLib
|
||||
registeredEvents []string
|
||||
}
|
||||
|
||||
func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
|
||||
app := &ExtApplication{
|
||||
ethpub.NewPEthereum(lib.eth),
|
||||
make(chan ethutil.React, 1),
|
||||
make(chan ethutil.React, 1),
|
||||
make(chan bool),
|
||||
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)
|
||||
|
||||
app.container.NewWatcher(app.watcherQuitChan)
|
||||
|
||||
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
|
||||
app.watcherQuitChan <- 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 storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
|
||||
app.container.StorageChanged(storageObject)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (app *ExtApplication) Watch(addr, storageAddr string) {
|
||||
var event string
|
||||
if len(storageAddr) == 0 {
|
||||
event = "object:" + string(ethutil.Hex2Bytes(addr))
|
||||
app.lib.eth.Reactor().Subscribe(event, app.changeChan)
|
||||
} else {
|
||||
event = "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
|
||||
app.lib.eth.Reactor().Subscribe(event, app.changeChan)
|
||||
}
|
||||
|
||||
app.registeredEvents = append(app.registeredEvents, event)
|
||||
}
|
||||
|
|
@ -0,0 +1,405 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethdb"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"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"
|
||||
"time"
|
||||
)
|
||||
|
||||
var logger = ethlog.NewLogger("GUI")
|
||||
|
||||
type Gui struct {
|
||||
// The main application window
|
||||
win *qml.Window
|
||||
// QML Engine
|
||||
engine *qml.Engine
|
||||
component *qml.Common
|
||||
// The ethereum interface
|
||||
eth *eth.Ethereum
|
||||
|
||||
// The public Ethereum library
|
||||
uiLib *UiLib
|
||||
|
||||
txDb *ethdb.LDBDatabase
|
||||
|
||||
pub *ethpub.PEthereum
|
||||
logLevel ethlog.LogLevel
|
||||
open bool
|
||||
|
||||
Session string
|
||||
}
|
||||
|
||||
// Create GUI, but doesn't start it
|
||||
func New(ethereum *eth.Ethereum, session string, logLevel int) *Gui {
|
||||
|
||||
db, err := ethdb.NewLDBDatabase("tx_database")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
pub := ethpub.NewPEthereum(ethereum)
|
||||
|
||||
return &Gui{eth: ethereum, txDb: db, pub: pub, logLevel: ethlog.LogLevel(logLevel), Session: session, open: false}
|
||||
}
|
||||
|
||||
func (gui *Gui) Start(assetPath string) {
|
||||
const version = "0.5.0 RC15"
|
||||
|
||||
defer gui.txDb.Close()
|
||||
|
||||
// Register ethereum functions
|
||||
qml.RegisterTypes("Ethereum", 1, 0, []qml.TypeSpec{{
|
||||
Init: func(p *ethpub.PBlock, obj qml.Object) { p.Number = 0; p.Hash = "" },
|
||||
}, {
|
||||
Init: func(p *ethpub.PTx, obj qml.Object) { p.Value = ""; p.Hash = ""; p.Address = "" },
|
||||
}, {
|
||||
Init: func(p *ethpub.KeyVal, obj qml.Object) { p.Key = ""; p.Value = "" },
|
||||
}})
|
||||
|
||||
ethutil.Config.SetClientString("Ethereal")
|
||||
|
||||
// Create a new QML engine
|
||||
gui.engine = qml.NewEngine()
|
||||
context := gui.engine.Context()
|
||||
|
||||
// Expose the eth library and the ui library to QML
|
||||
context.SetVar("eth", gui)
|
||||
context.SetVar("pub", gui.pub)
|
||||
gui.uiLib = NewUiLib(gui.engine, gui.eth, assetPath)
|
||||
context.SetVar("ui", gui.uiLib)
|
||||
|
||||
// Load the main QML interface
|
||||
data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
|
||||
|
||||
var win *qml.Window
|
||||
var err error
|
||||
var addlog = false
|
||||
if len(data) == 0 {
|
||||
win, err = gui.showKeyImport(context)
|
||||
} else {
|
||||
win, err = gui.showWallet(context)
|
||||
addlog = true
|
||||
}
|
||||
if err != nil {
|
||||
logger.Errorln("asset not found: you can set an alternative asset path on the command line using option 'asset_path'", err)
|
||||
|
||||
panic(err)
|
||||
}
|
||||
|
||||
logger.Infoln("Starting GUI")
|
||||
gui.open = true
|
||||
win.Show()
|
||||
// only add the gui logger after window is shown otherwise slider wont be shown
|
||||
if addlog {
|
||||
ethlog.AddLogSystem(gui)
|
||||
}
|
||||
win.Wait()
|
||||
// need to silence gui logger after window closed otherwise logsystem hangs
|
||||
gui.SetLogLevel(ethlog.Silence)
|
||||
gui.open = false
|
||||
}
|
||||
|
||||
func (gui *Gui) Stop() {
|
||||
if gui.open {
|
||||
gui.SetLogLevel(ethlog.Silence)
|
||||
gui.open = false
|
||||
gui.win.Hide()
|
||||
}
|
||||
logger.Infoln("Stopped")
|
||||
}
|
||||
|
||||
func (gui *Gui) ToggleMining() {
|
||||
var txt string
|
||||
if gui.eth.Mining {
|
||||
utils.StopMining(gui.eth)
|
||||
txt = "Start mining"
|
||||
} else {
|
||||
utils.StartMining(gui.eth)
|
||||
txt = "Stop mining"
|
||||
}
|
||||
|
||||
gui.win.Root().Set("miningButtonText", txt)
|
||||
}
|
||||
|
||||
func (gui *Gui) showWallet(context *qml.Context) (*qml.Window, error) {
|
||||
component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/wallet.qml"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
win := gui.createWindow(component)
|
||||
|
||||
gui.setInitialBlockChain()
|
||||
gui.loadAddressBook()
|
||||
gui.readPreviousTransactions()
|
||||
gui.setPeerInfo()
|
||||
|
||||
go gui.update()
|
||||
|
||||
return win, nil
|
||||
}
|
||||
|
||||
func (gui *Gui) showKeyImport(context *qml.Context) (*qml.Window, error) {
|
||||
context.SetVar("lib", gui)
|
||||
component, err := gui.engine.LoadFile(gui.uiLib.AssetPath("qml/first_run.qml"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return gui.createWindow(component), nil
|
||||
}
|
||||
|
||||
func (gui *Gui) createWindow(comp qml.Object) *qml.Window {
|
||||
win := comp.CreateWindow(nil)
|
||||
|
||||
gui.win = win
|
||||
gui.uiLib.win = win
|
||||
|
||||
return gui.win
|
||||
}
|
||||
|
||||
func (gui *Gui) ImportAndSetPrivKey(secret string) bool {
|
||||
err := gui.eth.KeyManager().InitFromString(gui.Session, 0, secret)
|
||||
if err != nil {
|
||||
logger.Errorln("unable to import: ", err)
|
||||
return false
|
||||
}
|
||||
logger.Errorln("successfully imported: ", err)
|
||||
return true
|
||||
}
|
||||
|
||||
func (gui *Gui) CreateAndSetPrivKey() (string, string, string, string) {
|
||||
err := gui.eth.KeyManager().Init(gui.Session, 0, true)
|
||||
if err != nil {
|
||||
logger.Errorln("unable to create key: ", err)
|
||||
return "", "", "", ""
|
||||
}
|
||||
return gui.eth.KeyManager().KeyPair().AsStrings()
|
||||
}
|
||||
|
||||
func (gui *Gui) setInitialBlockChain() {
|
||||
sBlk := gui.eth.BlockChain().LastBlockHash
|
||||
blk := gui.eth.BlockChain().GetBlock(sBlk)
|
||||
for ; blk != nil; blk = gui.eth.BlockChain().GetBlock(sBlk) {
|
||||
sBlk = blk.PrevHash
|
||||
addr := gui.address()
|
||||
|
||||
// Loop through all transactions to see if we missed any while being offline
|
||||
for _, tx := range blk.Transactions() {
|
||||
if bytes.Compare(tx.Sender(), addr) == 0 || bytes.Compare(tx.Recipient, addr) == 0 {
|
||||
if ok, _ := gui.txDb.Get(tx.Hash()); ok == nil {
|
||||
gui.txDb.Put(tx.Hash(), tx.RlpEncode())
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
gui.processBlock(blk, true)
|
||||
}
|
||||
}
|
||||
|
||||
type address struct {
|
||||
Name, Address string
|
||||
}
|
||||
|
||||
var namereg = ethutil.Hex2Bytes("bb5f186604d057c1c5240ca2ae0f6430138ac010")
|
||||
|
||||
func (gui *Gui) loadAddressBook() {
|
||||
gui.win.Root().Call("clearAddress")
|
||||
stateObject := gui.eth.StateManager().CurrentState().GetStateObject(namereg)
|
||||
if stateObject != nil {
|
||||
stateObject.State().EachStorage(func(name string, value *ethutil.Value) {
|
||||
gui.win.Root().Call("addAddress", struct{ Name, Address string }{name, ethutil.Bytes2Hex(value.Bytes())})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (gui *Gui) readPreviousTransactions() {
|
||||
it := gui.txDb.Db().NewIterator(nil, nil)
|
||||
addr := gui.address()
|
||||
for it.Next() {
|
||||
tx := ethchain.NewTransactionFromBytes(it.Value())
|
||||
|
||||
var inout string
|
||||
if bytes.Compare(tx.Sender(), addr) == 0 {
|
||||
inout = "send"
|
||||
} else {
|
||||
inout = "recv"
|
||||
}
|
||||
|
||||
gui.win.Root().Call("addTx", ethpub.NewPTx(tx), inout)
|
||||
|
||||
}
|
||||
it.Release()
|
||||
}
|
||||
|
||||
func (gui *Gui) processBlock(block *ethchain.Block, initial bool) {
|
||||
gui.win.Root().Call("addBlock", ethpub.NewPBlock(block), initial)
|
||||
}
|
||||
|
||||
func (gui *Gui) setWalletValue(amount, unconfirmedFunds *big.Int) {
|
||||
var str string
|
||||
if unconfirmedFunds != nil {
|
||||
pos := "+"
|
||||
if unconfirmedFunds.Cmp(big.NewInt(0)) < 0 {
|
||||
pos = "-"
|
||||
}
|
||||
val := ethutil.CurrencyToString(new(big.Int).Abs(ethutil.BigCopy(unconfirmedFunds)))
|
||||
str = fmt.Sprintf("%v (%s %v)", ethutil.CurrencyToString(amount), pos, val)
|
||||
} else {
|
||||
str = fmt.Sprintf("%v", ethutil.CurrencyToString(amount))
|
||||
}
|
||||
|
||||
gui.win.Root().Call("setWalletValue", str)
|
||||
}
|
||||
|
||||
// Simple go routine function that updates the list of peers in the GUI
|
||||
func (gui *Gui) update() {
|
||||
reactor := gui.eth.Reactor()
|
||||
|
||||
blockChan := make(chan ethutil.React, 1)
|
||||
txChan := make(chan ethutil.React, 1)
|
||||
objectChan := make(chan ethutil.React, 1)
|
||||
peerChan := make(chan ethutil.React, 1)
|
||||
|
||||
reactor.Subscribe("newBlock", blockChan)
|
||||
reactor.Subscribe("newTx:pre", txChan)
|
||||
reactor.Subscribe("newTx:post", txChan)
|
||||
reactor.Subscribe("object:"+string(namereg), objectChan)
|
||||
reactor.Subscribe("peerList", peerChan)
|
||||
|
||||
ticker := time.NewTicker(5 * time.Second)
|
||||
|
||||
state := gui.eth.StateManager().TransState()
|
||||
|
||||
unconfirmedFunds := new(big.Int)
|
||||
gui.win.Root().Call("setWalletValue", fmt.Sprintf("%v", ethutil.CurrencyToString(state.GetAccount(gui.address()).Amount)))
|
||||
|
||||
for {
|
||||
select {
|
||||
case b := <-blockChan:
|
||||
block := b.Resource.(*ethchain.Block)
|
||||
gui.processBlock(block, false)
|
||||
if bytes.Compare(block.Coinbase, gui.address()) == 0 {
|
||||
gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.address()).Amount, nil)
|
||||
}
|
||||
|
||||
case txMsg := <-txChan:
|
||||
tx := txMsg.Resource.(*ethchain.Transaction)
|
||||
|
||||
if txMsg.Event == "newTx:pre" {
|
||||
object := state.GetAccount(gui.address())
|
||||
|
||||
if bytes.Compare(tx.Sender(), gui.address()) == 0 {
|
||||
gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "send")
|
||||
gui.txDb.Put(tx.Hash(), tx.RlpEncode())
|
||||
|
||||
unconfirmedFunds.Sub(unconfirmedFunds, tx.Value)
|
||||
} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
|
||||
gui.win.Root().Call("addTx", ethpub.NewPTx(tx), "recv")
|
||||
gui.txDb.Put(tx.Hash(), tx.RlpEncode())
|
||||
|
||||
unconfirmedFunds.Add(unconfirmedFunds, tx.Value)
|
||||
}
|
||||
|
||||
gui.setWalletValue(object.Amount, unconfirmedFunds)
|
||||
} else {
|
||||
object := state.GetAccount(gui.address())
|
||||
if bytes.Compare(tx.Sender(), gui.address()) == 0 {
|
||||
object.SubAmount(tx.Value)
|
||||
} else if bytes.Compare(tx.Recipient, gui.address()) == 0 {
|
||||
object.AddAmount(tx.Value)
|
||||
}
|
||||
|
||||
gui.setWalletValue(object.Amount, nil)
|
||||
|
||||
state.UpdateStateObject(object)
|
||||
}
|
||||
case <-objectChan:
|
||||
gui.loadAddressBook()
|
||||
case <-peerChan:
|
||||
gui.setPeerInfo()
|
||||
case <-ticker.C:
|
||||
gui.setPeerInfo()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (gui *Gui) setPeerInfo() {
|
||||
gui.win.Root().Call("setPeers", fmt.Sprintf("%d / %d", gui.eth.PeerCount(), gui.eth.MaxPeers))
|
||||
|
||||
gui.win.Root().Call("resetPeers")
|
||||
for _, peer := range gui.pub.GetPeers() {
|
||||
gui.win.Root().Call("addPeer", peer)
|
||||
}
|
||||
}
|
||||
|
||||
func (gui *Gui) privateKey() string {
|
||||
return ethutil.Bytes2Hex(gui.eth.KeyManager().PrivateKey())
|
||||
}
|
||||
|
||||
func (gui *Gui) address() []byte {
|
||||
return gui.eth.KeyManager().Address()
|
||||
}
|
||||
|
||||
func (gui *Gui) RegisterName(name string) {
|
||||
name = fmt.Sprintf("\"%s\"\n1", name)
|
||||
gui.pub.Transact(gui.privateKey(), "namereg", "1000", "1000000", "150", name)
|
||||
}
|
||||
|
||||
func (gui *Gui) Transact(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
|
||||
return gui.pub.Transact(gui.privateKey(), recipient, value, gas, gasPrice, data)
|
||||
}
|
||||
|
||||
func (gui *Gui) Create(recipient, value, gas, gasPrice, data string) (*ethpub.PReceipt, error) {
|
||||
return gui.pub.Transact(gui.privateKey(), recipient, value, gas, gasPrice, data)
|
||||
}
|
||||
|
||||
func (gui *Gui) ChangeClientId(id string) {
|
||||
ethutil.Config.SetIdentifier(id)
|
||||
}
|
||||
|
||||
func (gui *Gui) ClientId() string {
|
||||
return ethutil.Config.Identifier
|
||||
}
|
||||
|
||||
// functions that allow Gui to implement interface ethlog.LogSystem
|
||||
func (gui *Gui) SetLogLevel(level ethlog.LogLevel) {
|
||||
gui.logLevel = level
|
||||
}
|
||||
|
||||
func (gui *Gui) GetLogLevel() ethlog.LogLevel {
|
||||
return gui.logLevel
|
||||
}
|
||||
|
||||
// this extra function needed to give int typecast value to gui widget
|
||||
// that sets initial loglevel to default
|
||||
func (gui *Gui) GetLogLevelInt() int {
|
||||
return int(gui.logLevel)
|
||||
}
|
||||
|
||||
func (gui *Gui) Println(v ...interface{}) {
|
||||
gui.printLog(fmt.Sprintln(v...))
|
||||
}
|
||||
|
||||
func (gui *Gui) Printf(format string, v ...interface{}) {
|
||||
gui.printLog(fmt.Sprintf(format, v...))
|
||||
}
|
||||
|
||||
// Print function that logs directly to the GUI
|
||||
func (gui *Gui) printLog(s string) {
|
||||
str := strings.TrimRight(s, "\n")
|
||||
lines := strings.Split(str, "\n")
|
||||
for _, line := range lines {
|
||||
gui.win.Root().Call("addLog", line)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,133 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/go-qml/qml"
|
||||
"github.com/howeyc/fsnotify"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"net/url"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
type HtmlApplication struct {
|
||||
win *qml.Window
|
||||
webView qml.Object
|
||||
engine *qml.Engine
|
||||
lib *UiLib
|
||||
path string
|
||||
watcher *fsnotify.Watcher
|
||||
}
|
||||
|
||||
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) RootFolder() string {
|
||||
folder, err := url.Parse(app.path)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return path.Dir(folder.RequestURI())
|
||||
}
|
||||
func (app *HtmlApplication) RecursiveFolders() []os.FileInfo {
|
||||
files, _ := ioutil.ReadDir(app.RootFolder())
|
||||
var folders []os.FileInfo
|
||||
for _, file := range files {
|
||||
if file.IsDir() {
|
||||
folders = append(folders, file)
|
||||
}
|
||||
}
|
||||
return folders
|
||||
}
|
||||
|
||||
func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
|
||||
var err error
|
||||
|
||||
app.watcher, err = fsnotify.NewWatcher()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
err = app.watcher.Watch(app.RootFolder())
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
for _, folder := range app.RecursiveFolders() {
|
||||
fullPath := app.RootFolder() + "/" + folder.Name()
|
||||
app.watcher.Watch(fullPath)
|
||||
}
|
||||
|
||||
go func() {
|
||||
out:
|
||||
for {
|
||||
select {
|
||||
case <-quitChan:
|
||||
app.watcher.Close()
|
||||
break out
|
||||
case <-app.watcher.Event:
|
||||
//logger.Debugln("Got event:", ev)
|
||||
app.webView.Call("reload")
|
||||
case err := <-app.watcher.Error:
|
||||
// TODO: Do something here
|
||||
logger.Infoln("Watcher error:", err)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
}
|
||||
|
||||
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 := ðpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
|
||||
app.webView.Call("onNewBlockCb", b)
|
||||
}
|
||||
|
||||
func (app *HtmlApplication) ObjectChanged(stateObject *ethchain.StateObject) {
|
||||
app.webView.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
|
||||
}
|
||||
|
||||
func (app *HtmlApplication) StorageChanged(storageObject *ethchain.StorageState) {
|
||||
app.webView.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
|
||||
}
|
||||
|
||||
func (app *HtmlApplication) Destroy() {
|
||||
app.engine.Destroy()
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/go-qml/qml"
|
||||
)
|
||||
|
||||
type QmlApplication struct {
|
||||
win *qml.Window
|
||||
engine *qml.Engine
|
||||
lib *UiLib
|
||||
path string
|
||||
}
|
||||
|
||||
func NewQmlApplication(path string, lib *UiLib) *QmlApplication {
|
||||
engine := qml.NewEngine()
|
||||
return &QmlApplication{engine: engine, path: path, lib: lib}
|
||||
}
|
||||
|
||||
func (app *QmlApplication) Create() error {
|
||||
component, err := app.engine.LoadFile(app.path)
|
||||
if err != nil {
|
||||
logger.Warnln(err)
|
||||
}
|
||||
app.win = component.CreateWindow(nil)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (app *QmlApplication) Destroy() {
|
||||
app.engine.Destroy()
|
||||
}
|
||||
|
||||
func (app *QmlApplication) NewWatcher(quitChan chan bool) {
|
||||
}
|
||||
|
||||
// Events
|
||||
func (app *QmlApplication) NewBlock(block *ethchain.Block) {
|
||||
pblock := ðpub.PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Bytes2Hex(block.Hash())}
|
||||
app.win.Call("onNewBlockCb", pblock)
|
||||
}
|
||||
|
||||
func (app *QmlApplication) ObjectChanged(stateObject *ethchain.StateObject) {
|
||||
app.win.Call("onObjectChangeCb", ethpub.NewPStateObject(stateObject))
|
||||
}
|
||||
|
||||
func (app *QmlApplication) StorageChanged(storageObject *ethchain.StorageState) {
|
||||
app.win.Call("onStorageChangeCb", ethpub.NewPStorageState(storageObject))
|
||||
}
|
||||
|
||||
// Getters
|
||||
func (app *QmlApplication) Engine() *qml.Engine {
|
||||
return app.engine
|
||||
}
|
||||
func (app *QmlApplication) Window() *qml.Window {
|
||||
return app.win
|
||||
}
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
package ethui
|
||||
|
||||
import (
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/go-qml/qml"
|
||||
"path"
|
||||
)
|
||||
|
||||
type memAddr struct {
|
||||
Num string
|
||||
Value string
|
||||
}
|
||||
|
||||
// UI Library that has some basic functionality exposed
|
||||
type UiLib struct {
|
||||
engine *qml.Engine
|
||||
eth *eth.Ethereum
|
||||
connected bool
|
||||
assetPath string
|
||||
// The main application window
|
||||
win *qml.Window
|
||||
Db *Debugger
|
||||
DbWindow *DebuggerWindow
|
||||
}
|
||||
|
||||
func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib {
|
||||
return &UiLib{engine: engine, eth: eth, assetPath: assetPath}
|
||||
}
|
||||
|
||||
func (ui *UiLib) OpenQml(path string) {
|
||||
container := NewQmlApplication(path[7:], ui)
|
||||
app := NewExtApplication(container, ui)
|
||||
|
||||
go app.run()
|
||||
}
|
||||
|
||||
func (ui *UiLib) OpenHtml(path string) {
|
||||
container := NewHtmlApplication(path, ui)
|
||||
app := NewExtApplication(container, ui)
|
||||
|
||||
go app.run()
|
||||
}
|
||||
|
||||
func (ui *UiLib) Muted(content string) {
|
||||
component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
|
||||
if err != nil {
|
||||
logger.Debugln(err)
|
||||
|
||||
return
|
||||
}
|
||||
win := component.CreateWindow(nil)
|
||||
go func() {
|
||||
path := "file://" + ui.AssetPath("muted/index.html")
|
||||
win.Set("url", path)
|
||||
|
||||
win.Show()
|
||||
win.Wait()
|
||||
}()
|
||||
}
|
||||
|
||||
func (ui *UiLib) Connect(button qml.Object) {
|
||||
if !ui.connected {
|
||||
ui.eth.Start(true)
|
||||
ui.connected = true
|
||||
button.Set("enabled", false)
|
||||
}
|
||||
}
|
||||
|
||||
func (ui *UiLib) ConnectToPeer(addr string) {
|
||||
ui.eth.ConnectToPeer(addr)
|
||||
}
|
||||
|
||||
func (ui *UiLib) AssetPath(p string) string {
|
||||
return path.Join(ui.assetPath, p)
|
||||
}
|
||||
|
||||
func (self *UiLib) StartDbWithContractAndData(contractHash, data string) {
|
||||
dbWindow := NewDebuggerWindow(self)
|
||||
object := self.eth.StateManager().CurrentState().GetStateObject(ethutil.Hex2Bytes(contractHash))
|
||||
if len(object.Script()) > 0 {
|
||||
dbWindow.SetCode("0x" + ethutil.Bytes2Hex(object.Script()))
|
||||
}
|
||||
dbWindow.SetData("0x" + data)
|
||||
|
||||
dbWindow.Show()
|
||||
}
|
||||
|
||||
func (self *UiLib) StartDbWithCode(code string) {
|
||||
dbWindow := NewDebuggerWindow(self)
|
||||
dbWindow.SetCode("0x" + code)
|
||||
dbWindow.Show()
|
||||
}
|
||||
|
||||
func (self *UiLib) StartDebugger() {
|
||||
dbWindow := NewDebuggerWindow(self)
|
||||
//self.DbWindow = dbWindow
|
||||
|
||||
dbWindow.Show()
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/go-ethereum/utils"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
)
|
||||
|
||||
func InitJsConsole(ethereum *eth.Ethereum) {
|
||||
repl := NewJSRepl(ethereum)
|
||||
go repl.Start()
|
||||
utils.RegisterInterrupt(func(os.Signal) {
|
||||
repl.Stop()
|
||||
})
|
||||
}
|
||||
|
||||
func ExecJsFile(ethereum *eth.Ethereum, InputFile string) {
|
||||
file, err := os.Open(InputFile)
|
||||
if err != nil {
|
||||
logger.Fatalln(err)
|
||||
}
|
||||
content, err := ioutil.ReadAll(file)
|
||||
if err != nil {
|
||||
logger.Fatalln(err)
|
||||
}
|
||||
re := NewJSRE(ethereum)
|
||||
utils.RegisterInterrupt(func(os.Signal) {
|
||||
re.Stop()
|
||||
})
|
||||
re.Run(string(content))
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"os"
|
||||
"os/user"
|
||||
"path"
|
||||
)
|
||||
|
||||
var Identifier string
|
||||
var KeyRing string
|
||||
var KeyStore string
|
||||
var StartRpc bool
|
||||
var RpcPort int
|
||||
var UseUPnP bool
|
||||
var OutboundPort string
|
||||
var ShowGenesis bool
|
||||
var AddPeer string
|
||||
var MaxPeer int
|
||||
var GenAddr bool
|
||||
var UseSeed bool
|
||||
var SecretFile string
|
||||
var ExportDir string
|
||||
var NonInteractive bool
|
||||
var Datadir string
|
||||
var LogFile string
|
||||
var ConfigFile string
|
||||
var DebugFile string
|
||||
var LogLevel int
|
||||
|
||||
// flags specific to cli client
|
||||
var StartMining bool
|
||||
var StartJsConsole bool
|
||||
var InputFile string
|
||||
|
||||
func defaultDataDir() string {
|
||||
usr, _ := user.Current()
|
||||
return path.Join(usr.HomeDir, ".ethereum")
|
||||
}
|
||||
|
||||
var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
|
||||
|
||||
func Init() {
|
||||
flag.Usage = func() {
|
||||
fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
|
||||
flag.PrintDefaults()
|
||||
}
|
||||
|
||||
flag.StringVar(&Identifier, "id", "", "Custom client identifier")
|
||||
flag.StringVar(&KeyRing, "keyring", "", "identifier for keyring to use")
|
||||
flag.StringVar(&KeyStore, "keystore", "db", "system to store keyrings: db|file (db)")
|
||||
flag.StringVar(&OutboundPort, "port", "30303", "listening port")
|
||||
flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
|
||||
flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers")
|
||||
flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on")
|
||||
flag.BoolVar(&StartRpc, "rpc", false, "start rpc server")
|
||||
flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)")
|
||||
flag.BoolVar(&UseSeed, "seed", true, "seed peers")
|
||||
flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key")
|
||||
flag.StringVar(&SecretFile, "import", "", "imports the file given (hex or mnemonic formats)")
|
||||
flag.StringVar(&ExportDir, "export", "", "exports the session keyring to files in the directory given")
|
||||
flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)")
|
||||
flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use")
|
||||
flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file")
|
||||
flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)")
|
||||
flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-5: silent,error,warn,info,debug,debug detail)")
|
||||
|
||||
flag.BoolVar(&StartMining, "mine", false, "start dagger mining")
|
||||
flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console")
|
||||
|
||||
flag.Parse()
|
||||
|
||||
InputFile = flag.Arg(0)
|
||||
}
|
||||
|
|
@ -0,0 +1,231 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/eth-go/ethchain"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/ethereum/go-ethereum/utils"
|
||||
"github.com/obscuren/otto"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
var jsrelogger = ethlog.NewLogger("JSRE")
|
||||
|
||||
type JSRE struct {
|
||||
ethereum *eth.Ethereum
|
||||
vm *otto.Otto
|
||||
lib *ethpub.PEthereum
|
||||
|
||||
blockChan chan ethutil.React
|
||||
changeChan chan ethutil.React
|
||||
quitChan chan bool
|
||||
|
||||
objectCb map[string][]otto.Value
|
||||
}
|
||||
|
||||
func (jsre *JSRE) LoadExtFile(path string) {
|
||||
result, err := ioutil.ReadFile(path)
|
||||
if err == nil {
|
||||
jsre.vm.Run(result)
|
||||
} else {
|
||||
jsrelogger.Debugln("Could not load file:", path)
|
||||
}
|
||||
}
|
||||
|
||||
func (jsre *JSRE) LoadIntFile(file string) {
|
||||
assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal", "assets", "ext")
|
||||
jsre.LoadExtFile(path.Join(assetPath, file))
|
||||
}
|
||||
|
||||
func NewJSRE(ethereum *eth.Ethereum) *JSRE {
|
||||
re := &JSRE{
|
||||
ethereum,
|
||||
otto.New(),
|
||||
ethpub.NewPEthereum(ethereum),
|
||||
make(chan ethutil.React, 1),
|
||||
make(chan ethutil.React, 1),
|
||||
make(chan bool),
|
||||
make(map[string][]otto.Value),
|
||||
}
|
||||
|
||||
// Init the JS lib
|
||||
re.vm.Run(jsLib)
|
||||
|
||||
// Load extra javascript files
|
||||
re.LoadIntFile("string.js")
|
||||
re.LoadIntFile("big.js")
|
||||
|
||||
// We have to make sure that, whoever calls this, calls "Stop"
|
||||
go re.mainLoop()
|
||||
|
||||
re.Bind("eth", &JSEthereum{re.lib, re.vm})
|
||||
|
||||
re.initStdFuncs()
|
||||
|
||||
jsrelogger.Infoln("started")
|
||||
|
||||
return re
|
||||
}
|
||||
|
||||
func (self *JSRE) Bind(name string, v interface{}) {
|
||||
self.vm.Set(name, v)
|
||||
}
|
||||
|
||||
func (self *JSRE) Run(code string) (otto.Value, error) {
|
||||
return self.vm.Run(code)
|
||||
}
|
||||
|
||||
func (self *JSRE) Require(file string) error {
|
||||
if len(filepath.Ext(file)) == 0 {
|
||||
file += ".js"
|
||||
}
|
||||
|
||||
fh, err := os.Open(file)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
content, _ := ioutil.ReadAll(fh)
|
||||
self.Run("exports = {};(function() {" + string(content) + "})();")
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (self *JSRE) Stop() {
|
||||
// Kill the main loop
|
||||
self.quitChan <- true
|
||||
|
||||
close(self.blockChan)
|
||||
close(self.quitChan)
|
||||
close(self.changeChan)
|
||||
jsrelogger.Infoln("stopped")
|
||||
}
|
||||
|
||||
func (self *JSRE) mainLoop() {
|
||||
// Subscribe to events
|
||||
reactor := self.ethereum.Reactor()
|
||||
reactor.Subscribe("newBlock", self.blockChan)
|
||||
|
||||
out:
|
||||
for {
|
||||
select {
|
||||
case <-self.quitChan:
|
||||
break out
|
||||
case block := <-self.blockChan:
|
||||
if _, ok := block.Resource.(*ethchain.Block); ok {
|
||||
}
|
||||
case object := <-self.changeChan:
|
||||
if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
|
||||
for _, cb := range self.objectCb[ethutil.Bytes2Hex(stateObject.Address())] {
|
||||
val, _ := self.vm.ToValue(ethpub.NewPStateObject(stateObject))
|
||||
cb.Call(cb, val)
|
||||
}
|
||||
} else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
|
||||
for _, cb := range self.objectCb[ethutil.Bytes2Hex(storageObject.StateAddress)+ethutil.Bytes2Hex(storageObject.Address)] {
|
||||
val, _ := self.vm.ToValue(ethpub.NewPStorageState(storageObject))
|
||||
cb.Call(cb, val)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRE) initStdFuncs() {
|
||||
t, _ := self.vm.Get("eth")
|
||||
eth := t.Object()
|
||||
eth.Set("watch", self.watch)
|
||||
eth.Set("addPeer", self.addPeer)
|
||||
eth.Set("require", self.require)
|
||||
eth.Set("stopMining", self.stopMining)
|
||||
eth.Set("startMining", self.startMining)
|
||||
eth.Set("execBlock", self.execBlock)
|
||||
}
|
||||
|
||||
/*
|
||||
* The following methods are natively implemented javascript functions
|
||||
*/
|
||||
|
||||
func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
|
||||
v, _ := self.vm.ToValue(utils.StopMining(self.ethereum))
|
||||
return v
|
||||
}
|
||||
|
||||
func (self *JSRE) startMining(call otto.FunctionCall) otto.Value {
|
||||
v, _ := self.vm.ToValue(utils.StartMining(self.ethereum))
|
||||
return v
|
||||
}
|
||||
|
||||
// eth.watch
|
||||
func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
|
||||
addr, _ := call.Argument(0).ToString()
|
||||
var storageAddr string
|
||||
var cb otto.Value
|
||||
var storageCallback bool
|
||||
if len(call.ArgumentList) > 2 {
|
||||
storageCallback = true
|
||||
storageAddr, _ = call.Argument(1).ToString()
|
||||
cb = call.Argument(2)
|
||||
} else {
|
||||
cb = call.Argument(1)
|
||||
}
|
||||
|
||||
if storageCallback {
|
||||
self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
|
||||
|
||||
event := "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
|
||||
self.ethereum.Reactor().Subscribe(event, self.changeChan)
|
||||
} else {
|
||||
self.objectCb[addr] = append(self.objectCb[addr], cb)
|
||||
|
||||
event := "object:" + string(ethutil.Hex2Bytes(addr))
|
||||
self.ethereum.Reactor().Subscribe(event, self.changeChan)
|
||||
}
|
||||
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
func (self *JSRE) addPeer(call otto.FunctionCall) otto.Value {
|
||||
host, err := call.Argument(0).ToString()
|
||||
if err != nil {
|
||||
return otto.FalseValue()
|
||||
}
|
||||
self.ethereum.ConnectToPeer(host)
|
||||
|
||||
return otto.TrueValue()
|
||||
}
|
||||
|
||||
func (self *JSRE) require(call otto.FunctionCall) otto.Value {
|
||||
file, err := call.Argument(0).ToString()
|
||||
if err != nil {
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
if err := self.Require(file); err != nil {
|
||||
fmt.Println("err:", err)
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
t, _ := self.vm.Get("exports")
|
||||
|
||||
return t
|
||||
}
|
||||
|
||||
func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
|
||||
hash, err := call.Argument(0).ToString()
|
||||
if err != nil {
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
err = utils.BlockDo(self.ethereum, ethutil.Hex2Bytes(hash))
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return otto.FalseValue()
|
||||
}
|
||||
|
||||
return otto.TrueValue()
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
package main
|
||||
|
||||
const jsLib = `
|
||||
function pp(object) {
|
||||
var str = "";
|
||||
|
||||
if(object instanceof Array) {
|
||||
str += "[ ";
|
||||
for(var i = 0, l = object.length; i < l; i++) {
|
||||
str += pp(object[i]);
|
||||
|
||||
if(i < l-1) {
|
||||
str += ", ";
|
||||
}
|
||||
}
|
||||
str += " ]";
|
||||
} else if(typeof(object) === "object") {
|
||||
str += "{ ";
|
||||
var last = Object.keys(object).sort().pop()
|
||||
for(var k in object) {
|
||||
str += k + ": " + pp(object[k]);
|
||||
|
||||
if(k !== last) {
|
||||
str += ", ";
|
||||
}
|
||||
}
|
||||
str += " }";
|
||||
} else if(typeof(object) === "string") {
|
||||
str += "\033[32m'" + object + "'";
|
||||
} else if(typeof(object) === "undefined") {
|
||||
str += "\033[1m\033[30m" + object;
|
||||
} else if(typeof(object) === "number") {
|
||||
str += "\033[31m" + object;
|
||||
} else if(typeof(object) === "function") {
|
||||
str += "\033[35m[Function]";
|
||||
} else {
|
||||
str += object;
|
||||
}
|
||||
|
||||
str += "\033[0m";
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
function prettyPrint(/* */) {
|
||||
var args = arguments;
|
||||
for(var i = 0, l = args.length; i < l; i++) {
|
||||
console.log(pp(args[i]))
|
||||
}
|
||||
}
|
||||
|
||||
var print = prettyPrint;
|
||||
`
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"github.com/ethereum/go-ethereum/utils"
|
||||
"runtime"
|
||||
)
|
||||
|
||||
var logger = ethlog.NewLogger("CLI")
|
||||
|
||||
func main() {
|
||||
runtime.GOMAXPROCS(runtime.NumCPU())
|
||||
|
||||
utils.HandleInterrupt()
|
||||
|
||||
// precedence: code-internal flag default < config file < environment variables < command line
|
||||
Init() // parsing command line
|
||||
utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH")
|
||||
|
||||
utils.InitDataDir(Datadir)
|
||||
|
||||
utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile)
|
||||
|
||||
db := utils.NewDatabase()
|
||||
|
||||
keyManager := utils.NewKeyManager(KeyStore, Datadir, db)
|
||||
|
||||
// create, import, export keys
|
||||
utils.KeyTasks(keyManager, KeyRing, GenAddr, SecretFile, ExportDir, NonInteractive)
|
||||
|
||||
ethereum := utils.NewEthereum(db, keyManager, UseUPnP, OutboundPort, MaxPeer)
|
||||
|
||||
if ShowGenesis {
|
||||
utils.ShowGenesis(ethereum)
|
||||
}
|
||||
|
||||
if StartMining {
|
||||
utils.StartMining(ethereum)
|
||||
}
|
||||
|
||||
// better reworked as cases
|
||||
if StartJsConsole {
|
||||
InitJsConsole(ethereum)
|
||||
} else if len(InputFile) > 0 {
|
||||
ExecJsFile(ethereum, InputFile)
|
||||
}
|
||||
|
||||
if StartRpc {
|
||||
utils.StartRpc(ethereum, RpcPort)
|
||||
}
|
||||
|
||||
utils.StartEthereum(ethereum, UseSeed)
|
||||
|
||||
// this blocks the thread
|
||||
ethereum.WaitForShutdown()
|
||||
ethlog.Flush()
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"github.com/obscuren/otto"
|
||||
"io"
|
||||
"os"
|
||||
"path"
|
||||
)
|
||||
|
||||
type Repl interface {
|
||||
Start()
|
||||
Stop()
|
||||
}
|
||||
|
||||
type JSRepl struct {
|
||||
re *JSRE
|
||||
|
||||
prompt string
|
||||
|
||||
history *os.File
|
||||
|
||||
running bool
|
||||
}
|
||||
|
||||
func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
|
||||
hist, err := os.OpenFile(path.Join(ethutil.Config.ExecPath, "history"), os.O_RDWR|os.O_CREATE, os.ModePerm)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
return &JSRepl{re: NewJSRE(ethereum), prompt: "> ", history: hist}
|
||||
}
|
||||
|
||||
func (self *JSRepl) Start() {
|
||||
if !self.running {
|
||||
self.running = true
|
||||
logger.Infoln("init JS Console")
|
||||
reader := bufio.NewReader(self.history)
|
||||
for {
|
||||
line, err := reader.ReadString('\n')
|
||||
if err != nil && err == io.EOF {
|
||||
break
|
||||
} else if err != nil {
|
||||
fmt.Println("error reading history", err)
|
||||
break
|
||||
}
|
||||
|
||||
addHistory(line[:len(line)-1])
|
||||
}
|
||||
self.read()
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRepl) Stop() {
|
||||
if self.running {
|
||||
self.running = false
|
||||
self.re.Stop()
|
||||
logger.Infoln("exit JS Console")
|
||||
self.history.Close()
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRepl) parseInput(code string) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
fmt.Println("[native] error", r)
|
||||
}
|
||||
}()
|
||||
|
||||
value, err := self.re.Run(code)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
|
||||
self.PrintValue(value)
|
||||
}
|
||||
|
||||
// The JSEthereum object attempts to wrap the PEthereum object and returns
|
||||
// meaningful javascript objects
|
||||
type JSBlock struct {
|
||||
*ethpub.PBlock
|
||||
eth *JSEthereum
|
||||
}
|
||||
|
||||
func (self *JSBlock) GetTransaction(hash string) otto.Value {
|
||||
return self.eth.toVal(self.PBlock.GetTransaction(hash))
|
||||
}
|
||||
|
||||
type JSEthereum struct {
|
||||
*ethpub.PEthereum
|
||||
vm *otto.Otto
|
||||
}
|
||||
|
||||
func (self *JSEthereum) GetBlock(hash string) otto.Value {
|
||||
return self.toVal(&JSBlock{self.PEthereum.GetBlock(hash), self})
|
||||
}
|
||||
|
||||
func (self *JSEthereum) GetPeers() otto.Value {
|
||||
return self.toVal(self.PEthereum.GetPeers())
|
||||
}
|
||||
|
||||
func (self *JSEthereum) GetKey() otto.Value {
|
||||
return self.toVal(self.PEthereum.GetKey())
|
||||
}
|
||||
|
||||
func (self *JSEthereum) GetStateObject(addr string) otto.Value {
|
||||
return self.toVal(self.PEthereum.GetStateObject(addr))
|
||||
}
|
||||
|
||||
func (self *JSEthereum) GetStateKeyVals(addr string) otto.Value {
|
||||
return self.toVal(self.PEthereum.GetStateObject(addr).StateKeyVal(false))
|
||||
}
|
||||
|
||||
func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
|
||||
r, err := self.PEthereum.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
return self.toVal(r)
|
||||
}
|
||||
|
||||
func (self *JSEthereum) Create(key, valueStr, gasStr, gasPriceStr, scriptStr string) otto.Value {
|
||||
r, err := self.PEthereum.Create(key, valueStr, gasStr, gasPriceStr, scriptStr)
|
||||
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
return self.toVal(r)
|
||||
}
|
||||
|
||||
func (self *JSEthereum) toVal(v interface{}) otto.Value {
|
||||
result, err := self.vm.ToValue(v)
|
||||
|
||||
if err != nil {
|
||||
fmt.Println("Value unknown:", err)
|
||||
|
||||
return otto.UndefinedValue()
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
package main
|
||||
|
||||
// #cgo darwin CFLAGS: -I/usr/local/opt/readline/include
|
||||
// #cgo darwin LDFLAGS: -L/usr/local/opt/readline/lib
|
||||
// #cgo LDFLAGS: -lreadline
|
||||
// #include <stdio.h>
|
||||
// #include <stdlib.h>
|
||||
// #include <readline/readline.h>
|
||||
// #include <readline/history.h>
|
||||
import "C"
|
||||
import (
|
||||
"os"
|
||||
"os/signal"
|
||||
"strings"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func initReadLine() {
|
||||
C.rl_catch_sigwinch = 0
|
||||
C.rl_catch_signals = 0
|
||||
c := make(chan os.Signal, 1)
|
||||
signal.Notify(c, syscall.SIGWINCH)
|
||||
signal.Notify(c, os.Interrupt)
|
||||
go func() {
|
||||
for sig := range c {
|
||||
switch sig {
|
||||
case syscall.SIGWINCH:
|
||||
C.rl_resize_terminal()
|
||||
|
||||
case os.Interrupt:
|
||||
C.rl_cleanup_after_signal()
|
||||
default:
|
||||
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
func readLine(prompt *string) *string {
|
||||
var p *C.char
|
||||
|
||||
//readline allows an empty prompt(NULL)
|
||||
if prompt != nil {
|
||||
p = C.CString(*prompt)
|
||||
}
|
||||
|
||||
ret := C.readline(p)
|
||||
|
||||
if p != nil {
|
||||
C.free(unsafe.Pointer(p))
|
||||
}
|
||||
|
||||
if ret == nil {
|
||||
return nil
|
||||
} //EOF
|
||||
|
||||
s := C.GoString(ret)
|
||||
C.free(unsafe.Pointer(ret))
|
||||
return &s
|
||||
}
|
||||
|
||||
func addHistory(s string) {
|
||||
p := C.CString(s)
|
||||
C.add_history(p)
|
||||
C.free(unsafe.Pointer(p))
|
||||
}
|
||||
|
||||
var indentCount = 0
|
||||
var str = ""
|
||||
|
||||
func (self *JSRepl) setIndent() {
|
||||
open := strings.Count(str, "{")
|
||||
open += strings.Count(str, "(")
|
||||
closed := strings.Count(str, "}")
|
||||
closed += strings.Count(str, ")")
|
||||
indentCount = open - closed
|
||||
if indentCount <= 0 {
|
||||
self.prompt = "> "
|
||||
} else {
|
||||
self.prompt = strings.Join(make([]string, indentCount*2), "..")
|
||||
self.prompt += " "
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRepl) read() {
|
||||
initReadLine()
|
||||
L:
|
||||
for {
|
||||
switch result := readLine(&self.prompt); true {
|
||||
case result == nil:
|
||||
break L
|
||||
|
||||
case *result != "":
|
||||
str += *result + "\n"
|
||||
|
||||
self.setIndent()
|
||||
|
||||
if indentCount <= 0 {
|
||||
if *result == "exit" {
|
||||
self.Stop()
|
||||
break L
|
||||
}
|
||||
|
||||
hist := str[:len(str)-1]
|
||||
addHistory(hist) //allow user to recall this line
|
||||
self.history.WriteString(str)
|
||||
|
||||
self.parseInput(str)
|
||||
|
||||
str = ""
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRepl) PrintValue(v interface{}) {
|
||||
method, _ := self.re.vm.Get("prettyPrint")
|
||||
v, err := self.re.vm.ToValue(v)
|
||||
if err == nil {
|
||||
method.Call(method, v)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
repl_darwin.go
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func (self *JSRepl) read() {
|
||||
reader := bufio.NewReader(os.Stdin)
|
||||
for {
|
||||
fmt.Printf(self.prompt)
|
||||
str, _, err := reader.ReadLine()
|
||||
if err != nil {
|
||||
fmt.Println("Error reading input", err)
|
||||
} else {
|
||||
self.parseInput(string(str))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (self *JSRepl) PrintValue(value otto.Value) {
|
||||
fmt.Println(value)
|
||||
}
|
||||
|
|
@ -130,7 +130,9 @@ out:
|
|||
func (self *Miner) Stop() {
|
||||
logger.Infoln("Stopping...")
|
||||
self.quitChan <- true
|
||||
self.powQuitChan <- ethutil.React{}
|
||||
|
||||
close(self.powQuitChan)
|
||||
close(self.quitChan)
|
||||
}
|
||||
|
||||
func (self *Miner) mineNewBlock() {
|
||||
|
|
|
|||
|
|
@ -212,7 +212,7 @@ func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, sc
|
|||
tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, data)
|
||||
}
|
||||
|
||||
acc := lib.stateManager.TransState().GetStateObject(keyPair.Address())
|
||||
acc := lib.stateManager.TransState().GetOrNewStateObject(keyPair.Address())
|
||||
tx.Nonce = acc.Nonce
|
||||
acc.Nonce += 1
|
||||
lib.stateManager.TransState().UpdateStateObject(acc)
|
||||
|
|
|
|||
|
|
@ -45,11 +45,11 @@ func NewCache(db ethutil.Database) *Cache {
|
|||
return &Cache{db: db, nodes: make(map[string]*Node)}
|
||||
}
|
||||
|
||||
func (cache *Cache) Put(v interface{}) interface{} {
|
||||
func (cache *Cache) PutValue(v interface{}, force bool) interface{} {
|
||||
value := ethutil.NewValue(v)
|
||||
|
||||
enc := value.Encode()
|
||||
if len(enc) >= 32 {
|
||||
if len(enc) >= 32 || force {
|
||||
sha := ethcrypto.Sha3Bin(enc)
|
||||
|
||||
cache.nodes[string(sha)] = NewNode(sha, value, true)
|
||||
|
|
@ -61,6 +61,10 @@ func (cache *Cache) Put(v interface{}) interface{} {
|
|||
return v
|
||||
}
|
||||
|
||||
func (cache *Cache) Put(v interface{}) interface{} {
|
||||
return cache.PutValue(v, false)
|
||||
}
|
||||
|
||||
func (cache *Cache) Get(key []byte) *ethutil.Value {
|
||||
// First check if the key is the cache
|
||||
if cache.nodes[string(key)] != nil {
|
||||
|
|
@ -170,7 +174,15 @@ func (t *Trie) Update(key string, value string) {
|
|||
|
||||
k := CompactHexDecode(key)
|
||||
|
||||
t.Root = t.UpdateState(t.Root, k, value)
|
||||
root := t.UpdateState(t.Root, k, value)
|
||||
switch root.(type) {
|
||||
case string:
|
||||
t.Root = root
|
||||
case []byte:
|
||||
t.Root = root
|
||||
default:
|
||||
t.Root = t.cache.PutValue(root, true)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Trie) Get(key string) string {
|
||||
|
|
@ -184,7 +196,20 @@ func (t *Trie) Get(key string) string {
|
|||
}
|
||||
|
||||
func (t *Trie) Delete(key string) {
|
||||
t.Update(key, "")
|
||||
t.mut.Lock()
|
||||
defer t.mut.Unlock()
|
||||
|
||||
k := CompactHexDecode(key)
|
||||
|
||||
root := t.DeleteState(t.Root, k)
|
||||
switch root.(type) {
|
||||
case string:
|
||||
t.Root = root
|
||||
case []byte:
|
||||
t.Root = root
|
||||
default:
|
||||
t.Root = t.cache.PutValue(root, true)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Trie) GetState(node interface{}, key []int) interface{} {
|
||||
|
|
@ -236,15 +261,7 @@ func (t *Trie) GetNode(node interface{}) *ethutil.Value {
|
|||
}
|
||||
|
||||
func (t *Trie) UpdateState(node interface{}, key []int, value string) interface{} {
|
||||
|
||||
if value != "" {
|
||||
return t.InsertState(node, key, value)
|
||||
} else {
|
||||
// delete it
|
||||
return t.DeleteState(node, key)
|
||||
}
|
||||
|
||||
return t.Root
|
||||
}
|
||||
|
||||
func (t *Trie) Put(node interface{}) interface{} {
|
||||
|
|
@ -532,10 +549,10 @@ func (it *TrieIterator) iterateNode(key []int, currentNode *ethutil.Value, cb Ea
|
|||
if currentNode.Len() == 2 {
|
||||
k := CompactDecode(currentNode.Get(0).Str())
|
||||
|
||||
if currentNode.Get(1).Str() == "" {
|
||||
it.iterateNode(key, currentNode.Get(1), cb)
|
||||
} else {
|
||||
pk := append(key, k...)
|
||||
if currentNode.Get(1).Len() != 0 && currentNode.Get(1).Str() == "" {
|
||||
it.iterateNode(pk, currentNode.Get(1), cb)
|
||||
} else {
|
||||
|
||||
if k[len(k)-1] == 16 {
|
||||
cb(DecodeCompact(pk), currentNode.Get(1))
|
||||
|
|
@ -549,7 +566,7 @@ func (it *TrieIterator) iterateNode(key []int, currentNode *ethutil.Value, cb Ea
|
|||
if i == 16 && currentNode.Get(i).Len() != 0 {
|
||||
cb(DecodeCompact(pk), currentNode.Get(i))
|
||||
} else {
|
||||
if currentNode.Get(i).Str() == "" {
|
||||
if currentNode.Get(i).Len() != 0 && currentNode.Get(i).Str() == "" {
|
||||
it.iterateNode(pk, currentNode.Get(i), cb)
|
||||
} else {
|
||||
val := currentNode.Get(i).Str()
|
||||
|
|
|
|||
|
|
@ -1,9 +1,16 @@
|
|||
package ethtrie
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
const LONG_WORD = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
|
|
@ -171,23 +178,154 @@ func TestTriePurge(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestTrieIt(t *testing.T) {
|
||||
_, trie := New()
|
||||
|
||||
data := [][]string{
|
||||
{"do", "verb"},
|
||||
{"ether", "wookiedoo"},
|
||||
{"horse", "stallion"},
|
||||
{"shaman", "horse"},
|
||||
{"doge", "coin"},
|
||||
{"ether", ""},
|
||||
{"dog", "puppy"},
|
||||
{"shaman", ""},
|
||||
func h(str string) string {
|
||||
d, err := hex.DecodeString(str)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
for _, item := range data {
|
||||
trie.Update(item[0], item[1])
|
||||
}
|
||||
|
||||
fmt.Printf("root %x", trie.Root)
|
||||
return string(d)
|
||||
}
|
||||
|
||||
func get(in string) (out string) {
|
||||
if len(in) > 2 && in[:2] == "0x" {
|
||||
out = h(in[2:])
|
||||
} else {
|
||||
out = in
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
type Test struct {
|
||||
Name string
|
||||
In map[string]string
|
||||
Root string
|
||||
}
|
||||
|
||||
func CreateTest(name string, data []byte) (Test, error) {
|
||||
t := Test{Name: name}
|
||||
err := json.Unmarshal(data, &t)
|
||||
if err != nil {
|
||||
return Test{}, fmt.Errorf("%v", err)
|
||||
}
|
||||
|
||||
return t, nil
|
||||
}
|
||||
|
||||
func CreateTests(uri string, cb func(Test)) map[string]Test {
|
||||
resp, err := http.Get(uri)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
data, err := ioutil.ReadAll(resp.Body)
|
||||
|
||||
var objmap map[string]*json.RawMessage
|
||||
err = json.Unmarshal(data, &objmap)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
tests := make(map[string]Test)
|
||||
for name, testData := range objmap {
|
||||
test, err := CreateTest(name, *testData)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
if cb != nil {
|
||||
cb(test)
|
||||
}
|
||||
tests[name] = test
|
||||
}
|
||||
|
||||
return tests
|
||||
}
|
||||
|
||||
func TestRemote(t *testing.T) {
|
||||
CreateTests("https://raw.githubusercontent.com/ethereum/tests/develop/trietest.json", func(test Test) {
|
||||
_, trie := New()
|
||||
for key, value := range test.In {
|
||||
trie.Update(get(key), get(value))
|
||||
}
|
||||
|
||||
a := NewValue(h(test.Root)).Bytes()
|
||||
b := NewValue(trie.Root).Bytes()
|
||||
if bytes.Compare(a, b) != 0 {
|
||||
t.Errorf("%-10s: %x %x", test.Name, a, b)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestTrieReplay(t *testing.T) {
|
||||
CreateTests("https://raw.githubusercontent.com/ethereum/tests/develop/trietest.json", func(test Test) {
|
||||
_, trie := New()
|
||||
for key, value := range test.In {
|
||||
trie.Update(get(key), get(value))
|
||||
}
|
||||
|
||||
_, trie2 := New()
|
||||
trie.NewIterator().Each(func(key string, v *Value) {
|
||||
trie2.Update(key, v.Str())
|
||||
})
|
||||
|
||||
a := NewValue(trie.Root).Bytes()
|
||||
b := NewValue(trie2.Root).Bytes()
|
||||
if bytes.Compare(a, b) != 0 {
|
||||
t.Errorf("%s %x %x\n", test.Name, trie.Root, trie2.Root)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func RandomData() [][]string {
|
||||
data := [][]string{
|
||||
{"0x000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1", "0x4e616d6552656700000000000000000000000000000000000000000000000000"},
|
||||
{"0x0000000000000000000000000000000000000000000000000000000000000045", "0x22b224a1420a802ab51d326e29fa98e34c4f24ea"},
|
||||
{"0x0000000000000000000000000000000000000000000000000000000000000046", "0x67706c2076330000000000000000000000000000000000000000000000000000"},
|
||||
{"0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6", "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000"},
|
||||
{"0x0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2", "0x4655474156000000000000000000000000000000000000000000000000000000"},
|
||||
{"0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000", "0x697c7b8c961b56f675d570498424ac8de1a918f6"},
|
||||
{"0x4655474156000000000000000000000000000000000000000000000000000000", "0x7ef9e639e2733cb34e4dfc576d4b23f72db776b2"},
|
||||
{"0x4e616d6552656700000000000000000000000000000000000000000000000000", "0xec4f34c97e43fbb2816cfd95e388353c7181dab1"},
|
||||
}
|
||||
|
||||
var c [][]string
|
||||
for len(data) != 0 {
|
||||
e := rand.Intn(len(data))
|
||||
c = append(c, data[e])
|
||||
|
||||
copy(data[e:], data[e+1:])
|
||||
data[len(data)-1] = nil
|
||||
data = data[:len(data)-1]
|
||||
}
|
||||
|
||||
return c
|
||||
}
|
||||
|
||||
const MaxTest = 1000
|
||||
|
||||
// This test insert data in random order and seeks to find indifferences between the different tries
|
||||
func TestRegression(t *testing.T) {
|
||||
rand.Seed(time.Now().Unix())
|
||||
|
||||
roots := make(map[string]int)
|
||||
for i := 0; i < MaxTest; i++ {
|
||||
_, trie := New()
|
||||
data := RandomData()
|
||||
|
||||
for _, test := range data {
|
||||
trie.Update(test[0], test[1])
|
||||
}
|
||||
trie.Delete("0x4e616d6552656700000000000000000000000000000000000000000000000000")
|
||||
|
||||
roots[string(trie.Root.([]byte))] += 1
|
||||
}
|
||||
|
||||
if len(roots) > 1 {
|
||||
for root, num := range roots {
|
||||
t.Errorf("%x => %d\n", root, num)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ type config struct {
|
|||
|
||||
ExecPath string
|
||||
Debug bool
|
||||
Paranoia bool
|
||||
Ver string
|
||||
ClientString string
|
||||
Identifier string
|
||||
|
|
@ -43,7 +44,7 @@ func ReadConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix
|
|||
} else {
|
||||
g.ParseAll()
|
||||
}
|
||||
Config = &config{ExecPath: Datadir, Debug: true, Ver: "0.5.15", conf: g, Identifier: Identifier}
|
||||
Config = &config{ExecPath: Datadir, Debug: true, Ver: "0.5.15", conf: g, Identifier: Identifier, Paranoia: true}
|
||||
Config.SetClientString("Ethereum(G)")
|
||||
}
|
||||
return Config
|
||||
|
|
|
|||
|
|
@ -116,6 +116,8 @@ func (val *Value) Bytes() []byte {
|
|||
return a
|
||||
} else if s, ok := val.Val.(byte); ok {
|
||||
return []byte{s}
|
||||
} else if s, ok := val.Val.(string); ok {
|
||||
return []byte(s)
|
||||
}
|
||||
|
||||
return []byte{}
|
||||
|
|
@ -196,6 +198,12 @@ func (val *Value) Encode() []byte {
|
|||
return Encode(val.Val)
|
||||
}
|
||||
|
||||
// Assume that the data we have is encoded
|
||||
func (self *Value) Decode() {
|
||||
v, _ := Decode(self.Bytes(), 0)
|
||||
self.Val = v
|
||||
}
|
||||
|
||||
func NewValueFromBytes(data []byte) *Value {
|
||||
if len(data) != 0 {
|
||||
data, _ := Decode(data, 0)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,57 @@
|
|||
#!/bin/sh
|
||||
|
||||
if [ "$1" == "" ]; then
|
||||
echo "Usage $0 executable branch ethereum develop"
|
||||
echo "executable ethereum or ethereal"
|
||||
echo "branch develop or master"
|
||||
exit
|
||||
fi
|
||||
|
||||
exe=$1
|
||||
branch=$2
|
||||
|
||||
# Test if go is installed
|
||||
command -v go >/dev/null 2>&1 || { echo >&2 "Unable to find 'go'. This script requires go."; exit 1; }
|
||||
|
||||
# Test if $GOPATH is set
|
||||
if [ "$GOPATH" == "" ]; then
|
||||
echo "\$GOPATH not set"
|
||||
exit
|
||||
fi
|
||||
|
||||
echo "go get -u -d github.com/ethereum/go-ethereum/$exe"
|
||||
go get -v -u -d github.com/ethereum/go-ethereum/$exe
|
||||
if [ $? != 0 ]; then
|
||||
echo "go get failed"
|
||||
exit
|
||||
fi
|
||||
|
||||
echo "serpent-go"
|
||||
cd $GOPATH/src/github.com/obscuren/serpent-go
|
||||
|
||||
echo "init submodule"
|
||||
git submodule init
|
||||
git submodule update
|
||||
|
||||
echo "eth-go"
|
||||
cd $GOPATH/src/github.com/ethereum/eth-go
|
||||
git checkout $branch
|
||||
|
||||
echo "go-ethereum"
|
||||
cd $GOPATH/src/github.com/ethereum/go-ethereum/$exe
|
||||
git checkout $branch
|
||||
|
||||
if [ "$exe" == "ethereal" ]; then
|
||||
echo "Building ethereal GUI. Assuming Qt is installed. If this step"
|
||||
echo "fails; please refer to: https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go)"
|
||||
else
|
||||
echo "Building ethereum CLI."
|
||||
fi
|
||||
|
||||
go install
|
||||
if [ $? == 0 ]; then
|
||||
echo "go install failed"
|
||||
exit
|
||||
fi
|
||||
|
||||
echo "done. Please run $exe :-)"
|
||||
2
peer.go
2
peer.go
|
|
@ -21,7 +21,7 @@ const (
|
|||
// The size of the output buffer for writing messages
|
||||
outputBufferSize = 50
|
||||
// Current protocol version
|
||||
ProtocolVersion = 20
|
||||
ProtocolVersion = 21
|
||||
// Interval for ping/pong message
|
||||
pingPongTimer = 2 * time.Second
|
||||
)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,253 @@
|
|||
package utils
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/ethereum/eth-go"
|
||||
"github.com/ethereum/eth-go/ethcrypto"
|
||||
"github.com/ethereum/eth-go/ethdb"
|
||||
"github.com/ethereum/eth-go/ethlog"
|
||||
"github.com/ethereum/eth-go/ethminer"
|
||||
"github.com/ethereum/eth-go/ethpub"
|
||||
"github.com/ethereum/eth-go/ethrpc"
|
||||
"github.com/ethereum/eth-go/ethutil"
|
||||
"io"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path"
|
||||
"time"
|
||||
)
|
||||
|
||||
var logger = ethlog.NewLogger("CLI")
|
||||
var interruptCallbacks = []func(os.Signal){}
|
||||
|
||||
// Register interrupt handlers callbacks
|
||||
func RegisterInterrupt(cb func(os.Signal)) {
|
||||
interruptCallbacks = append(interruptCallbacks, cb)
|
||||
}
|
||||
|
||||
// go routine that call interrupt handlers in order of registering
|
||||
func HandleInterrupt() {
|
||||
c := make(chan os.Signal, 1)
|
||||
go func() {
|
||||
signal.Notify(c, os.Interrupt)
|
||||
for sig := range c {
|
||||
logger.Errorf("Shutting down (%v) ... \n", sig)
|
||||
RunInterruptCallbacks(sig)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
func RunInterruptCallbacks(sig os.Signal) {
|
||||
for _, cb := range interruptCallbacks {
|
||||
cb(sig)
|
||||
}
|
||||
}
|
||||
|
||||
func AbsolutePath(Datadir string, filename string) string {
|
||||
if path.IsAbs(filename) {
|
||||
return filename
|
||||
}
|
||||
return path.Join(Datadir, filename)
|
||||
}
|
||||
|
||||
func openLogFile(Datadir string, filename string) *os.File {
|
||||
path := AbsolutePath(Datadir, filename)
|
||||
file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("error opening log file '%s': %v", filename, err))
|
||||
}
|
||||
return file
|
||||
}
|
||||
|
||||
func confirm(message string) bool {
|
||||
fmt.Println(message, "Are you sure? (y/n)")
|
||||
var r string
|
||||
fmt.Scanln(&r)
|
||||
for ; ; fmt.Scanln(&r) {
|
||||
if r == "n" || r == "y" {
|
||||
break
|
||||
} else {
|
||||
fmt.Printf("Yes or no?", r)
|
||||
}
|
||||
}
|
||||
return r == "y"
|
||||
}
|
||||
|
||||
func InitDataDir(Datadir string) {
|
||||
_, err := os.Stat(Datadir)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
|
||||
os.Mkdir(Datadir, 0777)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func InitLogging(Datadir string, LogFile string, LogLevel int, DebugFile string) {
|
||||
var writer io.Writer
|
||||
if LogFile == "" {
|
||||
writer = os.Stdout
|
||||
} else {
|
||||
writer = openLogFile(Datadir, LogFile)
|
||||
}
|
||||
ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.LogLevel(LogLevel)))
|
||||
if DebugFile != "" {
|
||||
writer = openLogFile(Datadir, DebugFile)
|
||||
ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.DebugLevel))
|
||||
}
|
||||
}
|
||||
|
||||
func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) {
|
||||
InitDataDir(Datadir)
|
||||
ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix)
|
||||
}
|
||||
|
||||
func exit(err error) {
|
||||
status := 0
|
||||
if err != nil {
|
||||
logger.Errorln("Fatal: ", err)
|
||||
status = 1
|
||||
}
|
||||
ethlog.Flush()
|
||||
os.Exit(status)
|
||||
}
|
||||
|
||||
func NewDatabase() ethutil.Database {
|
||||
db, err := ethdb.NewLDBDatabase("database")
|
||||
if err != nil {
|
||||
exit(err)
|
||||
}
|
||||
return db
|
||||
}
|
||||
|
||||
func NewEthereum(db ethutil.Database, keyManager *ethcrypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
|
||||
ethereum, err := eth.New(db, keyManager, eth.CapDefault, usePnp)
|
||||
if err != nil {
|
||||
logger.Fatalln("eth start err:", err)
|
||||
}
|
||||
ethereum.Port = OutboundPort
|
||||
ethereum.MaxPeers = MaxPeer
|
||||
return ethereum
|
||||
}
|
||||
|
||||
func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
|
||||
logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver)
|
||||
ethereum.Start(UseSeed)
|
||||
RegisterInterrupt(func(sig os.Signal) {
|
||||
ethereum.Stop()
|
||||
ethlog.Flush()
|
||||
})
|
||||
}
|
||||
|
||||
func ShowGenesis(ethereum *eth.Ethereum) {
|
||||
logger.Infoln(ethereum.BlockChain().Genesis())
|
||||
exit(nil)
|
||||
}
|
||||
|
||||
func NewKeyManager(KeyStore string, Datadir string, db ethutil.Database) *ethcrypto.KeyManager {
|
||||
var keyManager *ethcrypto.KeyManager
|
||||
switch {
|
||||
case KeyStore == "db":
|
||||
keyManager = ethcrypto.NewDBKeyManager(db)
|
||||
case KeyStore == "file":
|
||||
keyManager = ethcrypto.NewFileKeyManager(Datadir)
|
||||
default:
|
||||
exit(fmt.Errorf("unknown keystore type: %s", KeyStore))
|
||||
}
|
||||
return keyManager
|
||||
}
|
||||
|
||||
func KeyTasks(keyManager *ethcrypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
|
||||
var err error
|
||||
switch {
|
||||
case GenAddr:
|
||||
if NonInteractive || confirm("This action overwrites your old private key.") {
|
||||
err = keyManager.Init(KeyRing, 0, true)
|
||||
}
|
||||
exit(err)
|
||||
case len(SecretFile) > 0:
|
||||
if NonInteractive || confirm("This action overwrites your old private key.") {
|
||||
err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
|
||||
}
|
||||
exit(err)
|
||||
case len(ExportDir) > 0:
|
||||
err = keyManager.Init(KeyRing, 0, false)
|
||||
if err == nil {
|
||||
err = keyManager.Export(ExportDir)
|
||||
}
|
||||
exit(err)
|
||||
default:
|
||||
// Creates a keypair if none exists
|
||||
err = keyManager.Init(KeyRing, 0, false)
|
||||
if err != nil {
|
||||
exit(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
|
||||
var err error
|
||||
ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort)
|
||||
if err != nil {
|
||||
logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
|
||||
} else {
|
||||
go ethereum.RpcServer.Start()
|
||||
}
|
||||
}
|
||||
|
||||
var miner ethminer.Miner
|
||||
|
||||
func StartMining(ethereum *eth.Ethereum) bool {
|
||||
if !ethereum.Mining {
|
||||
ethereum.Mining = true
|
||||
|
||||
addr := ethereum.KeyManager().Address()
|
||||
|
||||
go func() {
|
||||
miner = ethminer.NewDefaultMiner(addr, ethereum)
|
||||
// Give it some time to connect with peers
|
||||
time.Sleep(3 * time.Second)
|
||||
for !ethereum.IsUpToDate() == false {
|
||||
time.Sleep(5 * time.Second)
|
||||
}
|
||||
|
||||
logger.Infoln("Miner started")
|
||||
miner := ethminer.NewDefaultMiner(addr, ethereum)
|
||||
miner.Start()
|
||||
}()
|
||||
RegisterInterrupt(func(os.Signal) {
|
||||
StopMining(ethereum)
|
||||
})
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func StopMining(ethereum *eth.Ethereum) bool {
|
||||
if ethereum.Mining {
|
||||
miner.Stop()
|
||||
logger.Infoln("Miner stopped")
|
||||
ethereum.Mining = false
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Replay block
|
||||
func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
|
||||
block := ethereum.BlockChain().GetBlock(hash)
|
||||
if block == nil {
|
||||
return fmt.Errorf("unknown block %x", hash)
|
||||
}
|
||||
|
||||
parent := ethereum.BlockChain().GetBlock(block.PrevHash)
|
||||
|
||||
_, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
|
||||
}
|
||||
Loading…
Reference in New Issue