go-ethereum: github.com/ethereum/go-ethereum/whisper/whisperv6 Index | Files

package whisperv6

import "github.com/ethereum/go-ethereum/whisper/whisperv6"

Index

Package Files

api.go config.go doc.go envelope.go filter.go gen_criteria_json.go gen_message_json.go gen_newmessage_json.go message.go peer.go topic.go whisper.go

Constants

const (
    ProtocolVersion    = uint64(6) // Protocol version number
    ProtocolVersionStr = "6.0"     // The same, as a string
    ProtocolName       = "shh"     // Nickname of the protocol in geth

    NumberOfMessageCodes = 128

    SizeMask = byte(3) // mask used to extract the size of payload size field from the flags

    TopicLength = 4 // in bytes

    BloomFilterSize = 64 // in bytes

    EnvelopeHeaderLength = 20

    MaxMessageSize        = uint32(10 * 1024 * 1024) // maximum accepted size of a message.
    DefaultMaxMessageSize = uint32(1024 * 1024)
    DefaultMinimumPoW     = 0.2

    DefaultTTL           = 50 // seconds
    DefaultSyncAllowance = 10 // seconds
)

Whisper protocol parameters

Variables

var (
    ErrSymAsym              = errors.New("specify either a symmetric or an asymmetric key")
    ErrInvalidSymmetricKey  = errors.New("invalid symmetric key")
    ErrInvalidPublicKey     = errors.New("invalid public key")
    ErrInvalidSigningPubKey = errors.New("invalid signing public key")
    ErrTooLowPoW            = errors.New("message rejected, PoW too low")
    ErrNoTopics             = errors.New("missing topic(s)")
)

List of errors

var DefaultConfig = Config{
    MaxMessageSize:                        DefaultMaxMessageSize,
    MinimumAcceptedPOW:                    DefaultMinimumPoW,
    RestrictConnectionBetweenLightClients: true,
}

DefaultConfig represents (shocker!) the default configuration.

func BloomFilterMatch Uses

func BloomFilterMatch(filter, sample []byte) bool

func BytesToUintBigEndian Uses

func BytesToUintBigEndian(b []byte) (res uint64)

BytesToUintBigEndian converts the slice to 64-bit unsigned integer.

func GenerateRandomID Uses

func GenerateRandomID() (id string, err error)

GenerateRandomID generates a random string, which is then returned to be used as a key id

func IsPubKeyEqual Uses

func IsPubKeyEqual(a, b *ecdsa.PublicKey) bool

IsPubKeyEqual checks that two public keys are equal

func MakeFullNodeBloom Uses

func MakeFullNodeBloom() []byte

func NewSentMessage Uses

func NewSentMessage(params *MessageParams) (*sentMessage, error)

NewSentMessage creates and initializes a non-signed, non-encrypted Whisper message.

func TopicToBloom Uses

func TopicToBloom(topic TopicType) []byte

TopicToBloom converts the topic (4 bytes) to the bloom filter (64 bytes)

func ValidatePublicKey Uses

func ValidatePublicKey(k *ecdsa.PublicKey) bool

ValidatePublicKey checks the format of the given public key.

type Config Uses

type Config struct {
    MaxMessageSize                        uint32  `toml:",omitempty"`
    MinimumAcceptedPOW                    float64 `toml:",omitempty"`
    RestrictConnectionBetweenLightClients bool    `toml:",omitempty"`
}

Config represents the configuration state of a whisper node.

type Criteria Uses

type Criteria struct {
    SymKeyID     string      `json:"symKeyID"`
    PrivateKeyID string      `json:"privateKeyID"`
    Sig          []byte      `json:"sig"`
    MinPow       float64     `json:"minPow"`
    Topics       []TopicType `json:"topics"`
    AllowP2P     bool        `json:"allowP2P"`
}

Criteria holds various filter options for inbound messages.

func (Criteria) MarshalJSON Uses

func (c Criteria) MarshalJSON() ([]byte, error)

MarshalJSON marshals type Criteria to a json string

func (*Criteria) UnmarshalJSON Uses

func (c *Criteria) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals type Criteria to a json string

type Envelope Uses

