types

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 31, 2019 License: Apache-2.0 Imports: 20 Imported by: 1

Documentation

Overview

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright © 2019 Annchain Authors <EMAIL ADDRESS>

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

View Source 
const (
	BloomItemNumber = 3000
	HashFuncNum     = 8
)
View Source 
const (
	AddressLength = 20
)

Length of Addresses in bytes.

View Source 
const (
	HashLength = 32
)

Length of hash in bytes.

Variables

View Source 
var (
	ErrDuplicateTx = errors.New("Duplicate tx found in txlookup")

	ErrDuplicateNonce = errors.New("Duplicate tx nonce")

	ErrNonceNotExist = errors.New("Nonce not exist")
)

Functions

func ChannelHandler 

func ChannelHandler(timer *time.Timer, receiver chan interface{}, data interface{})

Types

type Address 

type Address struct {
	Bytes [AddressLength]byte `msgp:"bytes"`
}

Address represents the 20 byte of address.

func BigToAddress 

func BigToAddress(b *big.Int) Address

BigToAddress sets byte representation of b to Address. If b is larger than len(h), b will be cropped from the left.

func BytesToAddress 

func BytesToAddress(b []byte) Address

BytesToAddress sets b to hash. If b is larger than len(h), b will be cropped from the left.

func HexToAddress 

func HexToAddress(s string) Address

HexToAddress sets byte representation of s to Address. If b is larger than len(h), b will be cropped from the left.

func RandomAddress 

func RandomAddress() Address

func StringToAddress 

func StringToAddress(s string) (add Address, err error)

func (Address) Big 

func (h Address) Big() *big.Int

Big converts an Address to a big integer.

func (*Address) DecodeMsg 

func (z *Address) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Address) EncodeMsg 

func (z *Address) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Address) Format 

func (h Address) Format(s fmt.State, c rune)

Format implements fmt.Formatter, forcing the byte slice to be formatted as is, without going through the stringer interface used for logging.

func (Address) Generate 

func (h Address) Generate(rand *rand.Rand, size int) reflect.Value

Generate implements testing/quick.Generator.

func (Address) Hex 

func (h Address) Hex() string

Hex converts a Address to a hex string.

func (*Address) MarshalMsg 

func (z *Address) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Address) MarshalText 

func (h Address) MarshalText() ([]byte, error)

MarshalText returns the hex representation of h.

func (*Address) Msgsize 

func (z *Address) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Address) MustSetBytes 

func (h *Address) MustSetBytes(b []byte)

SetBytes sets the Address to the value of b. If b is larger than len(h), panic. It usually indicates a logic error.

func (*Address) SetBytes 

func (h *Address) SetBytes(b []byte) error

func (Address) ShortString 

func (h Address) ShortString() string

func (Address) String 

func (h Address) String() string

String implements the stringer interface and is used also by the logger when doing full logging into a file.

func (Address) TerminalString 

func (h Address) TerminalString() string

TerminalString implements log.TerminalStringer, formatting a string for console output during logging.

func (Address) ToBytes 

func (h Address) ToBytes() []byte

ToBytes convers Address to []byte.

func (*Address) UnmarshalJSON 

func (h *Address) UnmarshalJSON(input []byte) error

UnmarshalJSON parses an Address in hex syntax.

func (*Address) UnmarshalMsg 

func (z *Address) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

func (*Address) UnmarshalText 

func (h *Address) UnmarshalText(input []byte) error

UnmarshalText parses an Address in hex syntax.

type BasicMessage 

type BasicMessage struct {
	SourceId    uint16
	HeightRound HeightRound
	TermId      uint32
}

func (*BasicMessage) DecodeMsg 

func (z *BasicMessage) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*BasicMessage) EncodeMsg 

func (z *BasicMessage) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*BasicMessage) MarshalMsg 

func (z *BasicMessage) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*BasicMessage) Msgsize 

func (z *BasicMessage) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (BasicMessage) String 

func (m BasicMessage) String() string

func (*BasicMessage) UnmarshalMsg 

func (z *BasicMessage) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type BloomFilter 

type BloomFilter struct {
	Data  []byte
	Count uint32
	// contains filtered or unexported fields
}

func NewDefaultBloomFilter 

func NewDefaultBloomFilter() *BloomFilter

func (*BloomFilter) AddItem 

func (c *BloomFilter) AddItem(item []byte)

func (*BloomFilter) Decode 

func (c *BloomFilter) Decode() error

func (*BloomFilter) DecodeMsg 

func (z *BloomFilter) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*BloomFilter) Encode 

func (c *BloomFilter) Encode() error

func (*BloomFilter) EncodeMsg 

func (z *BloomFilter) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*BloomFilter) GetCount 

func (c *BloomFilter) GetCount() uint32

func (*BloomFilter) LookUpItem 

func (c *BloomFilter) LookUpItem(item []byte) (bool, error)

func (*BloomFilter) MarshalMsg 

func (z *BloomFilter) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*BloomFilter) Msgsize 

func (z *BloomFilter) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*BloomFilter) UnmarshalMsg 

func (z *BloomFilter) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type BlsSigSet 

type BlsSigSet struct {
	PublicKey    []byte
	BlsSignature []byte
}

func (*BlsSigSet) DecodeMsg 

func (z *BlsSigSet) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*BlsSigSet) EncodeMsg 

func (z *BlsSigSet) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*BlsSigSet) MarshalMsg 

func (z *BlsSigSet) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*BlsSigSet) Msgsize 

func (z *BlsSigSet) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*BlsSigSet) UnmarshalMsg 

func (z *BlsSigSet) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Campaign 

type Campaign struct {
	TxBase
	DkgPublicKey []byte
	Vrf          VrfInfo
	Issuer       Address
	// contains filtered or unexported fields
}

func (*Campaign) Compare 

func (c *Campaign) Compare(tx Txi) bool

func (*Campaign) DecodeMsg 

func (z *Campaign) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Campaign) Dump 

func (c *Campaign) Dump() string

func (*Campaign) EncodeMsg 

func (z *Campaign) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Campaign) GetBase 

func (c *Campaign) GetBase() *TxBase

func (*Campaign) GetDkgPublicKey 

func (c *Campaign) GetDkgPublicKey() kyber.Point

func (*Campaign) MarshalDkgKey 

func (c *Campaign) MarshalDkgKey() error

func (*Campaign) MarshalMsg 

func (z *Campaign) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Campaign) Msgsize 

func (z *Campaign) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Campaign) RawCampaign 

func (c *Campaign) RawCampaign() *RawCampaign

func (*Campaign) RawTxi 

func (c *Campaign) RawTxi() RawTxi

func (*Campaign) Sender 

func (c *Campaign) Sender() Address

func (*Campaign) SignatureTargets 

func (c *Campaign) SignatureTargets() []byte

func (*Campaign) String 

func (c *Campaign) String() string

func (*Campaign) UnmarshalDkgKey 

func (c *Campaign) UnmarshalDkgKey(unmarshalFunc func(b []byte) (kyber.Point, error)) error

func (*Campaign) UnmarshalMsg 

func (z *Campaign) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Campaigns 

type Campaigns []*Campaign

func (*Campaigns) DecodeMsg 

func (z *Campaigns) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Campaigns) EncodeMsg 

func (z Campaigns) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Campaigns) Len 

func (r *Campaigns) Len() int

func (Campaigns) MarshalMsg 

func (z Campaigns) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Campaigns) Msgsize 

func (z Campaigns) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (Campaigns) RawCampaigns 

func (cs Campaigns) RawCampaigns() RawCampaigns

func (Campaigns) String 

func (c Campaigns) String() string

func (*Campaigns) UnmarshalMsg 

func (z *Campaigns) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ConfirmTime 

