104 lines
3.4 KiB
Go
104 lines
3.4 KiB
Go
package gethbridge
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
whispertypes "github.com/status-im/status-go/protocol/transport/whisper/types"
|
|
protocol "github.com/status-im/status-go/protocol/types"
|
|
whisper "github.com/status-im/whisper/whisperv6"
|
|
)
|
|
|
|
type gethPublicWhisperAPIWrapper struct {
|
|
publicWhisperAPI *whisper.PublicWhisperAPI
|
|
}
|
|
|
|
// NewGethPublicWhisperAPIWrapper returns an object that wraps Geth's PublicWhisperAPI in a whispertypes interface
|
|
func NewGethPublicWhisperAPIWrapper(publicWhisperAPI *whisper.PublicWhisperAPI) whispertypes.PublicWhisperAPI {
|
|
if publicWhisperAPI == nil {
|
|
panic("publicWhisperAPI cannot be nil")
|
|
}
|
|
|
|
return &gethPublicWhisperAPIWrapper{
|
|
publicWhisperAPI: publicWhisperAPI,
|
|
}
|
|
}
|
|
|
|
// AddPrivateKey imports the given private key.
|
|
func (w *gethPublicWhisperAPIWrapper) AddPrivateKey(ctx context.Context, privateKey protocol.HexBytes) (string, error) {
|
|
return w.publicWhisperAPI.AddPrivateKey(ctx, hexutil.Bytes(privateKey))
|
|
}
|
|
|
|
// GenerateSymKeyFromPassword derives a key from the given password, stores it, and returns its ID.
|
|
func (w *gethPublicWhisperAPIWrapper) GenerateSymKeyFromPassword(ctx context.Context, passwd string) (string, error) {
|
|
return w.publicWhisperAPI.GenerateSymKeyFromPassword(ctx, passwd)
|
|
}
|
|
|
|
// DeleteKeyPair removes the key with the given key if it exists.
|
|
func (w *gethPublicWhisperAPIWrapper) DeleteKeyPair(ctx context.Context, key string) (bool, error) {
|
|
return w.publicWhisperAPI.DeleteKeyPair(ctx, key)
|
|
}
|
|
|
|
// NewMessageFilter creates a new filter that can be used to poll for
|
|
// (new) messages that satisfy the given criteria.
|
|
func (w *gethPublicWhisperAPIWrapper) NewMessageFilter(req whispertypes.Criteria) (string, error) {
|
|
topics := make([]whisper.TopicType, len(req.Topics))
|
|
for index, tt := range req.Topics {
|
|
topics[index] = whisper.TopicType(tt)
|
|
}
|
|
|
|
criteria := whisper.Criteria{
|
|
SymKeyID: req.SymKeyID,
|
|
PrivateKeyID: req.PrivateKeyID,
|
|
Sig: req.Sig,
|
|
MinPow: req.MinPow,
|
|
Topics: topics,
|
|
AllowP2P: req.AllowP2P,
|
|
}
|
|
return w.publicWhisperAPI.NewMessageFilter(criteria)
|
|
}
|
|
|
|
// GetFilterMessages returns the messages that match the filter criteria and
|
|
// are received between the last poll and now.
|
|
func (w *gethPublicWhisperAPIWrapper) GetFilterMessages(id string) ([]*whispertypes.Message, error) {
|
|
msgs, err := w.publicWhisperAPI.GetFilterMessages(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
wrappedMsgs := make([]*whispertypes.Message, len(msgs))
|
|
for index, msg := range msgs {
|
|
wrappedMsgs[index] = &whispertypes.Message{
|
|
Sig: msg.Sig,
|
|
TTL: msg.TTL,
|
|
Timestamp: msg.Timestamp,
|
|
Topic: whispertypes.TopicType(msg.Topic),
|
|
Payload: msg.Payload,
|
|
Padding: msg.Padding,
|
|
PoW: msg.PoW,
|
|
Hash: msg.Hash,
|
|
Dst: msg.Dst,
|
|
P2P: msg.P2P,
|
|
}
|
|
}
|
|
return wrappedMsgs, nil
|
|
}
|
|
|
|
// Post posts a message on the Whisper network.
|
|
// returns the hash of the message in case of success.
|
|
func (w *gethPublicWhisperAPIWrapper) Post(ctx context.Context, req whispertypes.NewMessage) ([]byte, error) {
|
|
msg := whisper.NewMessage{
|
|
SymKeyID: req.SymKeyID,
|
|
PublicKey: req.PublicKey,
|
|
Sig: req.SigID, // Sig is really a SigID
|
|
TTL: req.TTL,
|
|
Topic: whisper.TopicType(req.Topic),
|
|
Payload: req.Payload,
|
|
Padding: req.Padding,
|
|
PowTime: req.PowTime,
|
|
PowTarget: req.PowTarget,
|
|
TargetPeer: req.TargetPeer,
|
|
}
|
|
return w.publicWhisperAPI.Post(ctx, msg)
|
|
}
|