type Envelope struct {
    Expiry uint32
    TTL    uint32
    Topic  TopicType
    Data   []byte
    Nonce  uint64
    // contains filtered or unexported fields
}

Envelope represents a clear-text data packet to transmit through the Whisper network. Its contents may or may not be encrypted and signed.

func NewEnvelope Uses

func NewEnvelope(ttl uint32, topic TopicType, msg *sentMessage) *Envelope

NewEnvelope wraps a Whisper message with expiration and destination data included into an envelope for network forwarding.

func (*Envelope) Bloom Uses

func (e *Envelope) Bloom() []byte

Bloom maps 4-bytes Topic into 64-byte bloom filter with 3 bits set (at most).

func (*Envelope) DecodeRLP Uses

func (e *Envelope) DecodeRLP(s *rlp.Stream) error

DecodeRLP decodes an Envelope from an RLP data stream.

func (*Envelope) Hash Uses

func (e *Envelope) Hash() common.Hash

Hash returns the SHA3 hash of the envelope, calculating it if not yet done.

func (*Envelope) Open Uses

func (e *Envelope) Open(watcher *Filter) (msg *ReceivedMessage)

Open tries to decrypt an envelope, and populates the message fields in case of success.

func (*Envelope) OpenAsymmetric Uses

func (e *Envelope) OpenAsymmetric(key *ecdsa.PrivateKey) (*ReceivedMessage, error)

OpenAsymmetric tries to decrypt an envelope, potentially encrypted with a particular key.

func (*Envelope) OpenSymmetric Uses

func (e *Envelope) OpenSymmetric(key []byte) (msg *ReceivedMessage, err error)

OpenSymmetric tries to decrypt an envelope, potentially encrypted with a particular key.

func (*Envelope) PoW Uses

func (e *Envelope) PoW() float64

PoW computes (if necessary) and returns the proof of work target of the envelope.

func (*Envelope) Seal Uses

func (e *Envelope) Seal(options *MessageParams) error

Seal closes the envelope by spending the requested amount of time as a proof of work on hashing the data.

type Filter Uses

type Filter struct {
    Src        *ecdsa.PublicKey  // Sender of the message
    KeyAsym    *ecdsa.PrivateKey // Private Key of recipient
    KeySym     []byte            // Key associated with the Topic
    Topics     [][]byte          // Topics to filter messages with
    PoW        float64           // Proof of work as described in the Whisper spec
    AllowP2P   bool              // Indicates whether this filter is interested in direct peer-to-peer messages
    SymKeyHash common.Hash       // The Keccak256Hash of the symmetric key, needed for optimization

    Messages map[common.Hash]*ReceivedMessage
    // contains filtered or unexported fields
}

Filter represents a Whisper message filter

func (*Filter) MatchEnvelope Uses

func (f *Filter) MatchEnvelope(envelope *Envelope) bool

MatchEnvelope checks if it's worth decrypting the message. If it returns `true`, client code is expected to attempt decrypting the message and subsequently call MatchMessage. Topics are not checked here, since this is done by topic matchers.

func (*Filter) MatchMessage Uses

func (f *Filter) MatchMessage(msg *ReceivedMessage) bool

MatchMessage checks if the filter matches an already decrypted message (i.e. a Message that has already been handled by MatchEnvelope when checked by a previous filter). Topics are not checked here, since this is done by topic matchers.

func (*Filter) Retrieve Uses

func (f *Filter) Retrieve() (all []*ReceivedMessage)

Retrieve will return the list of all received messages associated to a filter.

func (*Filter) Trigger Uses

func (f *Filter) Trigger(msg *ReceivedMessage)

Trigger adds a yet-unknown message to the filter's list of received messages.

type Filters Uses

type Filters struct {
    // contains filtered or unexported fields
}

Filters represents a collection of filters

func NewFilters Uses

func NewFilters(w *Whisper) *Filters

NewFilters returns a newly created filter collection

func (*Filters) Get Uses

func (fs *Filters) Get(id string) *Filter

Get returns a filter from the collection with a specific ID

func (*Filters) Install Uses

func (fs *Filters) Install(watcher *Filter) (string, error)

Install will add a new filter to the filter collection

func (*Filters) NotifyWatchers Uses