type ConfirmTime struct {
	SeqHeight   uint64 `json:"seq_Height"`
	TxNum       uint64 `json:"tx_num"`
	ConfirmTime string `json:"confirm_time"`
}

func (*ConfirmTime) DecodeMsg 

func (z *ConfirmTime) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (ConfirmTime) EncodeMsg 

func (z ConfirmTime) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (ConfirmTime) MarshalMsg 

func (z ConfirmTime) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (ConfirmTime) Msgsize 

func (z ConfirmTime) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*ConfirmTime) UnmarshalMsg 

func (z *ConfirmTime) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Foo 

type Foo struct {
	Bar     string             `msg:"bar"`
	Baz     float64            `msg:"baz"`
	Address Address            `msg:"address"`
	Parents Hashes             `msg:"parents"`
	KV      map[string]float64 `msg:"kv"`
	Seq     Sequencer          `msg:"seq"`
	TxInner Tx                 `msg:"tx"`
}

func (*Foo) CalcHash 

func (f *Foo) CalcHash() (hash Hash, err error)

func (*Foo) DecodeMsg 

func (z *Foo) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Foo) EncodeMsg 

func (z *Foo) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Foo) MarshalMsg 

func (z *Foo) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Foo) Msgsize 

func (z *Foo) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Foo) UnmarshalMsg 

func (z *Foo) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Hash 

type Hash struct {
	Bytes [HashLength]byte `msgp:"bytes"`
}

Hash represents the 32 byte of Hash.

func BigToHash 

func BigToHash(b *big.Int) Hash

BigToHash sets byte representation of b to Hash. If b is larger than len(h), b will be cropped from the left.

func BytesToHash 

func BytesToHash(b []byte) Hash

BytesToHash sets b to hash. If b is larger than len(h), b will be cropped from the left.

func HexStringToHash 

func HexStringToHash(s string) (Hash, error)

func HexToHash 

func HexToHash(s string) Hash

HexToHash sets byte representation of s to Hash. If b is larger than len(h), b will be cropped from the left.

func RandomHash 

func RandomHash() Hash

func (Hash) Big 

func (h Hash) Big() *big.Int

Big converts an Hash to a big integer.

func (Hash) Cmp 

func (h Hash) Cmp(another Hash) int

Cmp compares two hashes. Returns 0 if two hashes are same. Returns -1 if the self hash is less than parameter hash. Returns 1 if the self hash is larger than parameter hash.

func (*Hash) DecodeMsg 

func (z *Hash) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Hash) Empty 

func (h *Hash) Empty() bool

func (*Hash) EncodeMsg 

func (z *Hash) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Hash) Generate 

func (h Hash) Generate(rand *rand.Rand, size int) reflect.Value

Generate implements testing/quick.Generator.

func (Hash) Hex 

func (h Hash) Hex() string

Hex converts a Hash to a hex string.

func (*Hash) MarshalMsg 

func (z *Hash) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Hash) MarshalText 

func (h Hash) MarshalText() ([]byte, error)

MarshalText returns the hex representation of h.

func (*Hash) Msgsize 

func (z *Hash) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Hash) MustSetBytes 

func (h *Hash) MustSetBytes(b []byte, padding Padding)

SetBytes sets the Hash to the value of b. If b is larger than len(h), panic. It usually indicates a logic error.

func (*Hash) SetBytes 

func (h *Hash) SetBytes(b []byte) error

func (Hash) String 

func (h Hash) String() string

String implements the stringer interface and is used also by the logger when doing full logging into a file.

func (Hash) TerminalString 

func (h Hash) TerminalString() string

TerminalString implements log.TerminalStringer, formatting a string for console output during logging.

func (Hash) ToBytes 

func (h Hash) ToBytes() []byte

ToBytes convers hash to []byte.

func (*Hash) UnmarshalJSON 

func (h *Hash) UnmarshalJSON(input []byte) error

UnmarshalJSON parses an Hash in hex syntax.

func (*Hash) UnmarshalMsg 

func (z *Hash) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

func (*Hash) UnmarshalText 

func (h *Hash) UnmarshalText(input []byte) error

UnmarshalText parses an Hash in hex syntax.

type HashBytes 

type HashBytes [HashLength]byte

func (*HashBytes) DecodeMsg 

func (z *HashBytes) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*HashBytes) EncodeMsg 

func (z *HashBytes) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*HashBytes) MarshalMsg 

func (z *HashBytes) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*HashBytes) Msgsize 

func (z *HashBytes) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*HashBytes) UnmarshalMsg 

func (z *HashBytes) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type HashOrNumber 

type HashOrNumber struct {
	Hash   *Hash   // Block hash from which to retrieve headers (excludes Number)
	Number *uint64 // Block hash from which to retrieve headers (excludes Hash)
}

hashOrNumber is a combined field for specifying an origin block.

func (*HashOrNumber) DecodeMsg 

func (z *HashOrNumber) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*HashOrNumber) EncodeMsg 

func (z *HashOrNumber) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*HashOrNumber) MarshalMsg 

func (z *HashOrNumber) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*HashOrNumber) Msgsize 

func (z *HashOrNumber) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*HashOrNumber) String 

func (m *HashOrNumber) String() string

func (*HashOrNumber) UnmarshalMsg 

func (z *HashOrNumber) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Hashes 

type Hashes []Hash

func (*Hashes) DecodeMsg 

func (z *Hashes) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Hashes) EncodeMsg 

func (z Hashes) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Hashes) Len 

func (a Hashes) Len() int

func (Hashes) Less 

func (a Hashes) Less(i, j int) bool

func (Hashes) MarshalMsg 

func (z Hashes) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Hashes) Msgsize 

func (z Hashes) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (Hashes) String 

func (h Hashes) String() string

func (Hashes) Swap 

func (a Hashes) Swap(i, j int)

func (*Hashes) UnmarshalMsg 

func (z *Hashes) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type HeightRound 

type HeightRound struct {
	Height uint64
	Round  int
}

HeightRound is the current progress of the consensus. Height is the block height, round is the sub-progress if no consensus can be easily reached

func (*HeightRound) DecodeMsg 

func (z *HeightRound) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (HeightRound) EncodeMsg 

func (z HeightRound) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*HeightRound) IsAfter 

func (h *HeightRound) IsAfter(o HeightRound) bool

IsAfter judges whether self is a higher HeightRound

func (*HeightRound) IsAfterOrEqual 

func (h *HeightRound) IsAfterOrEqual(o HeightRound) bool

IsAfterOrEqual judges whether self is a higher or equal HeightRound

func (*HeightRound) IsBefore 

func (h *HeightRound) IsBefore(o HeightRound) bool

IsAfterOrEqual judges whether self is a lower HeightRound

func (HeightRound) MarshalMsg 

func (z HeightRound) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (HeightRound) Msgsize 

func (z HeightRound) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*HeightRound) String 

func (h *HeightRound) String() string

func (*HeightRound) UnmarshalMsg 

func (z *HeightRound) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type ISigner 

type ISigner interface {
	AddressFromPubKeyBytes(pubKey []byte) Address
}
var Signer ISigner

type Message 

type Message interface {
	msg.Message
	String() string //string is for logging
}

type MessageBodiesRequest 

type MessageBodiesRequest struct {
	SeqHashes Hashes
	RequestId uint32 //avoid msg drop
}

func (*MessageBodiesRequest) DecodeMsg 

func (z *MessageBodiesRequest) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageBodiesRequest) EncodeMsg 

func (z *MessageBodiesRequest) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageBodiesRequest) MarshalMsg 

func (z *MessageBodiesRequest) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageBodiesRequest) Msgsize 

func (z *MessageBodiesRequest) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageBodiesRequest) String 

func (m *MessageBodiesRequest) String() string

