protocol/bc/types/block_header.go

   1 package types
   2
   3 import (
   4         "encoding/hex"
   5         "fmt"
   6         "io"
   7         "time"
   8
   9         "github.com/vapor/encoding/blockchain"
  10         "github.com/vapor/encoding/bufpool"
  11         "github.com/vapor/errors"
  12         "github.com/vapor/protocol/bc"
  13 )
  14
  15 // BlockHeader defines information about a block and is used in the Bytom
  16 type BlockHeader struct {
  17         Version           uint64  // The version of the block.
  18         Height            uint64  // The height of the block.
  19         PreviousBlockHash bc.Hash // The hash of the previous block.
  20         Timestamp         uint64  // The time of the block in seconds.
  21         BlockCommitment
  22 }
  23
  24 // Time returns the time represented by the Timestamp in block header.
  25 func (bh *BlockHeader) Time() time.Time {
  26         return time.Unix(int64(bh.Timestamp), 0).UTC()
  27 }
  28
  29 // Hash returns complete hash of the block header.
  30 func (bh *BlockHeader) Hash() bc.Hash {
  31         h, _ := mapBlockHeader(bh)
  32         return h
  33 }
  34
  35 // MarshalText fulfills the json.Marshaler interface. This guarantees that
  36 // block headers will get deserialized correctly when being parsed from HTTP
  37 // requests.
  38 func (bh *BlockHeader) MarshalText() ([]byte, error) {
  39         buf := bufpool.Get()
  40         defer bufpool.Put(buf)
  41
  42         if _, err := bh.WriteTo(buf); err != nil {
  43                 return nil, err
  44         }
  45
  46         enc := make([]byte, hex.EncodedLen(buf.Len()))
  47         hex.Encode(enc, buf.Bytes())
  48         return enc, nil
  49 }
  50
  51 // UnmarshalText fulfills the encoding.TextUnmarshaler interface.
  52 func (bh *BlockHeader) UnmarshalText(text []byte) error {
  53         decoded := make([]byte, hex.DecodedLen(len(text)))
  54         if _, err := hex.Decode(decoded, text); err != nil {
  55                 return err
  56         }
  57
  58         _, err := bh.readFrom(blockchain.NewReader(decoded))
  59         return err
  60 }
  61
  62 func (bh *BlockHeader) readFrom(r *blockchain.Reader) (serflag uint8, err error) {
  63         var serflags [1]byte
  64         io.ReadFull(r, serflags[:])
  65         serflag = serflags[0]
  66         switch serflag {
  67         case SerBlockHeader, SerBlockFull:
  68         default:
  69                 return 0, fmt.Errorf("unsupported serialization flags 0x%x", serflags)
  70         }
  71
  72         if bh.Version, err = blockchain.ReadVarint63(r); err != nil {
  73                 return 0, err
  74         }
  75         if bh.Height, err = blockchain.ReadVarint63(r); err != nil {
  76                 return 0, err
  77         }
  78         if _, err = bh.PreviousBlockHash.ReadFrom(r); err != nil {
  79                 return 0, err
  80         }
  81         if bh.Timestamp, err = blockchain.ReadVarint63(r); err != nil {
  82                 return 0, err
  83         }
  84         if _, err = blockchain.ReadExtensibleString(r, bh.BlockCommitment.readFrom); err != nil {
  85                 return 0, err
  86         }
  87         return
  88 }
  89
  90 // WriteTo writes the block header to the input io.Writer
  91 func (bh *BlockHeader) WriteTo(w io.Writer) (int64, error) {
  92         ew := errors.NewWriter(w)
  93         if err := bh.writeTo(ew, SerBlockHeader); err != nil {
  94                 return 0, err
  95         }
  96         return ew.Written(), ew.Err()
  97 }
  98
  99 func (bh *BlockHeader) writeTo(w io.Writer, serflags uint8) (err error) {
 100         w.Write([]byte{serflags})
 101         if _, err = blockchain.WriteVarint63(w, bh.Version); err != nil {
 102                 return err
 103         }
 104         if _, err = blockchain.WriteVarint63(w, bh.Height); err != nil {
 105                 return err
 106         }
 107         if _, err = bh.PreviousBlockHash.WriteTo(w); err != nil {
 108                 return err
 109         }
 110         if _, err = blockchain.WriteVarint63(w, bh.Timestamp); err != nil {
 111                 return err
 112         }
 113         if _, err = blockchain.WriteExtensibleString(w, nil, bh.BlockCommitment.writeTo); err != nil {
 114                 return err
 115         }
 116         return nil
 117 }