func (fs *Filters) NotifyWatchers(env *Envelope, p2pMessage bool)

NotifyWatchers notifies any filter that has declared interest for the envelope's topic.

func (*Filters) Uninstall Uses

func (fs *Filters) Uninstall(id string) bool

Uninstall will remove a filter whose id has been specified from the filter collection

type Info Uses

type Info struct {
    Memory         int     `json:"memory"`         // Memory size of the floating messages in bytes.
    Messages       int     `json:"messages"`       // Number of floating messages.
    MinPow         float64 `json:"minPow"`         // Minimal accepted PoW
    MaxMessageSize uint32  `json:"maxMessageSize"` // Maximum accepted message size
}

Info contains diagnostic information.

type MailServer Uses

type MailServer interface {
    Archive(env *Envelope)
    DeliverMail(whisperPeer *Peer, request *Envelope)
}

MailServer represents a mail server, capable of archiving the old messages for subsequent delivery to the peers. Any implementation must ensure that both functions are thread-safe. Also, they must return ASAP. DeliverMail should use directMessagesCode for delivery, in order to bypass the expiry checks.

type Message Uses

type Message struct {
    Sig       []byte    `json:"sig,omitempty"`
    TTL       uint32    `json:"ttl"`
    Timestamp uint32    `json:"timestamp"`
    Topic     TopicType `json:"topic"`
    Payload   []byte    `json:"payload"`
    Padding   []byte    `json:"padding"`
    PoW       float64   `json:"pow"`
    Hash      []byte    `json:"hash"`
    Dst       []byte    `json:"recipientPublicKey,omitempty"`
}

Message is the RPC representation of a whisper message.

func ToWhisperMessage Uses

func ToWhisperMessage(message *ReceivedMessage) *Message

ToWhisperMessage converts an internal message into an API version.

func (Message) MarshalJSON Uses

func (m Message) MarshalJSON() ([]byte, error)

MarshalJSON marshals type Message to a json string

func (*Message) UnmarshalJSON Uses

func (m *Message) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals type Message to a json string

type MessageParams Uses

type MessageParams struct {
    TTL      uint32
    Src      *ecdsa.PrivateKey
    Dst      *ecdsa.PublicKey
    KeySym   []byte
    Topic    TopicType
    WorkTime uint32
    PoW      float64
    Payload  []byte
    Padding  []byte
}

MessageParams specifies the exact way a message should be wrapped into an Envelope.

type NewMessage Uses

type NewMessage struct {
    SymKeyID   string    `json:"symKeyID"`
    PublicKey  []byte    `json:"pubKey"`
    Sig        string    `json:"sig"`
    TTL        uint32    `json:"ttl"`
    Topic      TopicType `json:"topic"`
    Payload    []byte    `json:"payload"`
    Padding    []byte    `json:"padding"`
    PowTime    uint32    `json:"powTime"`
    PowTarget  float64   `json:"powTarget"`
    TargetPeer string    `json:"targetPeer"`
}

NewMessage represents a new whisper message that is posted through the RPC.

func (NewMessage) MarshalJSON Uses

func (n NewMessage) MarshalJSON() ([]byte, error)

MarshalJSON marshals type NewMessage to a json string

func (*NewMessage) UnmarshalJSON Uses

func (n *NewMessage) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals type NewMessage to a json string

type Peer Uses

type Peer struct {
    // contains filtered or unexported fields
}

Peer represents a whisper protocol peer connection.

func (*Peer) ID Uses

func (peer *Peer) ID() []byte

ID returns a peer's id

type PublicWhisperAPI Uses

type PublicWhisperAPI struct {
    // contains filtered or unexported fields
}

PublicWhisperAPI provides the whisper RPC service that can be use publicly without security implications.

func NewPublicWhisperAPI Uses

func NewPublicWhisperAPI(w *Whisper) *PublicWhisperAPI

NewPublicWhisperAPI create a new RPC whisper service.

func (*PublicWhisperAPI) AddPrivateKey Uses

func (api *PublicWhisperAPI) AddPrivateKey(ctx context.Context, privateKey hexutil.Bytes) (string, error)

AddPrivateKey imports the given private key.