func (*MessageBodiesRequest) UnmarshalMsg 

func (z *MessageBodiesRequest) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageBodiesResponse 

type MessageBodiesResponse struct {
	Bodies      []RawData
	RequestedId uint32 //avoid msg drop
}

func (*MessageBodiesResponse) DecodeMsg 

func (z *MessageBodiesResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageBodiesResponse) EncodeMsg 

func (z *MessageBodiesResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageBodiesResponse) MarshalMsg 

func (z *MessageBodiesResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageBodiesResponse) Msgsize 

func (z *MessageBodiesResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageBodiesResponse) String 

func (m *MessageBodiesResponse) String() string

func (*MessageBodiesResponse) UnmarshalMsg 

func (z *MessageBodiesResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageBodyData 

type MessageBodyData struct {
	//RawTxs         *RawTxs
	//RawTermChanges *RawTermChanges
	//RawCampaigns   *RawCampaigns
	RawSequencer *RawSequencer
	RawTxs       *TxisMarshaler
}

func (*MessageBodyData) DecodeMsg 

func (z *MessageBodyData) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageBodyData) EncodeMsg 

func (z *MessageBodyData) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageBodyData) MarshalMsg 

func (z *MessageBodyData) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageBodyData) Msgsize 

func (z *MessageBodyData) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageBodyData) String 

func (m *MessageBodyData) String() string

func (*MessageBodyData) ToTxis 

func (m *MessageBodyData) ToTxis() Txis

func (*MessageBodyData) UnmarshalMsg 

func (z *MessageBodyData) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageCampaign 

type MessageCampaign struct {
	RawCampaign *RawCampaign
}

func (*MessageCampaign) DecodeMsg 

func (z *MessageCampaign) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageCampaign) EncodeMsg 

func (z *MessageCampaign) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageCampaign) MarshalMsg 

func (z *MessageCampaign) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageCampaign) Msgsize 

func (z *MessageCampaign) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageCampaign) String 

func (m *MessageCampaign) String() string

func (*MessageCampaign) UnmarshalMsg 

func (z *MessageCampaign) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageConsensusDkgDeal 

type MessageConsensusDkgDeal struct {
	Id        uint32
	Data      []byte
	PublicKey []byte
	Signature []byte
	TermId    uint64
}

func (*MessageConsensusDkgDeal) DecodeMsg 

func (z *MessageConsensusDkgDeal) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageConsensusDkgDeal) EncodeMsg 

func (z *MessageConsensusDkgDeal) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageConsensusDkgDeal) MarshalMsg 

func (z *MessageConsensusDkgDeal) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageConsensusDkgDeal) Msgsize 

func (z *MessageConsensusDkgDeal) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageConsensusDkgDeal) SignatureTargets 

func (m *MessageConsensusDkgDeal) SignatureTargets() []byte

func (MessageConsensusDkgDeal) String 

func (m MessageConsensusDkgDeal) String() string

func (*MessageConsensusDkgDeal) UnmarshalMsg 

func (z *MessageConsensusDkgDeal) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageConsensusDkgDealResponse 

type MessageConsensusDkgDealResponse struct {
	Id        uint32
	Data      []byte
	PublicKey []byte
	Signature []byte
	TermId    uint64
}

func (*MessageConsensusDkgDealResponse) DecodeMsg 

func (z *MessageConsensusDkgDealResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageConsensusDkgDealResponse) EncodeMsg 

func (z *MessageConsensusDkgDealResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageConsensusDkgDealResponse) MarshalMsg 

func (z *MessageConsensusDkgDealResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageConsensusDkgDealResponse) Msgsize 

func (z *MessageConsensusDkgDealResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageConsensusDkgDealResponse) SignatureTargets 

func (m *MessageConsensusDkgDealResponse) SignatureTargets() []byte

func (MessageConsensusDkgDealResponse) String 

func (m MessageConsensusDkgDealResponse) String() string

func (*MessageConsensusDkgDealResponse) UnmarshalMsg 

func (z *MessageConsensusDkgDealResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageConsensusDkgGenesisPublicKey 

type MessageConsensusDkgGenesisPublicKey struct {
	DkgPublicKey []byte
	PublicKey    []byte
	Signature    []byte
	TermId       uint64
}

msgp:MessageConsensusDkgGenesisPublicKey

func (*MessageConsensusDkgGenesisPublicKey) DecodeMsg 

func (z *MessageConsensusDkgGenesisPublicKey) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageConsensusDkgGenesisPublicKey) EncodeMsg 

func (z *MessageConsensusDkgGenesisPublicKey) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageConsensusDkgGenesisPublicKey) MarshalMsg 

func (z *MessageConsensusDkgGenesisPublicKey) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageConsensusDkgGenesisPublicKey) Msgsize 

func (z *MessageConsensusDkgGenesisPublicKey) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageConsensusDkgGenesisPublicKey) SignatureTargets 

func (m *MessageConsensusDkgGenesisPublicKey) SignatureTargets() []byte

func (*MessageConsensusDkgGenesisPublicKey) String 

func (m *MessageConsensusDkgGenesisPublicKey) String() string

func (*MessageConsensusDkgGenesisPublicKey) UnmarshalMsg 

func (z *MessageConsensusDkgGenesisPublicKey) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageConsensusDkgSigSets 

type MessageConsensusDkgSigSets struct {
	PkBls     []byte
	PublicKey []byte
	Signature []byte
	TermId    uint64
}

func (*MessageConsensusDkgSigSets) DecodeMsg 

func (z *MessageConsensusDkgSigSets) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageConsensusDkgSigSets) EncodeMsg 

func (z *MessageConsensusDkgSigSets) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageConsensusDkgSigSets) MarshalMsg 

func (z *MessageConsensusDkgSigSets) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageConsensusDkgSigSets) Msgsize 

func (z *MessageConsensusDkgSigSets) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageConsensusDkgSigSets) SignatureTargets 

func (m *MessageConsensusDkgSigSets) SignatureTargets() []byte

func (*MessageConsensusDkgSigSets) String 

func (m *MessageConsensusDkgSigSets) String() string

func (*MessageConsensusDkgSigSets) UnmarshalMsg 

func (z *MessageConsensusDkgSigSets) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageControl 

type MessageControl struct {
	Hash *Hash
}

func (*MessageControl) DecodeMsg 

func (z *MessageControl) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageControl) EncodeMsg 

func (z *MessageControl) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageControl) MarshalMsg 

func (z *MessageControl) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageControl) Msgsize 

func (z *MessageControl) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageControl) String 

func (m *MessageControl) String() string

func (*MessageControl) UnmarshalMsg 

func (z *MessageControl) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageDuplicate 

type MessageDuplicate bool

func (*MessageDuplicate) DecodeMsg 

func (z *MessageDuplicate) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (MessageDuplicate) EncodeMsg 

func (z MessageDuplicate) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (MessageDuplicate) MarshalMsg 

func (z MessageDuplicate) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (MessageDuplicate) Msgsize 

func (z MessageDuplicate) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageDuplicate) String 

func (m *MessageDuplicate) String() string

func (*MessageDuplicate) UnmarshalMsg 

func (z *MessageDuplicate) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageGetMsg 

type MessageGetMsg struct {
	Hash *Hash
}

func (*MessageGetMsg) DecodeMsg 

func (z *MessageGetMsg) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageGetMsg) EncodeMsg 

func (z *MessageGetMsg) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageGetMsg) MarshalMsg 

func (z *MessageGetMsg) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageGetMsg) Msgsize 

func (z *MessageGetMsg) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageGetMsg) String 

func (m *MessageGetMsg) String() string

