lotus/chain/types/tipset.go

211 lines
3.6 KiB
Go
Raw Normal View History

2019-07-26 04:54:22 +00:00
package types
import (
"bytes"
2019-07-26 04:54:22 +00:00
"encoding/json"
"fmt"
2019-11-01 13:58:48 +00:00
"io"
2019-10-01 18:47:42 +00:00
"sort"
2019-07-26 04:54:22 +00:00
"github.com/ipfs/go-cid"
logging "github.com/ipfs/go-log"
2019-11-01 22:44:55 +00:00
cbg "github.com/whyrusleeping/cbor-gen"
2019-07-26 04:54:22 +00:00
)
var log = logging.Logger("types")
2019-07-26 04:54:22 +00:00
type TipSet struct {
cids []cid.Cid
blks []*BlockHeader
height uint64
}
// why didnt i just export the fields? Because the struct has methods with the
// same names already
2019-11-01 13:58:48 +00:00
type ExpTipSet struct {
2019-07-26 04:54:22 +00:00
Cids []cid.Cid
Blocks []*BlockHeader
Height uint64
}
func (ts *TipSet) MarshalJSON() ([]byte, error) {
2019-11-01 13:58:48 +00:00
return json.Marshal(ExpTipSet{
2019-07-26 04:54:22 +00:00
Cids: ts.cids,
Blocks: ts.blks,
Height: ts.height,
})
}
func (ts *TipSet) UnmarshalJSON(b []byte) error {
2019-11-01 13:58:48 +00:00
var ets ExpTipSet
2019-07-26 04:54:22 +00:00
if err := json.Unmarshal(b, &ets); err != nil {
return err
}
2019-10-01 18:47:42 +00:00
ots, err := NewTipSet(ets.Blocks)
if err != nil {
return err
}
*ts = *ots
2019-07-26 04:54:22 +00:00
return nil
}
2019-11-01 13:58:48 +00:00
func (ts *TipSet) MarshalCBOR(w io.Writer) error {
2019-11-01 22:44:55 +00:00
if ts == nil {
_, err := w.Write(cbg.CborNull)
return err
}
2019-11-01 13:58:48 +00:00
return (&ExpTipSet{
Cids: ts.cids,
Blocks: ts.blks,
Height: ts.height,
}).MarshalCBOR(w)
}
func (ts *TipSet) UnmarshalCBOR(r io.Reader) error {
var ets ExpTipSet
if err := ets.UnmarshalCBOR(r); err != nil {
return err
}
ots, err := NewTipSet(ets.Blocks)
if err != nil {
return err
}
*ts = *ots
return nil
}
2019-10-01 18:47:42 +00:00
func tipsetSortFunc(blks []*BlockHeader) func(i, j int) bool {
return func(i, j int) bool {
ti := blks[i].LastTicket()
tj := blks[j].LastTicket()
if ti.Equals(tj) {
log.Warnf("blocks have same ticket (%s %s)", blks[i].Miner, blks[j].Miner)
2019-10-01 18:47:42 +00:00
return blks[i].Cid().KeyString() < blks[j].Cid().KeyString()
}
return ti.Less(tj)
}
}
2019-07-26 04:54:22 +00:00
func NewTipSet(blks []*BlockHeader) (*TipSet, error) {
2019-10-01 18:47:42 +00:00
sort.Slice(blks, tipsetSortFunc(blks))
2019-07-26 04:54:22 +00:00
var ts TipSet
ts.cids = []cid.Cid{blks[0].Cid()}
ts.blks = blks
for _, b := range blks[1:] {
if b.Height != blks[0].Height {
return nil, fmt.Errorf("cannot create tipset with mismatching heights")
}
2019-10-28 09:19:58 +00:00
for i, cid := range b.Parents {
if cid != blks[0].Parents[i] {
return nil, fmt.Errorf("cannot create tipset with mismatching parents")
}
}
2019-07-26 04:54:22 +00:00
ts.cids = append(ts.cids, b.Cid())
2019-10-13 01:18:59 +00:00
2019-07-26 04:54:22 +00:00
}
ts.height = blks[0].Height
return &ts, nil
}
func (ts *TipSet) Cids() []cid.Cid {
return ts.cids
}
func (ts *TipSet) Key() TipSetKey {
return NewTipSetKey(ts.cids...)
}
2019-07-26 04:54:22 +00:00
func (ts *TipSet) Height() uint64 {
return ts.height
}
func (ts *TipSet) Parents() []cid.Cid {
return ts.blks[0].Parents
}
func (ts *TipSet) Blocks() []*BlockHeader {
return ts.blks
}
func (ts *TipSet) Equals(ots *TipSet) bool {
2019-10-04 22:43:04 +00:00
if ts == nil && ots == nil {
return true
}
if ts == nil || ots == nil {
return false
}
2019-07-26 04:54:22 +00:00
if len(ts.blks) != len(ots.blks) {
return false
}
for i, b := range ts.blks {
if b.Cid() != ots.blks[i].Cid() {
return false
}
}
return true
}
func (t *Ticket) Less(o *Ticket) bool {
2019-10-09 04:38:59 +00:00
return bytes.Compare(t.VRFProof, o.VRFProof) < 0
}
func (ts *TipSet) MinTicket() *Ticket {
return ts.MinTicketBlock().Ticket
}
func (ts *TipSet) MinTimestamp() uint64 {
minTs := ts.Blocks()[0].Timestamp
for _, bh := range ts.Blocks()[1:] {
if bh.Timestamp < minTs {
minTs = bh.Timestamp
}
}
return minTs
}
func (ts *TipSet) MinTicketBlock() *BlockHeader {
blks := ts.Blocks()
min := blks[0]
for _, b := range blks[1:] {
if b.LastTicket().Less(min.LastTicket()) {
min = b
}
}
return min
}
2019-10-02 20:03:27 +00:00
func (ts *TipSet) ParentState() cid.Cid {
return ts.blks[0].ParentStateRoot
}
2019-11-15 02:27:43 +00:00
func (ts *TipSet) ParentWeight() BigInt {
return ts.blks[0].ParentWeight
}
func (ts *TipSet) Contains(oc cid.Cid) bool {
for _, c := range ts.cids {
if c == oc {
return true
}
}
return false
}