forked from cerc-io/plugeth
mobile: add whisper client (#15922)
This commit is contained in:
parent
cc2b39bbd1
commit
6fc8494620
@ -138,7 +138,9 @@ func (ec *EthereumClient) SubscribeNewHead(ctx *Context, handler NewHeadHandler,
|
||||
handler.OnNewHead(&Header{header})
|
||||
|
||||
case err := <-rawSub.Err():
|
||||
handler.OnError(err.Error())
|
||||
if err != nil {
|
||||
handler.OnError(err.Error())
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
@ -227,7 +229,9 @@ func (ec *EthereumClient) SubscribeFilterLogs(ctx *Context, query *FilterQuery,
|
||||
handler.OnFilterLogs(&Log{&log})
|
||||
|
||||
case err := <-rawSub.Err():
|
||||
handler.OnError(err.Error())
|
||||
if err != nil {
|
||||
handler.OnError(err.Error())
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
195
mobile/shhclient.go
Normal file
195
mobile/shhclient.go
Normal file
@ -0,0 +1,195 @@
|
||||
// Copyright 2017 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
// Contains a wrapper for the Whisper client.
|
||||
|
||||
package geth
|
||||
|
||||
import (
|
||||
"github.com/ethereum/go-ethereum/whisper/shhclient"
|
||||
whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
|
||||
)
|
||||
|
||||
// WhisperClient provides access to the Ethereum APIs.
|
||||
type WhisperClient struct {
|
||||
client *shhclient.Client
|
||||
}
|
||||
|
||||
// NewWhisperClient connects a client to the given URL.
|
||||
func NewWhisperClient(rawurl string) (client *WhisperClient, _ error) {
|
||||
rawClient, err := shhclient.Dial(rawurl)
|
||||
return &WhisperClient{rawClient}, err
|
||||
}
|
||||
|
||||
// GetVersion returns the Whisper sub-protocol version.
|
||||
func (wc *WhisperClient) GetVersion(ctx *Context) (version string, _ error) {
|
||||
return wc.client.Version(ctx.context)
|
||||
}
|
||||
|
||||
// Info returns diagnostic information about the whisper node.
|
||||
func (wc *WhisperClient) GetInfo(ctx *Context) (info *Info, _ error) {
|
||||
rawInfo, err := wc.client.Info(ctx.context)
|
||||
return &Info{&rawInfo}, err
|
||||
}
|
||||
|
||||
// SetMaxMessageSize sets the maximal message size allowed by this node. Incoming
|
||||
// and outgoing messages with a larger size will be rejected. Whisper message size
|
||||
// can never exceed the limit imposed by the underlying P2P protocol (10 Mb).
|
||||
func (wc *WhisperClient) SetMaxMessageSize(ctx *Context, size int32) error {
|
||||
return wc.client.SetMaxMessageSize(ctx.context, uint32(size))
|
||||
}
|
||||
|
||||
// SetMinimumPoW (experimental) sets the minimal PoW required by this node.
|
||||
// This experimental function was introduced for the future dynamic adjustment of
|
||||
// PoW requirement. If the node is overwhelmed with messages, it should raise the
|
||||
// PoW requirement and notify the peers. The new value should be set relative to
|
||||
// the old value (e.g. double). The old value could be obtained via shh_info call.
|
||||
func (wc *WhisperClient) SetMinimumPoW(ctx *Context, pow float64) error {
|
||||
return wc.client.SetMinimumPoW(ctx.context, pow)
|
||||
}
|
||||
|
||||
// Marks specific peer trusted, which will allow it to send historic (expired) messages.
|
||||
// Note This function is not adding new nodes, the node needs to exists as a peer.
|
||||
func (wc *WhisperClient) MarkTrustedPeer(ctx *Context, enode string) error {
|
||||
return wc.client.MarkTrustedPeer(ctx.context, enode)
|
||||
}
|
||||
|
||||
// NewKeyPair generates a new public and private key pair for message decryption and encryption.
|
||||
// It returns an identifier that can be used to refer to the key.
|
||||
func (wc *WhisperClient) NewKeyPair(ctx *Context) (string, error) {
|
||||
return wc.client.NewKeyPair(ctx.context)
|
||||
}
|
||||
|
||||
// AddPrivateKey stored the key pair, and returns its ID.
|
||||
func (wc *WhisperClient) AddPrivateKey(ctx *Context, key []byte) (string, error) {
|
||||
return wc.client.AddPrivateKey(ctx.context, key)
|
||||
}
|
||||
|
||||
// DeleteKeyPair delete the specifies key.
|
||||
func (wc *WhisperClient) DeleteKeyPair(ctx *Context, id string) (string, error) {
|
||||
return wc.client.DeleteKeyPair(ctx.context, id)
|
||||
}
|
||||
|
||||
// HasKeyPair returns an indication if the node has a private key or
|
||||
// key pair matching the given ID.
|
||||
func (wc *WhisperClient) HasKeyPair(ctx *Context, id string) (bool, error) {
|
||||
return wc.client.HasKeyPair(ctx.context, id)
|
||||
}
|
||||
|
||||
// GetPublicKey return the public key for a key ID.
|
||||
func (wc *WhisperClient) GetPublicKey(ctx *Context, id string) ([]byte, error) {
|
||||
return wc.client.PublicKey(ctx.context, id)
|
||||
}
|
||||
|
||||
// GetPrivateKey return the private key for a key ID.
|
||||
func (wc *WhisperClient) GetPrivateKey(ctx *Context, id string) ([]byte, error) {
|
||||
return wc.client.PrivateKey(ctx.context, id)
|
||||
}
|
||||
|
||||
// NewSymmetricKey generates a random symmetric key and returns its identifier.
|
||||
// Can be used encrypting and decrypting messages where the key is known to both parties.
|
||||
func (wc *WhisperClient) NewSymmetricKey(ctx *Context) (string, error) {
|
||||
return wc.client.NewSymmetricKey(ctx.context)
|
||||
}
|
||||
|
||||
// AddSymmetricKey stores the key, and returns its identifier.
|
||||
func (wc *WhisperClient) AddSymmetricKey(ctx *Context, key []byte) (string, error) {
|
||||
return wc.client.AddSymmetricKey(ctx.context, key)
|
||||
}
|
||||
|
||||
// GenerateSymmetricKeyFromPassword generates the key from password, stores it, and returns its identifier.
|
||||
func (wc *WhisperClient) GenerateSymmetricKeyFromPassword(ctx *Context, passwd string) (string, error) {
|
||||
return wc.client.GenerateSymmetricKeyFromPassword(ctx.context, passwd)
|
||||
}
|
||||
|
||||
// HasSymmetricKey returns an indication if the key associated with the given id is stored in the node.
|
||||
func (wc *WhisperClient) HasSymmetricKey(ctx *Context, id string) (bool, error) {
|
||||
return wc.client.HasSymmetricKey(ctx.context, id)
|
||||
}
|
||||
|
||||
// GetSymmetricKey returns the symmetric key associated with the given identifier.
|
||||
func (wc *WhisperClient) GetSymmetricKey(ctx *Context, id string) ([]byte, error) {
|
||||
return wc.client.GetSymmetricKey(ctx.context, id)
|
||||
}
|
||||
|
||||
// DeleteSymmetricKey deletes the symmetric key associated with the given identifier.
|
||||
func (wc *WhisperClient) DeleteSymmetricKey(ctx *Context, id string) error {
|
||||
return wc.client.DeleteSymmetricKey(ctx.context, id)
|
||||
}
|
||||
|
||||
// Post a message onto the network.
|
||||
func (wc *WhisperClient) Post(ctx *Context, message *NewMessage) (string, error) {
|
||||
return wc.client.Post(ctx.context, *message.newMessage)
|
||||
}
|
||||
|
||||
// NewHeadHandler is a client-side subscription callback to invoke on events and
|
||||
// subscription failure.
|
||||
type NewMessageHandler interface {
|
||||
OnNewMessage(message *Message)
|
||||
OnError(failure string)
|
||||
}
|
||||
|
||||
// SubscribeMessages subscribes to messages that match the given criteria. This method
|
||||
// is only supported on bi-directional connections such as websockets and IPC.
|
||||
// NewMessageFilter uses polling and is supported over HTTP.
|
||||
func (wc *WhisperClient) SubscribeMessages(ctx *Context, criteria *Criteria, handler NewMessageHandler, buffer int) (*Subscription, error) {
|
||||
// Subscribe to the event internally
|
||||
ch := make(chan *whisper.Message, buffer)
|
||||
rawSub, err := wc.client.SubscribeMessages(ctx.context, *criteria.criteria, ch)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Start up a dispatcher to feed into the callback
|
||||
go func() {
|
||||
for {
|
||||
select {
|
||||
case message := <-ch:
|
||||
handler.OnNewMessage(&Message{message})
|
||||
|
||||
case err := <-rawSub.Err():
|
||||
if err != nil {
|
||||
handler.OnError(err.Error())
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
return &Subscription{rawSub}, nil
|
||||
}
|
||||
|
||||
// NewMessageFilter creates a filter within the node. This filter can be used to poll
|
||||
// for new messages (see FilterMessages) that satisfy the given criteria. A filter can
|
||||
// timeout when it was polled for in whisper.filterTimeout.
|
||||
func (wc *WhisperClient) NewMessageFilter(ctx *Context, criteria *Criteria) (string, error) {
|
||||
return wc.client.NewMessageFilter(ctx.context, *criteria.criteria)
|
||||
}
|
||||
|
||||
// DeleteMessageFilter removes the filter associated with the given id.
|
||||
func (wc *WhisperClient) DeleteMessageFilter(ctx *Context, id string) error {
|
||||
return wc.client.DeleteMessageFilter(ctx.context, id)
|
||||
}
|
||||
|
||||
// GetFilterMessages retrieves all messages that are received between the last call to
|
||||
// this function and match the criteria that where given when the filter was created.
|
||||
func (wc *WhisperClient) GetFilterMessages(ctx *Context, id string) (*Messages, error) {
|
||||
rawFilterMessages, err := wc.client.FilterMessages(ctx.context, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
res := make([]*whisper.Message, len(rawFilterMessages))
|
||||
copy(res, rawFilterMessages)
|
||||
return &Messages{res}, nil
|
||||
}
|
@ -26,6 +26,7 @@ import (
|
||||
"github.com/ethereum/go-ethereum/common"
|
||||
"github.com/ethereum/go-ethereum/core/types"
|
||||
"github.com/ethereum/go-ethereum/rlp"
|
||||
whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
|
||||
)
|
||||
|
||||
// A Nonce is a 64-bit hash which proves (combined with the mix-hash) that
|
||||
@ -334,3 +335,95 @@ func (r *Receipt) GetLogs() *Logs { return &Logs{r.receipt.Logs} }
|
||||
func (r *Receipt) GetTxHash() *Hash { return &Hash{r.receipt.TxHash} }
|
||||
func (r *Receipt) GetContractAddress() *Address { return &Address{r.receipt.ContractAddress} }
|
||||
func (r *Receipt) GetGasUsed() int64 { return int64(r.receipt.GasUsed) }
|
||||
|
||||
// Info represents a diagnostic information about the whisper node.
|
||||
type Info struct {
|
||||
info *whisper.Info
|
||||
}
|
||||
|
||||
// NewMessage represents a new whisper message that is posted through the RPC.
|
||||
type NewMessage struct {
|
||||
newMessage *whisper.NewMessage
|
||||
}
|
||||
|
||||
func NewNewMessage() *NewMessage {
|
||||
nm := &NewMessage{
|
||||
newMessage: new(whisper.NewMessage),
|
||||
}
|
||||
return nm
|
||||
}
|
||||
|
||||
func (nm *NewMessage) GetSymKeyID() string { return nm.newMessage.SymKeyID }
|
||||
func (nm *NewMessage) SetSymKeyID(symKeyID string) { nm.newMessage.SymKeyID = symKeyID }
|
||||
func (nm *NewMessage) GetPublicKey() []byte { return nm.newMessage.PublicKey }
|
||||
func (nm *NewMessage) SetPublicKey(publicKey []byte) {
|
||||
nm.newMessage.PublicKey = common.CopyBytes(publicKey)
|
||||
}
|
||||
func (nm *NewMessage) GetSig() string { return nm.newMessage.Sig }
|
||||
func (nm *NewMessage) SetSig(sig string) { nm.newMessage.Sig = sig }
|
||||
func (nm *NewMessage) GetTTL() int64 { return int64(nm.newMessage.TTL) }
|
||||
func (nm *NewMessage) SetTTL(ttl int64) { nm.newMessage.TTL = uint32(ttl) }
|
||||
func (nm *NewMessage) GetPayload() []byte { return nm.newMessage.Payload }
|
||||
func (nm *NewMessage) SetPayload(payload []byte) { nm.newMessage.Payload = common.CopyBytes(payload) }
|
||||
func (nm *NewMessage) GetPowTime() int64 { return int64(nm.newMessage.PowTime) }
|
||||
func (nm *NewMessage) SetPowTime(powTime int64) { nm.newMessage.PowTime = uint32(powTime) }
|
||||
func (nm *NewMessage) GetPowTarget() float64 { return nm.newMessage.PowTarget }
|
||||
func (nm *NewMessage) SetPowTarget(powTarget float64) { nm.newMessage.PowTarget = powTarget }
|
||||
func (nm *NewMessage) GetTargetPeer() string { return nm.newMessage.TargetPeer }
|
||||
func (nm *NewMessage) SetTargetPeer(targetPeer string) { nm.newMessage.TargetPeer = targetPeer }
|
||||
func (nm *NewMessage) GetTopic() []byte { return nm.newMessage.Topic[:] }
|
||||
func (nm *NewMessage) SetTopic(topic []byte) { nm.newMessage.Topic = whisper.BytesToTopic(topic) }
|
||||
|
||||
// Message represents a whisper message.
|
||||
type Message struct {
|
||||
message *whisper.Message
|
||||
}
|
||||
|
||||
func (m *Message) GetSig() []byte { return m.message.Sig }
|
||||
func (m *Message) GetTTL() int64 { return int64(m.message.TTL) }
|
||||
func (m *Message) GetTimestamp() int64 { return int64(m.message.Timestamp) }
|
||||
func (m *Message) GetPayload() []byte { return m.message.Payload }
|
||||
func (m *Message) GetPoW() float64 { return m.message.PoW }
|
||||
func (m *Message) GetHash() []byte { return m.message.Hash }
|
||||
func (m *Message) GetDst() []byte { return m.message.Dst }
|
||||
|
||||
// Messages represents an array of messages.
|
||||
type Messages struct {
|
||||
messages []*whisper.Message
|
||||
}
|
||||
|
||||
// Size returns the number of messages in the slice.
|
||||
func (m *Messages) Size() int {
|
||||
return len(m.messages)
|
||||
}
|
||||
|
||||
// Get returns the message at the given index from the slice.
|
||||
func (m *Messages) Get(index int) (message *Message, _ error) {
|
||||
if index < 0 || index >= len(m.messages) {
|
||||
return nil, errors.New("index out of bounds")
|
||||
}
|
||||
return &Message{m.messages[index]}, nil
|
||||
}
|
||||
|
||||
// Criteria holds various filter options for inbound messages.
|
||||
type Criteria struct {
|
||||
criteria *whisper.Criteria
|
||||
}
|
||||
|
||||
func NewCriteria(topic []byte) *Criteria {
|
||||
c := &Criteria{
|
||||
criteria: new(whisper.Criteria),
|
||||
}
|
||||
encodedTopic := whisper.BytesToTopic(topic)
|
||||
c.criteria.Topics = []whisper.TopicType{encodedTopic}
|
||||
return c
|
||||
}
|
||||
|
||||
func (c *Criteria) GetSymKeyID() string { return c.criteria.SymKeyID }
|
||||
func (c *Criteria) SetSymKeyID(symKeyID string) { c.criteria.SymKeyID = symKeyID }
|
||||
func (c *Criteria) GetPrivateKeyID() string { return c.criteria.PrivateKeyID }
|
||||
func (c *Criteria) SetPrivateKeyID(privateKeyID string) { c.criteria.PrivateKeyID = privateKeyID }
|
||||
func (c *Criteria) GetSig() []byte { return c.criteria.Sig }
|
||||
func (c *Criteria) SetSig(sig []byte) { c.criteria.Sig = common.CopyBytes(sig) }
|
||||
func (c *Criteria) GetMinPow() float64 { return c.criteria.MinPow }
|
||||
func (c *Criteria) SetMinPow(pow float64) { c.criteria.MinPow = pow }
|
||||
|
Loading…
Reference in New Issue
Block a user