func (*MessageGetMsg) UnmarshalMsg 

func (z *MessageGetMsg) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageHeaderRequest 

type MessageHeaderRequest struct {
	Origin    HashOrNumber // Block from which to retrieve headers
	Amount    uint64       // Maximum number of headers to retrieve
	Skip      uint64       // Blocks to skip between consecutive headers
	Reverse   bool         // Query direction (false = rising towards latest, true = falling towards genesis)
	RequestId uint32       //avoid msg drop
}

getBlockHeadersData represents a block header query.

func (*MessageHeaderRequest) DecodeMsg 

func (z *MessageHeaderRequest) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageHeaderRequest) EncodeMsg 

func (z *MessageHeaderRequest) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageHeaderRequest) MarshalMsg 

func (z *MessageHeaderRequest) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageHeaderRequest) Msgsize 

func (z *MessageHeaderRequest) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageHeaderRequest) String 

func (m *MessageHeaderRequest) String() string

func (*MessageHeaderRequest) UnmarshalMsg 

func (z *MessageHeaderRequest) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageHeaderResponse 

type MessageHeaderResponse struct {
	Headers     *SequencerHeaders
	RequestedId uint32 //avoid msg drop
}

func (*MessageHeaderResponse) DecodeMsg 

func (z *MessageHeaderResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageHeaderResponse) EncodeMsg 

func (z *MessageHeaderResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageHeaderResponse) MarshalMsg 

func (z *MessageHeaderResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageHeaderResponse) Msgsize 

func (z *MessageHeaderResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageHeaderResponse) String 

func (m *MessageHeaderResponse) String() string

func (*MessageHeaderResponse) UnmarshalMsg 

func (z *MessageHeaderResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageNewSequencer 

type MessageNewSequencer struct {
	RawSequencer *RawSequencer
}

func (*MessageNewSequencer) DecodeMsg 

func (z *MessageNewSequencer) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageNewSequencer) EncodeMsg 

func (z *MessageNewSequencer) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageNewSequencer) GetHash 

func (m *MessageNewSequencer) GetHash() *Hash

func (*MessageNewSequencer) MarshalMsg 

func (z *MessageNewSequencer) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageNewSequencer) Msgsize 

func (z *MessageNewSequencer) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageNewSequencer) String 

func (m *MessageNewSequencer) String() string

func (*MessageNewSequencer) UnmarshalMsg 

func (z *MessageNewSequencer) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageNewTx 

type MessageNewTx struct {
	RawTx *RawTx
}

func (*MessageNewTx) DecodeMsg 

func (z *MessageNewTx) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageNewTx) EncodeMsg 

func (z *MessageNewTx) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageNewTx) GetHash 

func (m *MessageNewTx) GetHash() *Hash

func (*MessageNewTx) MarshalMsg 

func (z *MessageNewTx) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageNewTx) Msgsize 

func (z *MessageNewTx) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageNewTx) String 

func (m *MessageNewTx) String() string

func (*MessageNewTx) UnmarshalMsg 

func (z *MessageNewTx) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageNewTxs 

type MessageNewTxs struct {
	RawTxs *RawTxs
}

func (*MessageNewTxs) DecodeMsg 

func (z *MessageNewTxs) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageNewTxs) EncodeMsg 

func (z *MessageNewTxs) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageNewTxs) Hashes 

func (m *MessageNewTxs) Hashes() Hashes

func (*MessageNewTxs) MarshalMsg 

func (z *MessageNewTxs) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageNewTxs) Msgsize 

func (z *MessageNewTxs) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageNewTxs) String 

func (m *MessageNewTxs) String() string

func (*MessageNewTxs) Txis 

func (m *MessageNewTxs) Txis() Txis

func (*MessageNewTxs) UnmarshalMsg 

func (z *MessageNewTxs) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessagePing 

type MessagePing struct {
	Data []byte
}

func (*MessagePing) DecodeMsg 

func (z *MessagePing) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessagePing) EncodeMsg 

func (z *MessagePing) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessagePing) MarshalMsg 

func (z *MessagePing) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessagePing) Msgsize 

func (z *MessagePing) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessagePing) String 

func (m *MessagePing) String() string

func (*MessagePing) UnmarshalMsg 

func (z *MessagePing) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessagePong 

type MessagePong struct {
	Data []byte
}

func (*MessagePong) DecodeMsg 

func (z *MessagePong) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessagePong) EncodeMsg 

func (z *MessagePong) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessagePong) MarshalMsg 

func (z *MessagePong) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessagePong) Msgsize 

func (z *MessagePong) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessagePong) String 

func (m *MessagePong) String() string

func (*MessagePong) UnmarshalMsg 

func (z *MessagePong) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessagePreCommit 

type MessagePreCommit struct {
	BasicMessage
	Idv          *Hash // ID of the proposal, usually be the hash of the proposal
	BlsSignature []byte
	Signature    []byte
	PublicKey    []byte
}

func (*MessagePreCommit) BlsSignatureTargets 

func (m *MessagePreCommit) BlsSignatureTargets() []byte

func (*MessagePreCommit) DecodeMsg 

func (z *MessagePreCommit) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessagePreCommit) EncodeMsg 

func (z *MessagePreCommit) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessagePreCommit) MarshalMsg 

func (z *MessagePreCommit) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessagePreCommit) Msgsize 

func (z *MessagePreCommit) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessagePreCommit) SignatureTargets 

func (m *MessagePreCommit) SignatureTargets() []byte

func (MessagePreCommit) String 

func (m MessagePreCommit) String() string

func (*MessagePreCommit) UnmarshalMsg 

func (z *MessagePreCommit) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessagePreVote 

type MessagePreVote struct {
	BasicMessage
	Idv       *Hash // ID of the proposal, usually be the hash of the proposal
	Signature []byte
	PublicKey []byte
}

func (*MessagePreVote) DecodeMsg 

func (z *MessagePreVote) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessagePreVote) EncodeMsg 

func (z *MessagePreVote) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessagePreVote) MarshalMsg 

func (z *MessagePreVote) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessagePreVote) Msgsize 

func (z *MessagePreVote) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessagePreVote) SignatureTargets 

func (m *MessagePreVote) SignatureTargets() []byte

func (MessagePreVote) String 

func (m MessagePreVote) String() string

func (*MessagePreVote) UnmarshalMsg 

func (z *MessagePreVote) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageProposal 

type MessageProposal struct {
	BasicMessage
	Value      Proposal //TODO
	ValidRound int
	//PublicKey  []byte
	Signature []byte
}

func (MessageProposal) Copy 

func (m MessageProposal) Copy() *MessageProposal

func (*MessageProposal) DecodeMsg 

func (z *MessageProposal) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageProposal) EncodeMsg 

func (z *MessageProposal) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageProposal) MarshalMsg 

func (z *MessageProposal) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageProposal) Msgsize 

func (z *MessageProposal) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageProposal) SignatureTargets 

func (m *MessageProposal) SignatureTargets() []byte

func (MessageProposal) String 

func (m MessageProposal) String() string

func (*MessageProposal) UnmarshalMsg 

func (z *MessageProposal) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageSequencerHeader 

type MessageSequencerHeader struct {
	Hash   *Hash
	Number *uint64
}

func (*MessageSequencerHeader) DecodeMsg 

func (z *MessageSequencerHeader) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageSequencerHeader) EncodeMsg 

func (z *MessageSequencerHeader) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageSequencerHeader) MarshalMsg 

func (z *MessageSequencerHeader) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageSequencerHeader) Msgsize 

func (z *MessageSequencerHeader) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageSequencerHeader) String 

func (m *MessageSequencerHeader) String() string