func (*PublicWhisperAPI) AddSymKey Uses

func (api *PublicWhisperAPI) AddSymKey(ctx context.Context, key hexutil.Bytes) (string, error)

AddSymKey import a symmetric key. It returns an ID that can be used to refer to the key. Can be used encrypting and decrypting messages where the key is known to both parties.

func (*PublicWhisperAPI) CancelLightClient Uses

func (api *PublicWhisperAPI) CancelLightClient(ctx context.Context) bool

CancelLightClient cancels light client mode.

func (*PublicWhisperAPI) DeleteKeyPair Uses

func (api *PublicWhisperAPI) DeleteKeyPair(ctx context.Context, key string) (bool, error)

DeleteKeyPair removes the key with the given key if it exists.

func (*PublicWhisperAPI) DeleteMessageFilter Uses

func (api *PublicWhisperAPI) DeleteMessageFilter(id string) (bool, error)

DeleteMessageFilter deletes a filter.

func (*PublicWhisperAPI) DeleteSymKey Uses

func (api *PublicWhisperAPI) DeleteSymKey(ctx context.Context, id string) bool

DeleteSymKey deletes the symmetric key that is associated with the given id.

func (*PublicWhisperAPI) GenerateSymKeyFromPassword Uses

func (api *PublicWhisperAPI) GenerateSymKeyFromPassword(ctx context.Context, passwd string) (string, error)

GenerateSymKeyFromPassword derive a key from the given password, stores it, and returns its ID.

func (*PublicWhisperAPI) GetFilterMessages Uses

func (api *PublicWhisperAPI) GetFilterMessages(id string) ([]*Message, error)

GetFilterMessages returns the messages that match the filter criteria and are received between the last poll and now.

func (*PublicWhisperAPI) GetPrivateKey Uses

func (api *PublicWhisperAPI) GetPrivateKey(ctx context.Context, id string) (hexutil.Bytes, error)

GetPrivateKey returns the private key associated with the given key. The key is the hex encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62.

func (*PublicWhisperAPI) GetPublicKey Uses

func (api *PublicWhisperAPI) GetPublicKey(ctx context.Context, id string) (hexutil.Bytes, error)

GetPublicKey returns the public key associated with the given key. The key is the hex encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62.

func (*PublicWhisperAPI) GetSymKey Uses

func (api *PublicWhisperAPI) GetSymKey(ctx context.Context, id string) (hexutil.Bytes, error)

GetSymKey returns the symmetric key associated with the given id.

func (*PublicWhisperAPI) HasKeyPair Uses

func (api *PublicWhisperAPI) HasKeyPair(ctx context.Context, id string) bool

HasKeyPair returns an indication if the node has a key pair that is associated with the given id.

func (*PublicWhisperAPI) HasSymKey Uses

func (api *PublicWhisperAPI) HasSymKey(ctx context.Context, id string) bool

HasSymKey returns an indication if the node has a symmetric key associated with the given key.

func (*PublicWhisperAPI) Info Uses

func (api *PublicWhisperAPI) Info(ctx context.Context) Info

Info returns diagnostic information about the whisper node.

func (*PublicWhisperAPI) MakeLightClient Uses

func (api *PublicWhisperAPI) MakeLightClient(ctx context.Context) bool

MakeLightClient turns the node into light client, which does not forward any incoming messages, and sends only messages originated in this node.

func (*PublicWhisperAPI) MarkTrustedPeer Uses

func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, url string) (bool, error)

MarkTrustedPeer marks a 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 (*PublicWhisperAPI) Messages Uses

func (api *PublicWhisperAPI) Messages(ctx context.Context, crit Criteria) (*rpc.Subscription, error)

Messages set up a subscription that fires events when messages arrive that match the given set of criteria.

func (*PublicWhisperAPI) NewKeyPair Uses

func (api *PublicWhisperAPI) NewKeyPair(ctx context.Context) (string, error)

NewKeyPair generates a new public and private key pair for message decryption and encryption. It returns an ID that can be used to refer to the keypair.

func (*PublicWhisperAPI) NewMessageFilter Uses

func (api *PublicWhisperAPI) NewMessageFilter(req Criteria) (string, error)

