mirror of
https://gitlab.com/pulsechaincom/go-pulse.git
synced 2024-12-26 13:18:22 +00:00
106 lines
3.2 KiB
Go
106 lines
3.2 KiB
Go
// Contains the external API to the whisper sub-protocol.
|
|
|
|
package xeth
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/logger"
|
|
"github.com/ethereum/go-ethereum/whisper"
|
|
)
|
|
|
|
var qlogger = logger.NewLogger("XSHH")
|
|
|
|
// Whisper represents the API wrapper around the internal whisper implementation.
|
|
type Whisper struct {
|
|
*whisper.Whisper
|
|
}
|
|
|
|
// NewWhisper wraps an internal whisper client into an external API version.
|
|
func NewWhisper(w *whisper.Whisper) *Whisper {
|
|
return &Whisper{w}
|
|
}
|
|
|
|
// NewIdentity generates a new cryptographic identity for the client, and injects
|
|
// it into the known identities for message decryption.
|
|
func (self *Whisper) NewIdentity() string {
|
|
identity := self.Whisper.NewIdentity()
|
|
return common.ToHex(crypto.FromECDSAPub(&identity.PublicKey))
|
|
}
|
|
|
|
// HasIdentity checks if the the whisper node is configured with the private key
|
|
// of the specified public pair.
|
|
func (self *Whisper) HasIdentity(key string) bool {
|
|
return self.Whisper.HasIdentity(crypto.ToECDSAPub(common.FromHex(key)))
|
|
}
|
|
|
|
// Post injects a message into the whisper network for distribution.
|
|
func (self *Whisper) Post(payload string, to, from string, topics []string, priority, ttl uint32) error {
|
|
// Decode the topic strings
|
|
topicsDecoded := make([][]byte, len(topics))
|
|
for i, topic := range topics {
|
|
topicsDecoded[i] = common.FromHex(topic)
|
|
}
|
|
// Construct the whisper message and transmission options
|
|
message := whisper.NewMessage(common.FromHex(payload))
|
|
options := whisper.Options{
|
|
To: crypto.ToECDSAPub(common.FromHex(to)),
|
|
TTL: time.Duration(ttl) * time.Second,
|
|
Topics: whisper.NewTopics(topicsDecoded...),
|
|
}
|
|
if len(from) != 0 {
|
|
if key := self.Whisper.GetIdentity(crypto.ToECDSAPub(common.FromHex(from))); key != nil {
|
|
options.From = key
|
|
} else {
|
|
return fmt.Errorf("unknown identity to send from: %s", from)
|
|
}
|
|
}
|
|
// Wrap and send the message
|
|
pow := time.Duration(priority) * time.Millisecond
|
|
envelope, err := message.Wrap(pow, options)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := self.Whisper.Send(envelope); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Watch installs a new message handler to run in case a matching packet arrives
|
|
// from the whisper network.
|
|
func (self *Whisper) Watch(to, from string, topics [][]string, fn func(WhisperMessage)) int {
|
|
// Decode the topic strings
|
|
topicsDecoded := make([][][]byte, len(topics))
|
|
for i, condition := range topics {
|
|
topicsDecoded[i] = make([][]byte, len(condition))
|
|
for j, topic := range condition {
|
|
topicsDecoded[i][j] = common.FromHex(topic)
|
|
}
|
|
}
|
|
// Assemble and inject the filter into the whisper client
|
|
filter := whisper.Filter{
|
|
To: crypto.ToECDSAPub(common.FromHex(to)),
|
|
From: crypto.ToECDSAPub(common.FromHex(from)),
|
|
Topics: whisper.NewFilterTopics(topicsDecoded...),
|
|
}
|
|
filter.Fn = func(message *whisper.Message) {
|
|
fn(NewWhisperMessage(message))
|
|
}
|
|
return self.Whisper.Watch(filter)
|
|
}
|
|
|
|
// Messages retrieves all the currently pooled messages matching a filter id.
|
|
func (self *Whisper) Messages(id int) []WhisperMessage {
|
|
pool := self.Whisper.Messages(id)
|
|
|
|
messages := make([]WhisperMessage, len(pool))
|
|
for i, message := range pool {
|
|
messages[i] = NewWhisperMessage(message)
|
|
}
|
|
return messages
|
|
}
|