func (*MessageSequencerHeader) UnmarshalMsg 

func (z *MessageSequencerHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageSyncRequest 

type MessageSyncRequest struct {
	Hashes    *Hashes
	Filter    *BloomFilter
	Height    *uint64
	RequestId uint32 //avoid msg drop
}

func (*MessageSyncRequest) DecodeMsg 

func (z *MessageSyncRequest) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageSyncRequest) EncodeMsg 

func (z *MessageSyncRequest) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageSyncRequest) MarshalMsg 

func (z *MessageSyncRequest) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageSyncRequest) Msgsize 

func (z *MessageSyncRequest) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageSyncRequest) String 

func (m *MessageSyncRequest) String() string

func (*MessageSyncRequest) UnmarshalMsg 

func (z *MessageSyncRequest) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageSyncResponse 

type MessageSyncResponse struct {
	//RawTxs *RawTxs
	////SequencerIndex  []uint32
	//RawSequencers  *RawSequencers
	//RawCampaigns   *RawCampaigns
	//RawTermChanges *RawTermChanges
	RawTxs      *TxisMarshaler
	RequestedId uint32 //avoid msg drop
}

func (*MessageSyncResponse) DecodeMsg 

func (z *MessageSyncResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageSyncResponse) EncodeMsg 

func (z *MessageSyncResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageSyncResponse) Hashes 

func (m *MessageSyncResponse) Hashes() Hashes

func (*MessageSyncResponse) MarshalMsg 

func (z *MessageSyncResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageSyncResponse) Msgsize 

func (z *MessageSyncResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageSyncResponse) String 

func (m *MessageSyncResponse) String() string

func (*MessageSyncResponse) Txis 

func (m *MessageSyncResponse) Txis() Txis

func (*MessageSyncResponse) UnmarshalMsg 

func (z *MessageSyncResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageTermChange 

type MessageTermChange struct {
	RawTermChange *RawTermChange
}

func (*MessageTermChange) DecodeMsg 

func (z *MessageTermChange) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageTermChange) EncodeMsg 

func (z *MessageTermChange) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageTermChange) MarshalMsg 

func (z *MessageTermChange) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageTermChange) Msgsize 

func (z *MessageTermChange) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageTermChange) String 

func (m *MessageTermChange) String() string

func (*MessageTermChange) UnmarshalMsg 

func (z *MessageTermChange) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageTermChangeRequest 

type MessageTermChangeRequest struct {
	Id uint32
}

func (*MessageTermChangeRequest) DecodeMsg 

func (z *MessageTermChangeRequest) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (MessageTermChangeRequest) EncodeMsg 

func (z MessageTermChangeRequest) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (MessageTermChangeRequest) MarshalMsg 

func (z MessageTermChangeRequest) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (MessageTermChangeRequest) Msgsize 

func (z MessageTermChangeRequest) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (MessageTermChangeRequest) String 

func (m MessageTermChangeRequest) String() string

func (*MessageTermChangeRequest) UnmarshalMsg 

func (z *MessageTermChangeRequest) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageTermChangeResponse 

type MessageTermChangeResponse struct {
	TermChange *TermChange
	Id         uint32
}

func (*MessageTermChangeResponse) DecodeMsg 

func (z *MessageTermChangeResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageTermChangeResponse) EncodeMsg 

func (z *MessageTermChangeResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageTermChangeResponse) MarshalMsg 

func (z *MessageTermChangeResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageTermChangeResponse) Msgsize 

func (z *MessageTermChangeResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (MessageTermChangeResponse) String 

func (m MessageTermChangeResponse) String() string

func (*MessageTermChangeResponse) UnmarshalMsg 

func (z *MessageTermChangeResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageTxsRequest 

type MessageTxsRequest struct {
	Hashes    *Hashes
	SeqHash   *Hash
	Id        *uint64
	RequestId uint32 //avoid msg drop
}

func (*MessageTxsRequest) DecodeMsg 

func (z *MessageTxsRequest) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageTxsRequest) EncodeMsg 

func (z *MessageTxsRequest) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageTxsRequest) MarshalMsg 

func (z *MessageTxsRequest) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageTxsRequest) Msgsize 

func (z *MessageTxsRequest) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageTxsRequest) String 

func (m *MessageTxsRequest) String() string

func (*MessageTxsRequest) UnmarshalMsg 

func (z *MessageTxsRequest) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type MessageTxsResponse 

type MessageTxsResponse struct {
	//RawTxs         *RawTxs
	RawSequencer *RawSequencer
	//RawCampaigns   *RawCampaigns
	//RawTermChanges *RawTermChanges
	RawTxs      *TxisMarshaler
	RequestedId uint32 //avoid msg drop
}

func (*MessageTxsResponse) DecodeMsg 

func (z *MessageTxsResponse) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*MessageTxsResponse) EncodeMsg 

func (z *MessageTxsResponse) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*MessageTxsResponse) Hashes 

func (m *MessageTxsResponse) Hashes() Hashes

func (*MessageTxsResponse) MarshalMsg 

func (z *MessageTxsResponse) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*MessageTxsResponse) Msgsize 

func (z *MessageTxsResponse) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*MessageTxsResponse) String 

func (m *MessageTxsResponse) String() string

func (*MessageTxsResponse) UnmarshalMsg 

func (z *MessageTxsResponse) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Padding 

type Padding uint
const (
	PaddingLeft Padding = iota
	PaddingRight
	PaddingNone
)

func (*Padding) DecodeMsg 

func (z *Padding) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Padding) EncodeMsg 

func (z Padding) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Padding) MarshalMsg 

func (z Padding) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Padding) Msgsize 

func (z Padding) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Padding) UnmarshalMsg 

func (z *Padding) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Proposal 

type Proposal interface {
	Equal(Proposal) bool
	GetId() *Hash
	msg.Message
	String() string
	Copy() Proposal
}

type RawCampaign 

type RawCampaign struct {
	TxBase
	DkgPublicKey []byte
	Vrf          VrfInfo
}

func (*RawCampaign) Campaign 

func (rc *RawCampaign) Campaign() *Campaign

func (*RawCampaign) DecodeMsg 

func (z *RawCampaign) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*RawCampaign) EncodeMsg 

func (z *RawCampaign) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawCampaign) MarshalMsg 

func (z *RawCampaign) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*RawCampaign) Msgsize 

func (z *RawCampaign) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawCampaign) String 

func (t *RawCampaign) String() string

func (*RawCampaign) Txi 

func (t *RawCampaign) Txi() Txi

func (*RawCampaign) UnmarshalMsg 

func (z *RawCampaign) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawCampaigns 

type RawCampaigns []*RawCampaign

func (RawCampaigns) Campaigns 

func (r RawCampaigns) Campaigns() Campaigns

func (*RawCampaigns) DecodeMsg 

func (z *RawCampaigns) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawCampaigns) EncodeMsg 

func (z RawCampaigns) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawCampaigns) Len 

func (r *RawCampaigns) Len() int

func (RawCampaigns) MarshalMsg 

func (z RawCampaigns) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawCampaigns) Msgsize 

func (z RawCampaigns) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (RawCampaigns) String 

func (r RawCampaigns) String() string

func (RawCampaigns) Txis 

func (r RawCampaigns) Txis() Txis

func (*RawCampaigns) UnmarshalMsg 

func (z *RawCampaigns) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawData 

type RawData []byte

func (*RawData) DecodeMsg 

func (z *RawData) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawData) EncodeMsg 

func (z RawData) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (RawData) MarshalMsg 

func (z RawData) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawData) Msgsize 

func (z RawData) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawData) UnmarshalMsg 

func (z *RawData) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawSequencer 