NewMessageFilter creates a new filter that can be used to poll for (new) messages that satisfy the given criteria.

func (*PublicWhisperAPI) NewSymKey Uses

func (api *PublicWhisperAPI) NewSymKey(ctx context.Context) (string, error)

NewSymKey generate a random symmetric key. It returns an ID that can be used to refer to the key. Can be used encrypting and decrypting messages where the key is known to both parties.

func (*PublicWhisperAPI) Post Uses

func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (hexutil.Bytes, error)

Post posts a message on the Whisper network. returns the hash of the message in case of success.

func (*PublicWhisperAPI) SetBloomFilter Uses

func (api *PublicWhisperAPI) SetBloomFilter(ctx context.Context, bloom hexutil.Bytes) (bool, error)

SetBloomFilter sets the new value of bloom filter, and notifies the peers.

func (*PublicWhisperAPI) SetMaxMessageSize Uses

func (api *PublicWhisperAPI) SetMaxMessageSize(ctx context.Context, size uint32) (bool, error)

SetMaxMessageSize sets the maximum message size that is accepted. Upper limit is defined by MaxMessageSize.

func (*PublicWhisperAPI) SetMinPoW Uses

func (api *PublicWhisperAPI) SetMinPoW(ctx context.Context, pow float64) (bool, error)

SetMinPoW sets the minimum PoW, and notifies the peers.

func (*PublicWhisperAPI) Version Uses

func (api *PublicWhisperAPI) Version(ctx context.Context) string

Version returns the Whisper sub-protocol version.

type ReceivedMessage Uses

type ReceivedMessage struct {
    Raw []byte

    Payload   []byte
    Padding   []byte
    Signature []byte
    Salt      []byte

    PoW   float64          // Proof of work as described in the Whisper spec
    Sent  uint32           // Time when the message was posted into the network
    TTL   uint32           // Maximum time to live allowed for the message
    Src   *ecdsa.PublicKey // Message recipient (identity used to decode the message)
    Dst   *ecdsa.PublicKey // Message recipient (identity used to decode the message)
    Topic TopicType

    SymKeyHash   common.Hash // The Keccak256Hash of the key
    EnvelopeHash common.Hash // Message envelope hash to act as a unique id
}

ReceivedMessage represents a data packet to be received through the Whisper protocol and successfully decrypted.

func (*ReceivedMessage) SigToPubKey Uses

func (msg *ReceivedMessage) SigToPubKey() *ecdsa.PublicKey

SigToPubKey returns the public key associated to the message's signature.

func (*ReceivedMessage) ValidateAndParse Uses

func (msg *ReceivedMessage) ValidateAndParse() bool

ValidateAndParse checks the message validity and extracts the fields in case of success.

type Statistics Uses

type Statistics struct {
    // contains filtered or unexported fields
}

Statistics holds several message-related counter for analytics purposes.

type TopicType Uses

type TopicType [TopicLength]byte

TopicType represents a cryptographically secure, probabilistic partial classifications of a message, determined as the first (left) 4 bytes of the SHA3 hash of some arbitrary data given by the original author of the message.

func BytesToTopic Uses

func BytesToTopic(b []byte) (t TopicType)

BytesToTopic converts from the byte array representation of a topic into the TopicType type.

func (TopicType) MarshalText Uses

func (t TopicType) MarshalText() ([]byte, error)

MarshalText returns the hex representation of t.

func (*TopicType) String Uses

func (t *TopicType) String() string

String converts a topic byte array to a string representation.

func (*TopicType) UnmarshalText Uses

func (t *TopicType) UnmarshalText(input []byte) error

UnmarshalText parses a hex representation to a topic.

type Whisper Uses

type Whisper struct {
    // contains filtered or unexported fields
}

Whisper represents a dark communication interface through the Ethereum network, using its very own P2P communication layer.

func New Uses

func New(cfg *Config) *Whisper

New creates a Whisper client ready to communicate through the Ethereum P2P network.

func (*Whisper) APIs Uses

func (whisper *Whisper) APIs() []rpc.API

APIs returns the RPC descriptors the Whisper implementation offers

func (*Whisper) AddKeyPair Uses

