From cebb149f5cfaf008240d7069fd220401950cc7ee Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Wed, 28 Jan 2015 20:50:09 +0100
Subject: removed key while in the process of moving to the new key storage
---
xeth/xeth.go | 68 ++++++++++++++++++++++++++++++++++++++++++++++++------------
1 file changed, 55 insertions(+), 13 deletions(-)
(limited to 'xeth')
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 96e545b35..89b2459b0 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -22,7 +22,6 @@ var pipelogger = logger.NewLogger("XETH")
type Backend interface {
BlockProcessor() *core.BlockProcessor
ChainManager() *core.ChainManager
- Coinbase() []byte
KeyManager() *crypto.KeyManager
IsMining() bool
IsListening() bool
@@ -82,14 +81,6 @@ func (self *XEth) Accounts() []string {
return []string{toHex(self.eth.KeyManager().Address())}
}
-/*
-func (self *XEth) StateObject(addr string) *Object {
- object := &Object{self.State().safeGet(fromHex(addr))}
-
- return NewObject(object)
-}
-*/
-
func (self *XEth) PeerCount() int {
return self.eth.PeerCount()
}
@@ -190,10 +181,6 @@ func (self *XEth) FromNumber(str string) string {
return ethutil.BigD(fromHex(str)).String()
}
-func (self *XEth) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
- return "", nil
-}
-
func ToMessages(messages state.Messages) *ethutil.List {
var msgs []Message
for _, m := range messages {
@@ -216,3 +203,58 @@ func (self *XEth) PushTx(encodedTx string) (string, error) {
}
return toHex(tx.Hash()), nil
}
+
+func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
+
+ var (
+ to []byte
+ value = ethutil.NewValue(valueStr)
+ gas = ethutil.NewValue(gasStr)
+ price = ethutil.NewValue(gasPriceStr)
+ data []byte
+ key = self.eth.KeyManager().KeyPair()
+ contractCreation bool
+ )
+
+ data = fromHex(codeStr)
+ to = fromHex(toStr)
+ if len(to) == 0 {
+ contractCreation = true
+ }
+
+ var tx *types.Transaction
+ if contractCreation {
+ tx = types.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), data)
+ } else {
+ tx = types.NewTransactionMessage(to, value.BigInt(), gas.BigInt(), price.BigInt(), data)
+ }
+
+ state := self.chainManager.TransState()
+ nonce := state.GetNonce(key.Address())
+
+ tx.SetNonce(nonce)
+ tx.Sign(key.PrivateKey)
+
+ // Do some pre processing for our "pre" events and hooks
+ block := self.chainManager.NewBlock(key.Address())
+ coinbase := state.GetOrNewStateObject(key.Address())
+ coinbase.SetGasPool(block.GasLimit())
+ self.blockProcessor.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)
+
+ err := self.eth.TxPool().Add(tx)
+ if err != nil {
+ return "", err
+ }
+ state.SetNonce(key.Address(), nonce+1)
+
+ if contractCreation {
+ addr := core.AddressFromMessage(tx)
+ pipelogger.Infof("Contract addr %x\n", addr)
+ }
+
+ if types.IsContractAddr(to) {
+ return toHex(core.AddressFromMessage(tx)), nil
+ }
+
+ return toHex(tx.Hash()), nil
+}
--
cgit v1.2.3
From 84adf77bf3492351de82f0ec820a1d280e85a5cd Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Thu, 29 Jan 2015 13:10:34 +0100
Subject: Added RPC "Call" for JS calls to contracts
---
xeth/xeth.go | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
(limited to 'xeth')
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 89b2459b0..382a1f285 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -204,6 +204,34 @@ func (self *XEth) PushTx(encodedTx string) (string, error) {
return toHex(tx.Hash()), nil
}
+func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, error) {
+ if len(gasStr) == 0 {
+ gasStr = "100000"
+ }
+ if len(gasPriceStr) == 0 {
+ gasPriceStr = "1"
+ }
+
+ var (
+ statedb = self.chainManager.TransState()
+ initiator = state.NewStateObject(self.eth.KeyManager().KeyPair().Address(), self.eth.Db())
+ block = self.chainManager.CurrentBlock()
+ to = statedb.GetOrNewStateObject(fromHex(toStr))
+ data = fromHex(dataStr)
+ gas = ethutil.Big(gasStr)
+ price = ethutil.Big(gasPriceStr)
+ value = ethutil.Big(valueStr)
+ )
+
+ vmenv := NewEnv(self.chainManager, statedb, block, value, initiator.Address())
+ res, err := vmenv.Call(initiator, to.Address(), data, gas, price, value)
+ if err != nil {
+ return "", err
+ }
+
+ return toHex(res), nil
+}
+
func (self *XEth) Transact(toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) {
var (
--
cgit v1.2.3
From 6488a392a347d0d47212fdc78386e3e0e5841d7d Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Thu, 29 Jan 2015 16:52:00 +0100
Subject: Reimplemented message filters for rpc calls
---
xeth/xeth.go | 21 +++++++++++++++------
1 file changed, 15 insertions(+), 6 deletions(-)
(limited to 'xeth')
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 382a1f285..4cfa104d0 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -12,7 +12,9 @@ import (
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/state"
)
@@ -22,19 +24,22 @@ var pipelogger = logger.NewLogger("XETH")
type Backend interface {
BlockProcessor() *core.BlockProcessor
ChainManager() *core.ChainManager
- KeyManager() *crypto.KeyManager
+ TxPool() *core.TxPool
+ PeerCount() int
IsMining() bool
IsListening() bool
- PeerCount() int
+ Peers() []*p2p.Peer
+ KeyManager() *crypto.KeyManager
+ ClientIdentity() p2p.ClientIdentity
Db() ethutil.Database
- TxPool() *core.TxPool
+ EventMux() *event.TypeMux
}
type XEth struct {
eth Backend
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
- world *State
+ state *State
}
func New(eth Backend) *XEth {
@@ -43,12 +48,16 @@ func New(eth Backend) *XEth {
blockProcessor: eth.BlockProcessor(),
chainManager: eth.ChainManager(),
}
- xeth.world = NewState(xeth)
+ xeth.state = NewState(xeth)
return xeth
}
-func (self *XEth) State() *State { return self.world }
+func (self *XEth) Backend() Backend {
+ return self.eth
+}
+
+func (self *XEth) State() *State { return self.state }
func (self *XEth) BlockByHash(strHash string) *Block {
hash := fromHex(strHash)
--
cgit v1.2.3
From 0031f388ac1f6f4a23c5c75e5eeb4a007f0b2f31 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Thu, 29 Jan 2015 20:39:26 +0100
Subject: More dapp samples
* Info DApp, coin DApp
* Additional rpc methods
---
xeth/types.go | 19 +++++++++++++++----
xeth/world.go | 2 +-
2 files changed, 16 insertions(+), 5 deletions(-)
(limited to 'xeth')
diff --git a/xeth/types.go b/xeth/types.go
index 4d8543eb1..bee730ba1 100644
--- a/xeth/types.go
+++ b/xeth/types.go
@@ -35,20 +35,31 @@ func NewObject(state *state.StateObject) *Object {
func (self *Object) StorageString(str string) *ethutil.Value {
if ethutil.IsHex(str) {
- return self.Storage(ethutil.Hex2Bytes(str[2:]))
+ return self.storage(ethutil.Hex2Bytes(str[2:]))
} else {
- return self.Storage(ethutil.RightPadBytes([]byte(str), 32))
+ return self.storage(ethutil.RightPadBytes([]byte(str), 32))
}
}
func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value {
- return self.Storage(addr.Bytes())
+ return self.storage(addr.Bytes())
}
-func (self *Object) Storage(addr []byte) *ethutil.Value {
+func (self *Object) storage(addr []byte) *ethutil.Value {
return self.StateObject.GetStorage(ethutil.BigD(addr))
}
+func (self *Object) Storage() (storage map[string]string) {
+ storage = make(map[string]string)
+
+ it := self.StateObject.Trie().Iterator()
+ for it.Next() {
+ storage[toHex(it.Key)] = toHex(it.Value)
+ }
+
+ return
+}
+
// Block interface exposed to QML
type Block struct {
//Transactions string `json:"transactions"`
diff --git a/xeth/world.go b/xeth/world.go
index cdceec50d..9cbdd9461 100644
--- a/xeth/world.go
+++ b/xeth/world.go
@@ -11,7 +11,7 @@ func NewState(xeth *XEth) *State {
}
func (self *State) State() *state.StateDB {
- return self.xeth.chainManager.State()
+ return self.xeth.chainManager.TransState()
}
func (self *State) Get(addr string) *Object {
--
cgit v1.2.3
From 54927dc0e0b99009f92fbb7b28d71ae20179ce1e Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Thu, 29 Jan 2015 23:58:43 +0100
Subject: Fixed issue with Storage()
* Storage() returned encoded values. They are now decode prior to hexing
* Removed old code from state object
* Updated coin
---
xeth/types.go | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
(limited to 'xeth')
diff --git a/xeth/types.go b/xeth/types.go
index bee730ba1..34caf5cbc 100644
--- a/xeth/types.go
+++ b/xeth/types.go
@@ -1,6 +1,7 @@
package xeth
import (
+ "bytes"
"fmt"
"strings"
@@ -9,6 +10,7 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/p2p"
+ "github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/state"
)
@@ -54,8 +56,11 @@ func (self *Object) Storage() (storage map[string]string) {
it := self.StateObject.Trie().Iterator()
for it.Next() {
- storage[toHex(it.Key)] = toHex(it.Value)
+ var data []byte
+ rlp.Decode(bytes.NewReader(it.Value), &data)
+ storage[toHex(it.Key)] = toHex(data)
}
+ self.StateObject.Trie().PrintRoot()
return
}
--
cgit v1.2.3
From c03d403437c20584bcbf3cf3fa9d79ac7a0a8ca7 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Fri, 30 Jan 2015 13:25:12 +0100
Subject: Added whisper interface for xeth, added examples, updated RPC
* Added RPC methods for whisper
* Added whisper example
---
xeth/whisper.go | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
xeth/xeth.go | 12 +++---
2 files changed, 123 insertions(+), 5 deletions(-)
create mode 100644 xeth/whisper.go
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
new file mode 100644
index 000000000..31201271b
--- /dev/null
+++ b/xeth/whisper.go
@@ -0,0 +1,116 @@
+package xeth
+
+import (
+ "errors"
+ "fmt"
+ "time"
+
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/whisper"
+)
+
+var qlogger = logger.NewLogger("XSHH")
+
+type Whisper struct {
+ *whisper.Whisper
+}
+
+func NewWhisper(w *whisper.Whisper) *Whisper {
+ return &Whisper{w}
+}
+
+func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error {
+ if priority == 0 {
+ priority = 1000
+ }
+
+ if ttl == 0 {
+ ttl = 100
+ }
+
+ pk := crypto.ToECDSAPub(fromHex(from))
+ if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 {
+ msg := whisper.NewMessage(fromHex(payload))
+ envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
+ Ttl: time.Duration(ttl) * time.Second,
+ To: crypto.ToECDSAPub(fromHex(to)),
+ From: key,
+ Topics: whisper.TopicsFromString(topics...),
+ })
+
+ if err != nil {
+ return err
+ }
+
+ if err := self.Whisper.Send(envelope); err != nil {
+ return err
+ }
+ } else {
+ return errors.New("unmatched pub / priv for seal")
+ }
+
+ return nil
+}
+
+func (self *Whisper) NewIdentity() string {
+ key := self.Whisper.NewIdentity()
+
+ return toHex(crypto.FromECDSAPub(&key.PublicKey))
+}
+
+func (self *Whisper) HasIdentity(key string) bool {
+ return self.Whisper.HasIdentity(crypto.ToECDSAPub(fromHex(key)))
+}
+
+func (self *Whisper) Watch(opts *Options) int {
+ filter := whisper.Filter{
+ To: crypto.ToECDSA(fromHex(opts.To)),
+ From: crypto.ToECDSAPub(fromHex(opts.From)),
+ Topics: whisper.TopicsFromString(opts.Topics...),
+ }
+
+ var i int
+ filter.Fn = func(msg *whisper.Message) {
+ opts.Fn(NewWhisperMessage(msg))
+ }
+ fmt.Println("new filter", filter)
+
+ i = self.Whisper.Watch(filter)
+
+ return i
+}
+
+func (self *Whisper) Messages(id int) (messages []WhisperMessage) {
+ msgs := self.Whisper.Messages(id)
+ messages = make([]WhisperMessage, len(msgs))
+ for i, message := range msgs {
+ messages[i] = NewWhisperMessage(message)
+ }
+
+ return
+}
+
+type Options struct {
+ To string
+ From string
+ Topics []string
+ Fn func(msg WhisperMessage)
+}
+
+type WhisperMessage struct {
+ ref *whisper.Message
+ Flags int32 `json:"flags"`
+ Payload string `json:"payload"`
+ From string `json:"from"`
+}
+
+func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
+ return WhisperMessage{
+ ref: msg,
+ Flags: int32(msg.Flags),
+ Payload: "0x" + ethutil.Bytes2Hex(msg.Payload),
+ From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())),
+ }
+}
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 4cfa104d0..a65fa1331 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -16,6 +16,7 @@ import (
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/p2p"
"github.com/ethereum/go-ethereum/state"
+ "github.com/ethereum/go-ethereum/whisper"
)
var pipelogger = logger.NewLogger("XETH")
@@ -33,6 +34,7 @@ type Backend interface {
ClientIdentity() p2p.ClientIdentity
Db() ethutil.Database
EventMux() *event.TypeMux
+ Whisper() *whisper.Whisper
}
type XEth struct {
@@ -40,6 +42,7 @@ type XEth struct {
blockProcessor *core.BlockProcessor
chainManager *core.ChainManager
state *State
+ whisper *Whisper
}
func New(eth Backend) *XEth {
@@ -47,17 +50,16 @@ func New(eth Backend) *XEth {
eth: eth,
blockProcessor: eth.BlockProcessor(),
chainManager: eth.ChainManager(),
+ whisper: NewWhisper(eth.Whisper()),
}
xeth.state = NewState(xeth)
return xeth
}
-func (self *XEth) Backend() Backend {
- return self.eth
-}
-
-func (self *XEth) State() *State { return self.state }
+func (self *XEth) Backend() Backend { return self.eth }
+func (self *XEth) State() *State { return self.state }
+func (self *XEth) Whisper() *Whisper { return self.whisper }
func (self *XEth) BlockByHash(strHash string) *Block {
hash := fromHex(strHash)
--
cgit v1.2.3
From 2d9b3aa537a901d9b5b3aa951d71d9977c6e4703 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Fri, 30 Jan 2015 17:00:33 +0100
Subject: Removed debug log
---
xeth/whisper.go | 2 --
1 file changed, 2 deletions(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index 31201271b..32ad1332b 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -2,7 +2,6 @@ package xeth
import (
"errors"
- "fmt"
"time"
"github.com/ethereum/go-ethereum/crypto"
@@ -75,7 +74,6 @@ func (self *Whisper) Watch(opts *Options) int {
filter.Fn = func(msg *whisper.Message) {
opts.Fn(NewWhisperMessage(msg))
}
- fmt.Println("new filter", filter)
i = self.Whisper.Watch(filter)
--
cgit v1.2.3
From d52878c744fd7acce727feb41c2d4296e56826d3 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Sun, 1 Feb 2015 15:29:57 +0100
Subject: Removed some VMEnv & Added VmType() to vm.Environment
---
xeth/vm_env.go | 72 ----------------------------------------------------------
xeth/xeth.go | 24 ++++++++++++--------
2 files changed, 14 insertions(+), 82 deletions(-)
delete mode 100644 xeth/vm_env.go
(limited to 'xeth')
diff --git a/xeth/vm_env.go b/xeth/vm_env.go
deleted file mode 100644
index 1470b9eaa..000000000
--- a/xeth/vm_env.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package xeth
-
-import (
- "math/big"
-
- "github.com/ethereum/go-ethereum/core"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/state"
- "github.com/ethereum/go-ethereum/vm"
-)
-
-type VMEnv struct {
- chain *core.ChainManager
- state *state.StateDB
- block *types.Block
- value *big.Int
- sender []byte
-
- depth int
-}
-
-func NewEnv(chain *core.ChainManager, state *state.StateDB, block *types.Block, value *big.Int, sender []byte) *VMEnv {
- return &VMEnv{
- state: state,
- block: block,
- value: value,
- sender: sender,
- }
-}
-
-func (self *VMEnv) Origin() []byte { return self.sender }
-func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number() }
-func (self *VMEnv) PrevHash() []byte { return self.block.ParentHash() }
-func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase() }
-func (self *VMEnv) Time() int64 { return self.block.Time() }
-func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty() }
-func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit() }
-func (self *VMEnv) Value() *big.Int { return self.value }
-func (self *VMEnv) State() *state.StateDB { return self.state }
-func (self *VMEnv) Depth() int { return self.depth }
-func (self *VMEnv) SetDepth(i int) { self.depth = i }
-func (self *VMEnv) GetHash(n uint64) []byte {
- if block := self.chain.GetBlockByNumber(n); block != nil {
- return block.Hash()
- }
-
- return nil
-}
-func (self *VMEnv) AddLog(log state.Log) {
- self.state.AddLog(log)
-}
-func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
- return vm.Transfer(from, to, amount)
-}
-
-func (self *VMEnv) vm(addr, data []byte, gas, price, value *big.Int) *core.Execution {
- return core.NewExecution(self, addr, data, gas, price, value)
-}
-
-func (self *VMEnv) Call(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
- exe := self.vm(addr, data, gas, price, value)
- return exe.Call(addr, me)
-}
-func (self *VMEnv) CallCode(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error) {
- exe := self.vm(me.Address(), data, gas, price, value)
- return exe.Call(addr, me)
-}
-
-func (self *VMEnv) Create(me vm.ContextRef, addr, data []byte, gas, price, value *big.Int) ([]byte, error, vm.ContextRef) {
- exe := self.vm(addr, data, gas, price, value)
- return exe.Create(me)
-}
diff --git a/xeth/xeth.go b/xeth/xeth.go
index a65fa1331..0e71a0ed9 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -224,18 +224,22 @@ func (self *XEth) Call(toStr, valueStr, gasStr, gasPriceStr, dataStr string) (st
}
var (
- statedb = self.chainManager.TransState()
- initiator = state.NewStateObject(self.eth.KeyManager().KeyPair().Address(), self.eth.Db())
- block = self.chainManager.CurrentBlock()
- to = statedb.GetOrNewStateObject(fromHex(toStr))
- data = fromHex(dataStr)
- gas = ethutil.Big(gasStr)
- price = ethutil.Big(gasPriceStr)
- value = ethutil.Big(valueStr)
+ statedb = self.chainManager.TransState()
+ key = self.eth.KeyManager().KeyPair()
+ from = state.NewStateObject(key.Address(), self.eth.Db())
+ block = self.chainManager.CurrentBlock()
+ to = statedb.GetOrNewStateObject(fromHex(toStr))
+ data = fromHex(dataStr)
+ gas = ethutil.Big(gasStr)
+ price = ethutil.Big(gasPriceStr)
+ value = ethutil.Big(valueStr)
)
- vmenv := NewEnv(self.chainManager, statedb, block, value, initiator.Address())
- res, err := vmenv.Call(initiator, to.Address(), data, gas, price, value)
+ msg := types.NewTransactionMessage(fromHex(toStr), value, gas, price, data)
+ msg.Sign(key.PrivateKey)
+ vmenv := core.NewEnv(statedb, self.chainManager, msg, block)
+
+ res, err := vmenv.Call(from, to.Address(), data, gas, price, value)
if err != nil {
return "", err
}
--
cgit v1.2.3
From 623469cb6c6cdb6ff84dc2cb7d4409e9d7cf3f65 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Tue, 3 Feb 2015 06:56:19 -0800
Subject: Added missing whisper timestamp. Closes #284
---
xeth/whisper.go | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index 32ad1332b..d537f8c54 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -99,16 +99,16 @@ type Options struct {
type WhisperMessage struct {
ref *whisper.Message
- Flags int32 `json:"flags"`
Payload string `json:"payload"`
From string `json:"from"`
+ Sent uint64 `json:"time"`
}
func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
return WhisperMessage{
ref: msg,
- Flags: int32(msg.Flags),
Payload: "0x" + ethutil.Bytes2Hex(msg.Payload),
From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())),
+ Sent: msg.Sent,
}
}
--
cgit v1.2.3
From 7bd2fbe2b1445c26190008d21ad52dc5c364765c Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Tue, 3 Feb 2015 07:16:05 -0800
Subject: Fixed whisper "to" filtering. Closes #283
---
xeth/whisper.go | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index d537f8c54..42d7c44bc 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -2,6 +2,7 @@ package xeth
import (
"errors"
+ "fmt"
"time"
"github.com/ethereum/go-ethereum/crypto"
@@ -31,6 +32,7 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio
pk := crypto.ToECDSAPub(fromHex(from))
if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 {
+ fmt.Println("POST:", to)
msg := whisper.NewMessage(fromHex(payload))
envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
Ttl: time.Duration(ttl) * time.Second,
@@ -101,7 +103,7 @@ type WhisperMessage struct {
ref *whisper.Message
Payload string `json:"payload"`
From string `json:"from"`
- Sent uint64 `json:"time"`
+ Sent int64 `json:"time"`
}
func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
--
cgit v1.2.3
From b1870631a4829e075eae77064973ef94aa2166b3 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Wed, 4 Feb 2015 05:52:59 -0800
Subject: WIP miner
---
xeth/whisper.go | 7 ++-----
1 file changed, 2 insertions(+), 5 deletions(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index 42d7c44bc..52f4593e4 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -2,11 +2,9 @@ package xeth
import (
"errors"
- "fmt"
"time"
"github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/logger"
"github.com/ethereum/go-ethereum/whisper"
)
@@ -32,7 +30,6 @@ func (self *Whisper) Post(payload string, to, from string, topics []string, prio
pk := crypto.ToECDSAPub(fromHex(from))
if key := self.Whisper.GetIdentity(pk); key != nil || len(from) == 0 {
- fmt.Println("POST:", to)
msg := whisper.NewMessage(fromHex(payload))
envelope, err := msg.Seal(time.Duration(priority*100000), whisper.Opts{
Ttl: time.Duration(ttl) * time.Second,
@@ -109,8 +106,8 @@ type WhisperMessage struct {
func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
return WhisperMessage{
ref: msg,
- Payload: "0x" + ethutil.Bytes2Hex(msg.Payload),
- From: "0x" + ethutil.Bytes2Hex(crypto.FromECDSAPub(msg.Recover())),
+ Payload: toHex(msg.Payload),
+ From: toHex(crypto.FromECDSAPub(msg.Recover())),
Sent: msg.Sent,
}
}
--
cgit v1.2.3
From e40c1c62ce0c2d9567066d84ea74fd24b424a81a Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Thu, 5 Feb 2015 15:00:59 -0800
Subject: API changed to use Pubkey only. Reflected that change in the rest of
the api
---
xeth/whisper.go | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index 52f4593e4..8e3bcefd0 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -64,7 +64,7 @@ func (self *Whisper) HasIdentity(key string) bool {
func (self *Whisper) Watch(opts *Options) int {
filter := whisper.Filter{
- To: crypto.ToECDSA(fromHex(opts.To)),
+ To: crypto.ToECDSAPub(fromHex(opts.To)),
From: crypto.ToECDSAPub(fromHex(opts.From)),
Topics: whisper.TopicsFromString(opts.Topics...),
}
--
cgit v1.2.3
From ddccea75e8f4931689fdf6b57ec7159b65c0d3c5 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Tue, 10 Feb 2015 13:20:06 +0100
Subject: Fixed "to" field
---
xeth/whisper.go | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
(limited to 'xeth')
diff --git a/xeth/whisper.go b/xeth/whisper.go
index 8e3bcefd0..d9c7e1614 100644
--- a/xeth/whisper.go
+++ b/xeth/whisper.go
@@ -99,8 +99,9 @@ type Options struct {
type WhisperMessage struct {
ref *whisper.Message
Payload string `json:"payload"`
+ To string `json:"to"`
From string `json:"from"`
- Sent int64 `json:"time"`
+ Sent int64 `json:"sent"`
}
func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
@@ -108,6 +109,7 @@ func NewWhisperMessage(msg *whisper.Message) WhisperMessage {
ref: msg,
Payload: toHex(msg.Payload),
From: toHex(crypto.FromECDSAPub(msg.Recover())),
+ To: toHex(crypto.FromECDSAPub(msg.To)),
Sent: msg.Sent,
}
}
--
cgit v1.2.3