type RawSequencer struct {
	TxBase
	BlsJointSig    []byte
	BlsJointPubKey []byte
}

func (*RawSequencer) DecodeMsg 

func (z *RawSequencer) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*RawSequencer) EncodeMsg 

func (z *RawSequencer) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawSequencer) MarshalMsg 

func (z *RawSequencer) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*RawSequencer) Msgsize 

func (z *RawSequencer) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawSequencer) Sequencer 

func (t *RawSequencer) Sequencer() *Sequencer

func (*RawSequencer) String 

func (t *RawSequencer) String() string

func (*RawSequencer) Txi 

func (t *RawSequencer) Txi() Txi

func (*RawSequencer) UnmarshalMsg 

func (z *RawSequencer) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawSequencers 

type RawSequencers []*RawSequencer

func (*RawSequencers) DecodeMsg 

func (z *RawSequencers) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawSequencers) EncodeMsg 

func (z RawSequencers) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawSequencers) Len 

func (r *RawSequencers) Len() int

func (RawSequencers) MarshalMsg 

func (z RawSequencers) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawSequencers) Msgsize 

func (z RawSequencers) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (RawSequencers) Sequencers 

func (r RawSequencers) Sequencers() Sequencers

func (RawSequencers) String 

func (r RawSequencers) String() string

func (RawSequencers) ToHeaders 

func (seqs RawSequencers) ToHeaders() SequencerHeaders

func (RawSequencers) Txis 

func (r RawSequencers) Txis() Txis

func (*RawSequencers) UnmarshalMsg 

func (z *RawSequencers) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawTermChange 

type RawTermChange struct {
	TxBase
	TermId uint64
	PkBls  []byte
	SigSet []*SigSet
}

func (*RawTermChange) DecodeMsg 

func (z *RawTermChange) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*RawTermChange) EncodeMsg 

func (z *RawTermChange) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawTermChange) MarshalMsg 

func (z *RawTermChange) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*RawTermChange) Msgsize 

func (z *RawTermChange) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawTermChange) String 

func (t *RawTermChange) String() string

func (*RawTermChange) TermChange 

func (r *RawTermChange) TermChange() *TermChange

func (*RawTermChange) Txi 

func (t *RawTermChange) Txi() Txi

func (*RawTermChange) UnmarshalMsg 

func (z *RawTermChange) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawTermChanges 

type RawTermChanges []*RawTermChange

func (*RawTermChanges) DecodeMsg 

func (z *RawTermChanges) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawTermChanges) EncodeMsg 

func (z RawTermChanges) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawTermChanges) Len 

func (r *RawTermChanges) Len() int

func (RawTermChanges) MarshalMsg 

func (z RawTermChanges) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawTermChanges) Msgsize 

func (z RawTermChanges) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (RawTermChanges) String 

func (r RawTermChanges) String() string

func (RawTermChanges) TermChanges 

func (r RawTermChanges) TermChanges() TermChanges

func (RawTermChanges) Txis 

func (r RawTermChanges) Txis() Txis

func (*RawTermChanges) UnmarshalMsg 

func (z *RawTermChanges) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawTx 

type RawTx struct {
	TxBase
	To    Address
	Value *math.BigInt
	Data  []byte
}

compress data ,for p2p , small size

func (*RawTx) DecodeMsg 

func (z *RawTx) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*RawTx) EncodeMsg 

func (z *RawTx) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawTx) MarshalMsg 

func (z *RawTx) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*RawTx) Msgsize 

func (z *RawTx) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawTx) String 

func (t *RawTx) String() string

func (*RawTx) Tx 

func (t *RawTx) Tx() *Tx

func (*RawTx) Txi 

func (t *RawTx) Txi() Txi

func (*RawTx) UnmarshalMsg 

func (z *RawTx) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawTxMarshaler 

type RawTxMarshaler struct {
	RawTxi `msg:"-"`
}

TxMarshaler just for marshaller , put type to front 2 bytes, and marshal

func (*RawTxMarshaler) DecodeMsg 

func (t *RawTxMarshaler) DecodeMsg(dc *msgp.Reader) (err error)

func (*RawTxMarshaler) EncodeMsg 

func (t *RawTxMarshaler) EncodeMsg(en *msgp.Writer) (err error)

func (*RawTxMarshaler) MarshalMsg 

func (t *RawTxMarshaler) MarshalMsg(b []byte) (o []byte, err error)

func (*RawTxMarshaler) Msgsize 

func (t *RawTxMarshaler) Msgsize() (s int)

func (*RawTxMarshaler) Txi 

func (t *RawTxMarshaler) Txi() Txi

func (*RawTxMarshaler) UnmarshalMsg 

func (t *RawTxMarshaler) UnmarshalMsg(bts []byte) (o []byte, err error)

type RawTxi 

type RawTxi interface {
	GetType() TxBaseType
	GetHeight() uint64
	GetWeight() uint64
	GetTxHash() Hash
	GetNonce() uint64
	Parents() Hashes // Parents returns the hash of txs that it directly proves.
	SetHash(h Hash)
	String() string
	CalcTxHash() Hash    // TxHash returns a full tx hash (parents sealed by PoW stage 2)
	CalcMinedHash() Hash // NonceHash returns the part that needs to be considered in PoW stage 1.
	CalculateWeight(parents Txis) uint64

	Txi() Txi

	// implemented by msgp
	DecodeMsg(dc *msgp.Reader) (err error)
	EncodeMsg(en *msgp.Writer) (err error)
	MarshalMsg(b []byte) (o []byte, err error)
	UnmarshalMsg(bts []byte) (o []byte, err error)
	Msgsize() (s int)
}

type RawTxis 

type RawTxis []RawTxi

func (*RawTxis) DecodeMsg 

func (z *RawTxis) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawTxis) EncodeMsg 

func (z RawTxis) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (RawTxis) MarshalMsg 

func (z RawTxis) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawTxis) Msgsize 

func (z RawTxis) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*RawTxis) UnmarshalMsg 

func (z *RawTxis) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type RawTxs 

type RawTxs []*RawTx

func (*RawTxs) DecodeMsg 

func (z *RawTxs) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (RawTxs) EncodeMsg 

func (z RawTxs) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*RawTxs) Len 

func (r *RawTxs) Len() int

func (RawTxs) MarshalMsg 

func (z RawTxs) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (RawTxs) Msgsize 

func (z RawTxs) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (RawTxs) String 

func (r RawTxs) String() string

func (RawTxs) Txis 

func (r RawTxs) Txis() Txis

func (RawTxs) Txs 

func (r RawTxs) Txs() Txs

func (*RawTxs) UnmarshalMsg 

func (z *RawTxs) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Sequencer 

type Sequencer struct {
	// TODO: need more states in sequencer to differentiate multiple chains
	TxBase
	Issuer         Address
	BlsJointSig    []byte
	BlsJointPubKey []byte
	Proposing      bool `msg:"-"` // is the sequencer is proposal ,did't commit yet ,use this flag to avoid bls sig verification failed
}

func RandomSequencer 

func RandomSequencer() *Sequencer

func SampleSequencer 

func SampleSequencer() *Sequencer

func (*Sequencer) Compare 

func (t *Sequencer) Compare(tx Txi) bool

func (*Sequencer) DecodeMsg 

func (z *Sequencer) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Sequencer) Dump 

func (t *Sequencer) Dump() string

func (*Sequencer) EncodeMsg 

func (z *Sequencer) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Sequencer) GetBase 

func (t *Sequencer) GetBase() *TxBase

func (*Sequencer) GetHead 

func (t *Sequencer) GetHead() *SequencerHeader

func (*Sequencer) MarshalMsg 

func (z *Sequencer) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Sequencer) Msgsize 