func (whisper *Whisper) AddKeyPair(key *ecdsa.PrivateKey) (string, error)

AddKeyPair imports a asymmetric private key and returns it identifier.

func (*Whisper) AddSymKeyDirect Uses

func (whisper *Whisper) AddSymKeyDirect(key []byte) (string, error)

AddSymKeyDirect stores the key, and returns its id.

func (*Whisper) AddSymKeyFromPassword Uses

func (whisper *Whisper) AddSymKeyFromPassword(password string) (string, error)

AddSymKeyFromPassword generates the key from password, stores it, and returns its id.

func (*Whisper) AllowP2PMessagesFromPeer Uses

func (whisper *Whisper) AllowP2PMessagesFromPeer(peerID []byte) error

AllowP2PMessagesFromPeer marks specific peer trusted, which will allow it to send historic (expired) messages.

func (*Whisper) BloomFilter Uses

func (whisper *Whisper) BloomFilter() []byte

BloomFilter returns the aggregated bloom filter for all the topics of interest. The nodes are required to send only messages that match the advertised bloom filter. If a message does not match the bloom, it will tantamount to spam, and the peer will be disconnected.

func (*Whisper) BloomFilterTolerance Uses

func (whisper *Whisper) BloomFilterTolerance() []byte

BloomFilterTolerance returns the bloom filter which is tolerated for a limited time after new bloom was advertised to the peers. If sufficient time have elapsed or no change of bloom filter have ever occurred, the return value will be the same as return value of BloomFilter().

func (*Whisper) DeleteKeyPair Uses

func (whisper *Whisper) DeleteKeyPair(key string) bool

DeleteKeyPair deletes the specified key if it exists.

func (*Whisper) DeleteSymKey Uses

func (whisper *Whisper) DeleteSymKey(id string) bool

DeleteSymKey deletes the key associated with the name string if it exists.

func (*Whisper) Envelopes Uses

func (whisper *Whisper) Envelopes() []*Envelope

Envelopes retrieves all the messages currently pooled by the node.

func (*Whisper) GenerateSymKey Uses

func (whisper *Whisper) GenerateSymKey() (string, error)

GenerateSymKey generates a random symmetric key and stores it under id, which is then returned. Will be used in the future for session key exchange.

func (*Whisper) GetEnvelope Uses

func (w *Whisper) GetEnvelope(hash common.Hash) *Envelope

GetEnvelope retrieves an envelope from the message queue by its hash. It returns nil if the envelope can not be found.

func (*Whisper) GetFilter Uses

func (whisper *Whisper) GetFilter(id string) *Filter

GetFilter returns the filter by id.

func (*Whisper) GetPrivateKey Uses

func (whisper *Whisper) GetPrivateKey(id string) (*ecdsa.PrivateKey, error)

GetPrivateKey retrieves the private key of the specified identity.

func (*Whisper) GetSymKey Uses

func (whisper *Whisper) GetSymKey(id string) ([]byte, error)

GetSymKey returns the symmetric key associated with the given id.

func (*Whisper) HandlePeer Uses

func (whisper *Whisper) HandlePeer(peer *p2p.Peer, rw p2p.MsgReadWriter) error

HandlePeer is called by the underlying P2P layer when the whisper sub-protocol connection is negotiated.

func (*Whisper) HasKeyPair Uses

func (whisper *Whisper) HasKeyPair(id string) bool

HasKeyPair checks if the whisper node is configured with the private key of the specified public pair.

func (*Whisper) HasSymKey Uses

func (whisper *Whisper) HasSymKey(id string) bool

HasSymKey returns true if there is a key associated with the given id. Otherwise returns false.

func (*Whisper) LightClientMode Uses

func (whisper *Whisper) LightClientMode() bool

LightClientMode indicates is this node is light client (does not forward any messages)

func (*Whisper) LightClientModeConnectionRestricted Uses

func (whisper *Whisper) LightClientModeConnectionRestricted() bool

LightClientModeConnectionRestricted indicates that connection to light client in light client mode not allowed

func (*Whisper) MaxMessageSize Uses

func (whisper *Whisper) MaxMessageSize() uint32

MaxMessageSize returns the maximum accepted message size.

func (*Whisper) MinPow Uses