func (z *Sequencer) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Sequencer) Number 

func (t *Sequencer) Number() uint64

func (*Sequencer) Parents 

func (t *Sequencer) Parents() Hashes

func (*Sequencer) RawSequencer 

func (s *Sequencer) RawSequencer() *RawSequencer

func (*Sequencer) RawTxi 

func (c *Sequencer) RawTxi() RawTxi

func (*Sequencer) Sender 

func (t *Sequencer) Sender() Address

func (*Sequencer) SignatureTargets 

func (t *Sequencer) SignatureTargets() []byte

func (*Sequencer) String 

func (t *Sequencer) String() string

func (*Sequencer) UnmarshalMsg 

func (z *Sequencer) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SequencerHeader 

type SequencerHeader struct {
	Hash   Hash
	Height uint64
}

func NewSequencerHead 

func NewSequencerHead(hash Hash, height uint64) *SequencerHeader

func (*SequencerHeader) DecodeMsg 

func (z *SequencerHeader) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SequencerHeader) EncodeMsg 

func (z *SequencerHeader) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*SequencerHeader) Equal 

func (s *SequencerHeader) Equal(h *SequencerHeader) bool

func (*SequencerHeader) GetHash 

func (s *SequencerHeader) GetHash() Hash

func (*SequencerHeader) GetHeight 

func (s *SequencerHeader) GetHeight() uint64

func (*SequencerHeader) MarshalMsg 

func (z *SequencerHeader) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SequencerHeader) Msgsize 

func (z *SequencerHeader) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SequencerHeader) SequencerId 

func (s *SequencerHeader) SequencerId() uint64

func (*SequencerHeader) String 

func (s *SequencerHeader) String() string

func (*SequencerHeader) StringFull 

func (s *SequencerHeader) StringFull() string

func (*SequencerHeader) UnmarshalMsg 

func (z *SequencerHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SequencerHeaders 

type SequencerHeaders []*SequencerHeader

func (*SequencerHeaders) DecodeMsg 

func (z *SequencerHeaders) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (SequencerHeaders) EncodeMsg 

func (z SequencerHeaders) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SequencerHeaders) MarshalMsg 

func (z SequencerHeaders) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (SequencerHeaders) Msgsize 

func (z SequencerHeaders) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (SequencerHeaders) String 

func (h SequencerHeaders) String() string

func (*SequencerHeaders) UnmarshalMsg 

func (z *SequencerHeaders) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SequencerProposal 

type SequencerProposal struct {
	Sequencer
}

func (SequencerProposal) Copy 

func (s SequencerProposal) Copy() Proposal

func (*SequencerProposal) DecodeMsg 

func (z *SequencerProposal) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SequencerProposal) EncodeMsg 

func (z *SequencerProposal) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (SequencerProposal) Equal 

func (s SequencerProposal) Equal(o Proposal) bool

func (SequencerProposal) GetId 

func (s SequencerProposal) GetId() *Hash

func (*SequencerProposal) MarshalMsg 

func (z *SequencerProposal) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SequencerProposal) Msgsize 

func (z *SequencerProposal) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SequencerProposal) String 

func (s *SequencerProposal) String() string

func (*SequencerProposal) UnmarshalMsg 

func (z *SequencerProposal) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Sequencers 

type Sequencers []*Sequencer

func (*Sequencers) DecodeMsg 

func (z *Sequencers) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Sequencers) EncodeMsg 

func (z Sequencers) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Sequencers) Len 

func (r *Sequencers) Len() int

func (Sequencers) MarshalMsg 

func (z Sequencers) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Sequencers) Msgsize 

func (z Sequencers) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (Sequencers) String 

func (s Sequencers) String() string

func (Sequencers) ToHeaders 

func (s Sequencers) ToHeaders() SequencerHeaders

func (Sequencers) ToRawSequencers 

func (seqs Sequencers) ToRawSequencers() RawSequencers

func (*Sequencers) UnmarshalMsg 

func (z *Sequencers) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type SigSet 

type SigSet struct {
	PublicKey []byte
	Signature []byte
}

func (*SigSet) DecodeMsg 

func (z *SigSet) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*SigSet) EncodeMsg 

func (z *SigSet) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*SigSet) MarshalMsg 

func (z *SigSet) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*SigSet) Msgsize 

func (z *SigSet) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*SigSet) UnmarshalMsg 

func (z *SigSet) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type StringProposal 

type StringProposal string

StringProposal is for test

func (StringProposal) Copy 

func (s StringProposal) Copy() Proposal

func (*StringProposal) DecodeMsg 

func (z *StringProposal) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (StringProposal) EncodeMsg 

func (z StringProposal) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (StringProposal) Equal 

func (s StringProposal) Equal(o Proposal) bool

func (StringProposal) GetId 

func (s StringProposal) GetId() *Hash

func (StringProposal) MarshalMsg 

func (z StringProposal) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (StringProposal) Msgsize 

func (z StringProposal) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (StringProposal) String 

func (s StringProposal) String() string

func (*StringProposal) UnmarshalMsg 

func (z *StringProposal) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type TermChange 

type TermChange struct {
	TxBase
	TermID uint64
	PkBls  []byte
	SigSet []*SigSet
	Issuer Address
}

func (*TermChange) Compare 

func (tc *TermChange) Compare(tx Txi) bool

func (*TermChange) DecodeMsg 

func (z *TermChange) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*TermChange) Dump 

func (tc *TermChange) Dump() string

func (*TermChange) EncodeMsg 

func (z *TermChange) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*TermChange) GetBase 

func (tc *TermChange) GetBase() *TxBase

func (*TermChange) IsSameTermInfo 

func (tc *TermChange) IsSameTermInfo(ctc *TermChange) bool

func (*TermChange) MarshalMsg 

func (z *TermChange) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*TermChange) Msgsize 

func (z *TermChange) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*TermChange) RawTermChange 

func (c *TermChange) RawTermChange() *RawTermChange

func (*TermChange) RawTxi 

func (c *TermChange) RawTxi() RawTxi

func (*TermChange) Sender 

func (tc *TermChange) Sender() Address

func (*TermChange) SignatureTargets 

func (tc *TermChange) SignatureTargets() []byte

func (*TermChange) String 

func (tc *TermChange) String() string

func (*TermChange) UnmarshalMsg 

func (z *TermChange) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type TermChanges 

type TermChanges []*TermChange

func (*TermChanges) DecodeMsg 

func (z *TermChanges) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (TermChanges) EncodeMsg 

func (z TermChanges) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*TermChanges) Len 

func (r *TermChanges) Len() int

func (TermChanges) MarshalMsg 

func (z TermChanges) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (TermChanges) Msgsize 

func (z TermChanges) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (TermChanges) RawTermChanges 

func (cs TermChanges) RawTermChanges() RawTermChanges

func (TermChanges) String 

func (c TermChanges) String() string

func (*TermChanges) UnmarshalMsg 

func (z *TermChanges) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Tx 

type Tx struct {
	TxBase
	From  Address
	To    Address
	Value *math.BigInt
	Data  []byte
}

func RandomTx 

func RandomTx() *Tx

func SampleTx 

func SampleTx() *Tx

func (*Tx) Compare 

func (t *Tx) Compare(tx Txi) bool

func (*Tx) DecodeMsg 

func (z *Tx) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*Tx) Dump 

func (t *Tx) Dump() string

func (*Tx) EncodeMsg 

func (z *Tx) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Tx) GetBase 

func (t *Tx) GetBase() *TxBase

func (*Tx) GetValue 

func (t *Tx) GetValue() *math.BigInt

func (*Tx) MarshalMsg 

func (z *Tx) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*Tx) Msgsize 

func (z *Tx) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*Tx) Parents 

func (t *Tx) Parents() Hashes