func (whisper *Whisper) MinPow() float64

MinPow returns the PoW value required by this node.

func (*Whisper) MinPowTolerance Uses

func (whisper *Whisper) MinPowTolerance() float64

MinPowTolerance returns the value of minimum PoW which is tolerated for a limited time after PoW was changed. If sufficient time have elapsed or no change of PoW have ever occurred, the return value will be the same as return value of MinPow().

func (*Whisper) NewKeyPair Uses

func (whisper *Whisper) NewKeyPair() (string, error)

NewKeyPair generates a new cryptographic identity for the client, and injects it into the known identities for message decryption. Returns ID of the new key pair.

func (*Whisper) Overflow Uses

func (whisper *Whisper) Overflow() bool

Overflow returns an indication if the message queue is full.

func (*Whisper) Protocols Uses

func (whisper *Whisper) Protocols() []p2p.Protocol

Protocols returns the whisper sub-protocols ran by this particular client.

func (*Whisper) RegisterServer Uses

func (whisper *Whisper) RegisterServer(server MailServer)

RegisterServer registers MailServer interface. MailServer will process all the incoming messages with p2pRequestCode.

func (*Whisper) RequestHistoricMessages Uses

func (whisper *Whisper) RequestHistoricMessages(peerID []byte, envelope *Envelope) error

RequestHistoricMessages sends a message with p2pRequestCode to a specific peer, which is known to implement MailServer interface, and is supposed to process this request and respond with a number of peer-to-peer messages (possibly expired), which are not supposed to be forwarded any further. The whisper protocol is agnostic of the format and contents of envelope.

func (*Whisper) Send Uses

func (whisper *Whisper) Send(envelope *Envelope) error

Send injects a message into the whisper send queue, to be distributed in the network in the coming cycles.

func (*Whisper) SendP2PDirect Uses

func (whisper *Whisper) SendP2PDirect(peer *Peer, envelope *Envelope) error

SendP2PDirect sends a peer-to-peer message to a specific peer.

func (*Whisper) SendP2PMessage Uses

func (whisper *Whisper) SendP2PMessage(peerID []byte, envelope *Envelope) error

SendP2PMessage sends a peer-to-peer message to a specific peer.

func (*Whisper) SetBloomFilter Uses

func (whisper *Whisper) SetBloomFilter(bloom []byte) error

SetBloomFilter sets the new bloom filter

func (*Whisper) SetLightClientMode Uses

func (whisper *Whisper) SetLightClientMode(v bool)

SetLightClientMode makes node light client (does not forward any messages)

func (*Whisper) SetMaxMessageSize Uses

func (whisper *Whisper) SetMaxMessageSize(size uint32) error

SetMaxMessageSize sets the maximal message size allowed by this node

func (*Whisper) SetMinimumPoW Uses

func (whisper *Whisper) SetMinimumPoW(val float64) error

SetMinimumPoW sets the minimal PoW required by this node

func (*Whisper) SetMinimumPowTest Uses

func (whisper *Whisper) SetMinimumPowTest(val float64)

SetMinimumPowTest sets the minimal PoW in test environment

func (*Whisper) Start Uses

func (whisper *Whisper) Start(*p2p.Server) error

Start implements node.Service, starting the background data propagation thread of the Whisper protocol.

func (*Whisper) Stats Uses

func (whisper *Whisper) Stats() Statistics

Stats returns the whisper node statistics.

func (*Whisper) Stop Uses

func (whisper *Whisper) Stop() error

Stop implements node.Service, stopping the background data propagation thread of the Whisper protocol.

func (*Whisper) Subscribe Uses

func (whisper *Whisper) Subscribe(f *Filter) (string, error)

Subscribe installs a new message handler used for filtering, decrypting and subsequent storing of incoming messages.

func (*Whisper) Unsubscribe Uses

func (whisper *Whisper) Unsubscribe(id string) error

Unsubscribe removes an installed message handler.

func (*Whisper) Version Uses

func (whisper *Whisper) Version() uint

Version returns the whisper sub-protocols version number.

Package whisperv6 imports 31 packages (graph) and is imported by 116 packages. Updated 2020-05-03. Refresh now. Tools for package owners.