func (*Tx) RawTx 

func (t *Tx) RawTx() *RawTx

func (*Tx) RawTxi 

func (c *Tx) RawTxi() RawTxi

func (*Tx) Sender 

func (t *Tx) Sender() Address

func (*Tx) SignatureTargets 

func (t *Tx) SignatureTargets() []byte

func (*Tx) String 

func (t *Tx) String() string

func (*Tx) UnmarshalMsg 

func (z *Tx) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type TxBase 

type TxBase struct {
	Type         TxBaseType
	Hash         Hash
	ParentsHash  Hashes
	AccountNonce uint64
	Height       uint64
	PublicKey    []byte
	Signature    []byte
	MineNonce    uint64
	Weight       uint64
	// contains filtered or unexported fields
}

func (*TxBase) CalcMinedHash 

func (t *TxBase) CalcMinedHash() (hash Hash)

func (*TxBase) CalcTxHash 

func (t *TxBase) CalcTxHash() (hash Hash)

func (*TxBase) CalculateWeight 

func (t *TxBase) CalculateWeight(parents Txis) uint64

CalculateWeight a core algorithm for tx sorting, a tx's weight must bigger than any of it's parent's weight and bigger than any of it's elder transaction's

func (*TxBase) DecodeMsg 

func (z *TxBase) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*TxBase) EncodeMsg 

func (z *TxBase) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*TxBase) GetHeight 

func (t *TxBase) GetHeight() uint64

func (*TxBase) GetNonce 

func (t *TxBase) GetNonce() uint64

func (*TxBase) GetTxHash 

func (t *TxBase) GetTxHash() Hash

func (*TxBase) GetType 

func (t *TxBase) GetType() TxBaseType

func (*TxBase) GetWeight 

func (t *TxBase) GetWeight() uint64

func (*TxBase) InValid 

func (t *TxBase) InValid() bool

func (*TxBase) MarshalMsg 

func (z *TxBase) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*TxBase) Msgsize 

func (z *TxBase) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*TxBase) Parents 

func (t *TxBase) Parents() Hashes

func (*TxBase) SetHash 

func (t *TxBase) SetHash(hash Hash)

func (*TxBase) SetInValid 

func (t *TxBase) SetInValid(b bool)

func (*TxBase) String 

func (t *TxBase) String() string

func (*TxBase) UnmarshalMsg 

func (z *TxBase) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type TxBaseType 

type TxBaseType uint16
const (
	TxBaseTypeNormal TxBaseType = iota
	TxBaseTypeSequencer
	TxBaseTypeCampaign
	TxBaseTypeTermChange
)

func (*TxBaseType) DecodeMsg 

func (z *TxBaseType) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (TxBaseType) EncodeMsg 

func (z TxBaseType) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (TxBaseType) MarshalMsg 

func (z TxBaseType) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (TxBaseType) Msgsize 

func (z TxBaseType) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (TxBaseType) String 

func (t TxBaseType) String() string

func (*TxBaseType) UnmarshalMsg 

func (z *TxBaseType) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Txi 

type Txi interface {
	// Implemented by TxBase
	GetType() TxBaseType
	GetHeight() uint64
	GetWeight() uint64
	GetTxHash() Hash
	GetNonce() uint64
	Parents() Hashes // Parents returns the hash of txs that it directly proves.
	SetHash(h Hash)
	String() string
	CalcTxHash() Hash    // TxHash returns a full tx hash (parents sealed by PoW stage 2)
	CalcMinedHash() Hash // NonceHash returns the part that needs to be considered in PoW stage 1.
	CalculateWeight(parents Txis) uint64

	SetInValid(b bool)
	InValid() bool

	// implemented by each tx type
	GetBase() *TxBase
	Sender() Address
	Dump() string             // For logger dump
	Compare(tx Txi) bool      // Compare compares two txs, return true if they are the same.
	SignatureTargets() []byte // SignatureTargets only returns the parts that needs to be signed by sender.

	RawTxi() RawTxi // compressed txi

	// implemented by msgp
	DecodeMsg(dc *msgp.Reader) (err error)
	EncodeMsg(en *msgp.Writer) (err error)
	MarshalMsg(b []byte) (o []byte, err error)
	UnmarshalMsg(bts []byte) (o []byte, err error)
	Msgsize() (s int)
}

type Txis 

type Txis []Txi

func (*Txis) DecodeMsg 

func (z *Txis) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Txis) EncodeMsg 

func (z Txis) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (Txis) Len 

func (t Txis) Len() int

func (Txis) Less 

func (t Txis) Less(i, j int) bool

func (Txis) MarshalMsg 

func (z Txis) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Txis) Msgsize 

func (z Txis) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (Txis) RawTxis 

func (t Txis) RawTxis() RawTxis

func (Txis) String 

func (t Txis) String() string

func (Txis) Swap 

func (t Txis) Swap(i, j int)

func (Txis) ToRaw 

func (t Txis) ToRaw() (txs RawTxs, cps RawCampaigns, tcs RawTermChanges, seqs RawSequencers)

func (Txis) ToTxs 

func (t Txis) ToTxs() (txs Txs, cps Campaigns, tcs TermChanges, seqs Sequencers)

func (Txis) TxisMarshaler 

func (t Txis) TxisMarshaler() TxisMarshaler

func (*Txis) UnmarshalMsg 

func (z *Txis) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type TxisMarshaler 

type TxisMarshaler []*RawTxMarshaler

func (*TxisMarshaler) Append 

func (t *TxisMarshaler) Append(tx Txi)

func (*TxisMarshaler) DecodeMsg 

func (z *TxisMarshaler) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (TxisMarshaler) EncodeMsg 

func (z TxisMarshaler) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (TxisMarshaler) Len 

func (t TxisMarshaler) Len() int

func (TxisMarshaler) MarshalMsg 

func (z TxisMarshaler) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (TxisMarshaler) Msgsize 

func (z TxisMarshaler) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (TxisMarshaler) String 

func (t TxisMarshaler) String() string

func (TxisMarshaler) Txis 

func (t TxisMarshaler) Txis() Txis

func (*TxisMarshaler) UnmarshalMsg 

func (z *TxisMarshaler) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type Txs 

type Txs []*Tx

func (*Txs) DecodeMsg 

func (z *Txs) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (Txs) EncodeMsg 

func (z Txs) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*Txs) Len 

func (r *Txs) Len() int

func (Txs) MarshalMsg 

func (z Txs) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (Txs) Msgsize 

func (z Txs) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (Txs) String 

func (t Txs) String() string

func (Txs) ToRawTxs 

func (t Txs) ToRawTxs() RawTxs

func (*Txs) UnmarshalMsg 

func (z *Txs) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

type VrfInfo 

type VrfInfo struct {
	Message   []byte
	Proof     []byte
	PublicKey []byte
	Vrf       []byte
}

func (*VrfInfo) DecodeMsg 

func (z *VrfInfo) DecodeMsg(dc *msgp.Reader) (err error)

DecodeMsg implements msgp.Decodable

func (*VrfInfo) EncodeMsg 

func (z *VrfInfo) EncodeMsg(en *msgp.Writer) (err error)

EncodeMsg implements msgp.Encodable

func (*VrfInfo) MarshalMsg 

func (z *VrfInfo) MarshalMsg(b []byte) (o []byte, err error)

MarshalMsg implements msgp.Marshaler

func (*VrfInfo) Msgsize 

func (z *VrfInfo) Msgsize() (s int)

Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message

func (*VrfInfo) String 

func (v *VrfInfo) String() string

func (*VrfInfo) UnmarshalMsg 

func (z *VrfInfo) UnmarshalMsg(bts []byte) (o []byte, err error)

UnmarshalMsg implements msgp.Unmarshaler

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.