commits.db downloader

From Natasha Otomoski, 2 Weeks ago, written in Go, viewed 251 times.
URL https://paste.scratchbook.ch/view/ede159d0 Embed
Download Paste or View Raw
  1. package main
  2.  
  3. import "crypto/aes"
  4. import "crypto/sha256"
  5.  
  6. import (
  7.         "bytes"
  8.         "io"
  9.         "time"
  10. )
  11.  
  12. import (
  13.         "crypto/rand"
  14.         "encoding/binary"
  15.         "fmt"
  16.         "math"
  17. )
  18.  
  19. import "net"
  20. import "sync"
  21.  
  22. import "log"
  23.  
  24. import (
  25.         "encoding/hex"
  26. )
  27.  
  28. import "os"
  29.  
  30. import (
  31.         "unicode/utf8"
  32. )
  33.  
  34. import (
  35.         "errors"
  36. )
  37.  
  38. import "os/signal"
  39. import "syscall"
  40.  
  41. import (
  42.         "strconv"
  43. )
  44.  
  45. import (
  46.         "strings"
  47. )
  48.  
  49. func aes_checksum(buf, load_aes *[32]byte) {
  50.         var aestmp [32]byte
  51.  
  52.         var aes, err5 = aes.NewCipher(buf[0:])
  53.         if err5 != nil {
  54.                 panic("cannot use aes")
  55.         }
  56.  
  57.         aes.Encrypt(aestmp[0:16], load_aes[0:16])
  58.         aes.Decrypt(aestmp[16:32], load_aes[16:32])
  59.  
  60.         for i := 8; i < 16; i++ {
  61.                 aestmp[i], aestmp[8+i] = aestmp[8+i], aestmp[i]
  62.         }
  63.  
  64.         aes.Encrypt(load_aes[0:16], aestmp[0:16])
  65.         aes.Decrypt(load_aes[16:32], aestmp[16:32])
  66. }
  67.  
  68. func BCDFromUint(value uint64, buf []byte) {
  69.         if value > 0 {
  70.                 remainder := value
  71.                 for pos := len(buf) - 1; pos >= 0 && remainder > 0; pos-- {
  72.                         tail := byte(remainder % 100)
  73.                         hi, lo := tail/10, tail%10
  74.                         buf[pos] = byte(hi<<4 + lo)
  75.                         remainder = remainder / 100
  76.                 }
  77.         }
  78. }
  79.  
  80. const MaxBlockHeaderPayload = 16 + (HashSize * 2)
  81.  
  82. type BlockHeader struct {
  83.         Version int32
  84.  
  85.         PrevBlock Hash
  86.  
  87.         MerkleRoot Hash
  88.  
  89.         Timestamp time.Time
  90.  
  91.         Bits uint32
  92.  
  93.         Nonce uint32
  94. }
  95.  
  96. const blockHeaderLen = 80
  97.  
  98. func (h *BlockHeader) BlockHash() Hash {
  99.  
  100.         buf := bytes.NewBuffer(make([]byte, 0, MaxBlockHeaderPayload))
  101.         _ = writeBlockHeader(buf, 0, h)
  102.  
  103.         return DoubleHashH(buf.Bytes())
  104. }
  105.  
  106. func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  107.         return readBlockHeader(r, pver, h)
  108. }
  109.  
  110. func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  111.         return writeBlockHeader(w, pver, h)
  112. }
  113.  
  114. func (h *BlockHeader) Deserialize(r io.Reader) error {
  115.  
  116.         return readBlockHeader(r, 0, h)
  117. }
  118.  
  119. func (h *BlockHeader) Serialize(w io.Writer) error {
  120.  
  121.         return writeBlockHeader(w, 0, h)
  122. }
  123.  
  124. func NewBlockHeader(version int32, prevHash, merkleRootHash *Hash,
  125.         bits uint32, nonce uint32) *BlockHeader {
  126.  
  127.         return &BlockHeader{
  128.                 Version:    version,
  129.                 PrevBlock:  *prevHash,
  130.                 MerkleRoot: *merkleRootHash,
  131.                 Timestamp:  time.Unix(time.Now().Unix(), 0),
  132.                 Bits:       bits,
  133.                 Nonce:      nonce,
  134.         }
  135. }
  136.  
  137. func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
  138.         return readElements(r, &bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
  139.                 (*uint32Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
  140. }
  141.  
  142. func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
  143.         sec := uint32(bh.Timestamp.Unix())
  144.         return writeElements(w, bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
  145.                 sec, bh.Bits, bh.Nonce)
  146. }
  147.  
  148. const (
  149.         MaxVarIntPayload = 9
  150.  
  151.         binaryFreeListMaxItems = 1024
  152. )
  153.  
  154. var (
  155.         littleEndian = binary.LittleEndian
  156.  
  157.         bigEndian = binary.BigEndian
  158. )
  159.  
  160. type binaryFreeList chan []byte
  161.  
  162. func (l binaryFreeList) Borrow() []byte {
  163.         var buf []byte
  164.         select {
  165.         case buf = <-l:
  166.         default:
  167.                 buf = make([]byte, 8)
  168.         }
  169.         return buf[:8]
  170. }
  171.  
  172. func (l binaryFreeList) Return(buf []byte) {
  173.         select {
  174.         case l <- buf:
  175.         default:
  176.  
  177.         }
  178. }
  179.  
  180. func (l binaryFreeList) Uint8(r io.Reader) (uint8, error) {
  181.         buf := l.Borrow()[:1]
  182.         if _, err := io.ReadFull(r, buf); err != nil {
  183.                 l.Return(buf)
  184.                 return 0, err
  185.         }
  186.         rv := buf[0]
  187.         l.Return(buf)
  188.         return rv, nil
  189. }
  190.  
  191. func (l binaryFreeList) Uint16(r io.Reader, byteOrder binary.ByteOrder) (uint16, error) {
  192.         buf := l.Borrow()[:2]
  193.         if _, err := io.ReadFull(r, buf); err != nil {
  194.                 l.Return(buf)
  195.                 return 0, err
  196.         }
  197.         rv := byteOrder.Uint16(buf)
  198.         l.Return(buf)
  199.         return rv, nil
  200. }
  201.  
  202. func (l binaryFreeList) Uint32(r io.Reader, byteOrder binary.ByteOrder) (uint32, error) {
  203.         buf := l.Borrow()[:4]
  204.         if _, err := io.ReadFull(r, buf); err != nil {
  205.                 l.Return(buf)
  206.                 return 0, err
  207.         }
  208.         rv := byteOrder.Uint32(buf)
  209.         l.Return(buf)
  210.         return rv, nil
  211. }
  212.  
  213. func (l binaryFreeList) Uint64(r io.Reader, byteOrder binary.ByteOrder) (uint64, error) {
  214.         buf := l.Borrow()[:8]
  215.         if _, err := io.ReadFull(r, buf); err != nil {
  216.                 l.Return(buf)
  217.                 return 0, err
  218.         }
  219.         rv := byteOrder.Uint64(buf)
  220.         l.Return(buf)
  221.         return rv, nil
  222. }
  223.  
  224. func (l binaryFreeList) PutUint8(w io.Writer, val uint8) error {
  225.         buf := l.Borrow()[:1]
  226.         buf[0] = val
  227.         _, err := w.Write(buf)
  228.         l.Return(buf)
  229.         return err
  230. }
  231.  
  232. func (l binaryFreeList) PutUint16(w io.Writer, byteOrder binary.ByteOrder, val uint16) error {
  233.         buf := l.Borrow()[:2]
  234.         byteOrder.PutUint16(buf, val)
  235.         _, err := w.Write(buf)
  236.         l.Return(buf)
  237.         return err
  238. }
  239.  
  240. func (l binaryFreeList) PutUint32(w io.Writer, byteOrder binary.ByteOrder, val uint32) error {
  241.         buf := l.Borrow()[:4]
  242.         byteOrder.PutUint32(buf, val)
  243.         _, err := w.Write(buf)
  244.         l.Return(buf)
  245.         return err
  246. }
  247.  
  248. func (l binaryFreeList) PutUint64(w io.Writer, byteOrder binary.ByteOrder, val uint64) error {
  249.         buf := l.Borrow()[:8]
  250.         byteOrder.PutUint64(buf, val)
  251.         _, err := w.Write(buf)
  252.         l.Return(buf)
  253.         return err
  254. }
  255.  
  256. var binarySerializer binaryFreeList = make(chan []byte, binaryFreeListMaxItems)
  257.  
  258. var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
  259.         "encode a value greater than %x"
  260.  
  261. type uint32Time time.Time
  262.  
  263. type int64Time time.Time
  264.  
  265. func readElement(r io.Reader, element interface{}) error {
  266.  
  267.         switch e := element.(type) {
  268.         case *int32:
  269.                 rv, err := binarySerializer.Uint32(r, littleEndian)
  270.                 if err != nil {
  271.                         return err
  272.                 }
  273.                 *e = int32(rv)
  274.                 return nil
  275.  
  276.         case *uint32:
  277.                 rv, err := binarySerializer.Uint32(r, littleEndian)
  278.                 if err != nil {
  279.                         return err
  280.                 }
  281.                 *e = rv
  282.                 return nil
  283.  
  284.         case *int64:
  285.                 rv, err := binarySerializer.Uint64(r, littleEndian)
  286.                 if err != nil {
  287.                         return err
  288.                 }
  289.                 *e = int64(rv)
  290.                 return nil
  291.  
  292.         case *uint64:
  293.                 rv, err := binarySerializer.Uint64(r, littleEndian)
  294.                 if err != nil {
  295.                         return err
  296.                 }
  297.                 *e = rv
  298.                 return nil
  299.  
  300.         case *bool:
  301.                 rv, err := binarySerializer.Uint8(r)
  302.                 if err != nil {
  303.                         return err
  304.                 }
  305.                 if rv == 0x00 {
  306.                         *e = false
  307.                 } else {
  308.                         *e = true
  309.                 }
  310.                 return nil
  311.  
  312.         case *uint32Time:
  313.                 rv, err := binarySerializer.Uint32(r, binary.LittleEndian)
  314.                 if err != nil {
  315.                         return err
  316.                 }
  317.                 *e = uint32Time(time.Unix(int64(rv), 0))
  318.                 return nil
  319.  
  320.         case *int64Time:
  321.                 rv, err := binarySerializer.Uint64(r, binary.LittleEndian)
  322.                 if err != nil {
  323.                         return err
  324.                 }
  325.                 *e = int64Time(time.Unix(int64(rv), 0))
  326.                 return nil
  327.  
  328.         case *[4]byte:
  329.                 _, err := io.ReadFull(r, e[:])
  330.                 if err != nil {
  331.                         return err
  332.                 }
  333.                 return nil
  334.  
  335.         case *[CommandSize]uint8:
  336.                 _, err := io.ReadFull(r, e[:])
  337.                 if err != nil {
  338.                         return err
  339.                 }
  340.                 return nil
  341.  
  342.         case *[16]byte:
  343.                 _, err := io.ReadFull(r, e[:])
  344.                 if err != nil {
  345.                         return err
  346.                 }
  347.                 return nil
  348.  
  349.         case *Hash:
  350.                 _, err := io.ReadFull(r, e[:])
  351.                 if err != nil {
  352.                         return err
  353.                 }
  354.                 return nil
  355.  
  356.         case *ServiceFlag:
  357.                 rv, err := binarySerializer.Uint64(r, littleEndian)
  358.                 if err != nil {
  359.                         return err
  360.                 }
  361.                 *e = ServiceFlag(rv)
  362.                 return nil
  363.  
  364.         case *InvType:
  365.                 rv, err := binarySerializer.Uint32(r, littleEndian)
  366.                 if err != nil {
  367.                         return err
  368.                 }
  369.                 *e = InvType(rv)
  370.                 return nil
  371.  
  372.         case *BitcoinNet:
  373.                 rv, err := binarySerializer.Uint32(r, littleEndian)
  374.                 if err != nil {
  375.                         return err
  376.                 }
  377.                 *e = BitcoinNet(rv)
  378.                 return nil
  379.  
  380.         case *BloomUpdateType:
  381.                 rv, err := binarySerializer.Uint8(r)
  382.                 if err != nil {
  383.                         return err
  384.                 }
  385.                 *e = BloomUpdateType(rv)
  386.                 return nil
  387.  
  388.         case *RejectCode:
  389.                 rv, err := binarySerializer.Uint8(r)
  390.                 if err != nil {
  391.                         return err
  392.                 }
  393.                 *e = RejectCode(rv)
  394.                 return nil
  395.         }
  396.  
  397.         return binary.Read(r, littleEndian, element)
  398. }
  399.  
  400. func readElements(r io.Reader, elements ...interface{}) error {
  401.         for _, element := range elements {
  402.                 err := readElement(r, element)
  403.                 if err != nil {
  404.                         return err
  405.                 }
  406.         }
  407.         return nil
  408. }
  409.  
  410. func writeElement(w io.Writer, element interface{}) error {
  411.  
  412.         switch e := element.(type) {
  413.         case int32:
  414.                 err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  415.                 if err != nil {
  416.                         return err
  417.                 }
  418.                 return nil
  419.  
  420.         case uint32:
  421.                 err := binarySerializer.PutUint32(w, littleEndian, e)
  422.                 if err != nil {
  423.                         return err
  424.                 }
  425.                 return nil
  426.  
  427.         case int64:
  428.                 err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
  429.                 if err != nil {
  430.                         return err
  431.                 }
  432.                 return nil
  433.  
  434.         case uint64:
  435.                 err := binarySerializer.PutUint64(w, littleEndian, e)
  436.                 if err != nil {
  437.                         return err
  438.                 }
  439.                 return nil
  440.  
  441.         case bool:
  442.                 var err error
  443.                 if e {
  444.                         err = binarySerializer.PutUint8(w, 0x01)
  445.                 } else {
  446.                         err = binarySerializer.PutUint8(w, 0x00)
  447.                 }
  448.                 if err != nil {
  449.                         return err
  450.                 }
  451.                 return nil
  452.  
  453.         case [4]byte:
  454.                 _, err := w.Write(e[:])
  455.                 if err != nil {
  456.                         return err
  457.                 }
  458.                 return nil
  459.  
  460.         case [CommandSize]uint8:
  461.                 _, err := w.Write(e[:])
  462.                 if err != nil {
  463.                         return err
  464.                 }
  465.                 return nil
  466.  
  467.         case [16]byte:
  468.                 _, err := w.Write(e[:])
  469.                 if err != nil {
  470.                         return err
  471.                 }
  472.                 return nil
  473.  
  474.         case *Hash:
  475.                 _, err := w.Write(e[:])
  476.                 if err != nil {
  477.                         return err
  478.                 }
  479.                 return nil
  480.  
  481.         case ServiceFlag:
  482.                 err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
  483.                 if err != nil {
  484.                         return err
  485.                 }
  486.                 return nil
  487.  
  488.         case InvType:
  489.                 err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  490.                 if err != nil {
  491.                         return err
  492.                 }
  493.                 return nil
  494.  
  495.         case BitcoinNet:
  496.                 err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  497.                 if err != nil {
  498.                         return err
  499.                 }
  500.                 return nil
  501.  
  502.         case BloomUpdateType:
  503.                 err := binarySerializer.PutUint8(w, uint8(e))
  504.                 if err != nil {
  505.                         return err
  506.                 }
  507.                 return nil
  508.  
  509.         case RejectCode:
  510.                 err := binarySerializer.PutUint8(w, uint8(e))
  511.                 if err != nil {
  512.                         return err
  513.                 }
  514.                 return nil
  515.         }
  516.  
  517.         return binary.Write(w, littleEndian, element)
  518. }
  519.  
  520. func writeElements(w io.Writer, elements ...interface{}) error {
  521.         for _, element := range elements {
  522.                 err := writeElement(w, element)
  523.                 if err != nil {
  524.                         return err
  525.                 }
  526.         }
  527.         return nil
  528. }
  529.  
  530. func ReadVarInt(r io.Reader, pver uint32) (uint64, error) {
  531.         discriminant, err := binarySerializer.Uint8(r)
  532.         if err != nil {
  533.                 return 0, err
  534.         }
  535.  
  536.         var rv uint64
  537.         switch discriminant {
  538.         case 0xff:
  539.                 sv, err := binarySerializer.Uint64(r, littleEndian)
  540.                 if err != nil {
  541.                         return 0, err
  542.                 }
  543.                 rv = sv
  544.  
  545.                 min := uint64(0x100000000)
  546.                 if rv < min {
  547.                         return 0, messageError("ReadVarInt", fmt.Sprintf(
  548.                                 errNonCanonicalVarInt, rv, discriminant, min))
  549.                 }
  550.  
  551.         case 0xfe:
  552.                 sv, err := binarySerializer.Uint32(r, littleEndian)
  553.                 if err != nil {
  554.                         return 0, err
  555.                 }
  556.                 rv = uint64(sv)
  557.  
  558.                 min := uint64(0x10000)
  559.                 if rv < min {
  560.                         return 0, messageError("ReadVarInt", fmt.Sprintf(
  561.                                 errNonCanonicalVarInt, rv, discriminant, min))
  562.                 }
  563.  
  564.         case 0xfd:
  565.                 sv, err := binarySerializer.Uint16(r, littleEndian)
  566.                 if err != nil {
  567.                         return 0, err
  568.                 }
  569.                 rv = uint64(sv)
  570.  
  571.                 min := uint64(0xfd)
  572.                 if rv < min {
  573.                         return 0, messageError("ReadVarInt", fmt.Sprintf(
  574.                                 errNonCanonicalVarInt, rv, discriminant, min))
  575.                 }
  576.  
  577.         default:
  578.                 rv = uint64(discriminant)
  579.         }
  580.  
  581.         return rv, nil
  582. }
  583.  
  584. func WriteVarInt(w io.Writer, pver uint32, val uint64) error {
  585.         if val < 0xfd {
  586.                 return binarySerializer.PutUint8(w, uint8(val))
  587.         }
  588.  
  589.         if val <= math.MaxUint16 {
  590.                 err := binarySerializer.PutUint8(w, 0xfd)
  591.                 if err != nil {
  592.                         return err
  593.                 }
  594.                 return binarySerializer.PutUint16(w, littleEndian, uint16(val))
  595.         }
  596.  
  597.         if val <= math.MaxUint32 {
  598.                 err := binarySerializer.PutUint8(w, 0xfe)
  599.                 if err != nil {
  600.                         return err
  601.                 }
  602.                 return binarySerializer.PutUint32(w, littleEndian, uint32(val))
  603.         }
  604.  
  605.         err := binarySerializer.PutUint8(w, 0xff)
  606.         if err != nil {
  607.                 return err
  608.         }
  609.         return binarySerializer.PutUint64(w, littleEndian, val)
  610. }
  611.  
  612. func VarIntSerializeSize(val uint64) int {
  613.  
  614.         if val < 0xfd {
  615.                 return 1
  616.         }
  617.  
  618.         if val <= math.MaxUint16 {
  619.                 return 3
  620.         }
  621.  
  622.         if val <= math.MaxUint32 {
  623.                 return 5
  624.         }
  625.  
  626.         return 9
  627. }
  628.  
  629. func ReadVarString(r io.Reader, pver uint32) (string, error) {
  630.         count, err := ReadVarInt(r, pver)
  631.         if err != nil {
  632.                 return "", err
  633.         }
  634.  
  635.         if count > MaxMessagePayload {
  636.                 str := fmt.Sprintf("variable length string is too long "+
  637.                         "[count %d, max %d]", count, MaxMessagePayload)
  638.                 return "", messageError("ReadVarString", str)
  639.         }
  640.  
  641.         buf := make([]byte, count)
  642.         _, err = io.ReadFull(r, buf)
  643.         if err != nil {
  644.                 return "", err
  645.         }
  646.         return string(buf), nil
  647. }
  648.  
  649. func WriteVarString(w io.Writer, pver uint32, str string) error {
  650.         err := WriteVarInt(w, pver, uint64(len(str)))
  651.         if err != nil {
  652.                 return err
  653.         }
  654.         _, err = w.Write([]byte(str))
  655.         return err
  656. }
  657.  
  658. func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
  659.         fieldName string) ([]byte, error) {
  660.  
  661.         count, err := ReadVarInt(r, pver)
  662.         if err != nil {
  663.                 return nil, err
  664.         }
  665.  
  666.         if count > uint64(maxAllowed) {
  667.                 str := fmt.Sprintf("%s is larger than the max allowed size "+
  668.                         "[count %d, max %d]", fieldName, count, maxAllowed)
  669.                 return nil, messageError("ReadVarBytes", str)
  670.         }
  671.  
  672.         b := make([]byte, count)
  673.         _, err = io.ReadFull(r, b)
  674.         if err != nil {
  675.                 return nil, err
  676.         }
  677.         return b, nil
  678. }
  679.  
  680. func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
  681.         slen := uint64(len(bytes))
  682.         err := WriteVarInt(w, pver, slen)
  683.         if err != nil {
  684.                 return err
  685.         }
  686.  
  687.         _, err = w.Write(bytes)
  688.         return err
  689. }
  690.  
  691. func randomUint64(r io.Reader) (uint64, error) {
  692.         rv, err := binarySerializer.Uint64(r, bigEndian)
  693.         if err != nil {
  694.                 return 0, err
  695.         }
  696.         return rv, nil
  697. }
  698.  
  699. func RandomUint64() (uint64, error) {
  700.         return randomUint64(rand.Reader)
  701. }
  702.  
  703. const max_cruisers = 64
  704. const extra_addresses = 1024
  705.  
  706. var current_cruisers_mutex sync.Mutex
  707. var current_ended bool
  708. var current_all_cruisers map[string]*net.Conn
  709. var current_extra_cruisers map[string]struct{}
  710.  
  711. func init() {
  712.         current_all_cruisers = make(map[string]*net.Conn)
  713.         current_extra_cruisers = make(map[string]struct{})
  714. }
  715.  
  716. func cruiser_pending_extra_address() bool {
  717.         current_cruisers_mutex.Lock()
  718.         var pending = len(current_extra_cruisers) < extra_addresses
  719.         current_cruisers_mutex.Unlock()
  720.         return pending
  721. }
  722. func start_cruises(cru []string) {
  723.         for _, str := range cru {
  724.                 go func() {
  725.                         if err := cruise(str); err != nil {
  726.                                 fmt.Println(err)
  727.                         }
  728.                 }()
  729.         }
  730. }
  731. func has_cruiser(addr string) bool {
  732.         current_cruisers_mutex.Lock()
  733.         var ok2 = !current_ended
  734.         _, ok := current_all_cruisers[addr]
  735.         current_cruisers_mutex.Unlock()
  736.         return ok && ok2
  737. }
  738.  
  739. func end_cruises(cru []string) {
  740.         current_cruisers_mutex.Lock()
  741.         current_ended = true
  742.         for _, str := range cru {
  743.                 conn := current_all_cruisers[str]
  744.                 if conn != nil {
  745.                         (*conn).Close()
  746.                 }
  747.                 delete(current_all_cruisers, str)
  748.         }
  749.         current_cruisers_mutex.Unlock()
  750. }
  751. func end_other_cruiser_conn(conn *net.Conn) {
  752.         current_cruisers_mutex.Lock()
  753.         for str, c := range current_all_cruisers {
  754.                 if conn != c && c != nil {
  755.                         (*c).Close()
  756.                 }
  757.                 delete(current_all_cruisers, str)
  758.         }
  759.         current_cruisers_mutex.Unlock()
  760. }
  761. func cruised_conn() (conn *net.Conn, addr string) {
  762.         current_cruisers_mutex.Lock()
  763.         for a, c := range current_all_cruisers {
  764.                 if c != nil {
  765.                         conn = c
  766.                         addr = a
  767.                         delete(current_all_cruisers, a)
  768.                         break
  769.                 }
  770.         }
  771.         current_cruisers_mutex.Unlock()
  772.         return conn, addr
  773. }
  774.  
  775. func cruised_address() (addr string) {
  776.         current_cruisers_mutex.Lock()
  777.         for a := range current_all_cruisers {
  778.                 addr = a
  779.                 break
  780.         }
  781.         if len(addr) == 0 {
  782.                 for a := range current_extra_cruisers {
  783.                         addr = a
  784.                         break
  785.                 }
  786.         }
  787.         current_cruisers_mutex.Unlock()
  788.         return addr
  789. }
  790.  
  791. func isIpV6(ip string) bool {
  792.         for i := 0; i < len(ip); i++ {
  793.                 switch ip[i] {
  794.                 case '.':
  795.                         return false
  796.                 case ':':
  797.                         return true
  798.                 }
  799.         }
  800.         return true
  801. }
  802.  
  803. func cruise(addr string) error {
  804.  
  805.         current_cruisers_mutex.Lock()
  806.         if current_ended {
  807.                 current_cruisers_mutex.Unlock()
  808.                 return nil
  809.         }
  810.         if len(current_all_cruisers) >= max_cruisers {
  811.                 current_extra_cruisers[addr] = struct{}{}
  812.                 current_cruisers_mutex.Unlock()
  813.                 return fmt.Errorf("Max cruisers")
  814.         }
  815.         if _, ok := current_all_cruisers[addr]; ok {
  816.                 current_cruisers_mutex.Unlock()
  817.                 return nil
  818.         }
  819.         current_all_cruisers[addr] = nil
  820.         current_cruisers_mutex.Unlock()
  821.  
  822.         pver := ProtocolVersion
  823.         btcnet := MainNet
  824.  
  825.         conn, err := net.Dial("tcp", addr)
  826.         if err != nil {
  827.                 return err
  828.         }
  829.  
  830.         current_cruisers_mutex.Lock()
  831.         current_all_cruisers[addr] = &conn
  832.         current_cruisers_mutex.Unlock()
  833.  
  834.         nonce, err := RandomUint64()
  835.         if err != nil {
  836.                 conn.Close()
  837.                 return err
  838.         }
  839.         msgVersion := NewMsgVersionFromConn(conn, nonce, 0, SFNodeNetwork|SFNodeWitness)
  840.         if err := WriteMessage(conn, msgVersion, pver, btcnet); err != nil {
  841.                 conn.Close()
  842.                 return err
  843.         }
  844.         if err := msgVersion.AddUserAgent("Satoshi", "0.20.1"); err != nil {
  845.                 conn.Close()
  846.                 return err
  847.         }
  848.  
  849.         msg, _, err := ReadMessage(conn, pver, btcnet)
  850.         if err != nil {
  851.                 conn.Close()
  852.                 return err
  853.         }
  854.         vmsg, ok := msg.(*MsgVersion)
  855.         if !ok {
  856.                 conn.Close()
  857.                 return fmt.Errorf("Cannot make msg version")
  858.         }
  859.  
  860.         if uint32(vmsg.ProtocolVersion) < pver {
  861.                 pver = uint32(vmsg.ProtocolVersion)
  862.         }
  863.  
  864.         if err := WriteMessage(conn, NewMsgVerAck(), pver, btcnet); err != nil {
  865.                 conn.Close()
  866.                 return err
  867.         }
  868.  
  869.         getAddr := &MsgGetAddr{}
  870.  
  871.         if err := WriteMessage(conn, getAddr, pver, btcnet); err != nil {
  872.                 conn.Close()
  873.                 return err
  874.         }
  875.  
  876.         for has_cruiser(addr) {
  877.                 msg, _, err := ReadMessage(conn, pver, btcnet)
  878.                 if err != nil {
  879.                         conn.Close()
  880.                         return err
  881.                 }
  882.  
  883.                 if !has_cruiser(addr) {
  884.                         return nil
  885.                 }
  886.  
  887.                 switch tmsg := msg.(type) {
  888.                 case *MsgAddr:
  889.  
  890.                         for _, address := range tmsg.AddrList {
  891.                                 fmt.Printf("Node address received: %s %d\n", address.IP, address.Port)
  892.  
  893.                                 if isIpV6(address.IP.String()) {
  894.                                         go cruise(fmt.Sprintf("[%s]:%d", address.IP.String(), address.Port))
  895.                                 } else {
  896.                                         go cruise(fmt.Sprintf("%s:%d", address.IP.String(), address.Port))
  897.                                 }
  898.                         }
  899.  
  900.                         getAddr := &MsgGetAddr{}
  901.  
  902.                         if err := WriteMessage(conn, getAddr, pver, btcnet); err != nil {
  903.                                 conn.Close()
  904.                                 return err
  905.                         }
  906.                 }
  907.         }
  908.         return nil
  909. }
  910.  
  911. const downloader_start_height = 481824
  912.  
  913. var data_downloader_mutex sync.Mutex
  914. var data_downloader_active bool
  915. var data_download_height uint64
  916.  
  917. func data_downloader(conn *net.Conn, pver uint32, btcnet BitcoinNet) {
  918.  
  919.         data_downloader_mutex.Lock()
  920.  
  921.         if data_downloader_active {
  922.                 data_downloader_mutex.Unlock()
  923.                 return
  924.         }
  925.  
  926.         data_downloader_active = true
  927.         data_download_height = downloader_start_height
  928.         data_downloader_mutex.Unlock()
  929.  
  930.         firstBlock := myGet(downloader_start_height)
  931.  
  932.         newData := NewMsgGetData()
  933.  
  934.         newData.AddInvVect(NewInvVect(InvTypeBlock, firstBlock))
  935.  
  936.         if err := WriteMessage(*conn, newData, pver, btcnet); err != nil {
  937.                 log.Fatal(err)
  938.         }
  939.  
  940. }
  941.  
  942. func downloader_height(hash *Hash) int64 {
  943.  
  944.         data_downloader_mutex.Lock()
  945.         var near = data_download_height - 1
  946.         data_downloader_mutex.Unlock()
  947.  
  948.         for i := near; i < near+3; i++ {
  949.                 block := myGet(i)
  950.  
  951.                 if *block == *hash {
  952.                         return int64(i) + 1
  953.                 }
  954.         }
  955.         return -1
  956. }
  957.  
  958. func continue_downloader(conn *net.Conn, pver uint32, btcnet BitcoinNet) bool {
  959.         data_downloader_mutex.Lock()
  960.         data_download_height++
  961.         var height = data_download_height
  962.         data_downloader_mutex.Unlock()
  963.  
  964.         firstBlock := myGet(height)
  965.  
  966.         if firstBlock == nil {
  967.                 return false
  968.         }
  969.  
  970.         newData := NewMsgGetData()
  971.  
  972.         newData.AddInvVect(NewInvVect(InvTypeBlock, firstBlock))
  973.  
  974.         if err := WriteMessage(*conn, newData, pver, btcnet); err != nil {
  975.                 log.Fatal(err)
  976.         }
  977.         return true
  978.  
  979. }
  980.  
  981. type MessageError struct {
  982.         Func        string
  983.         Description string
  984. }
  985.  
  986. func (e *MessageError) Error() string {
  987.         if e.Func != "" {
  988.                 return fmt.Sprintf("%v: %v", e.Func, e.Description)
  989.         }
  990.         return e.Description
  991. }
  992.  
  993. func messageError(f string, desc string) *MessageError {
  994.         return &MessageError{Func: f, Description: desc}
  995. }
  996.  
  997. func HashB(b []byte) []byte {
  998.         hash := sha256.Sum256(b)
  999.         return hash[:]
  1000. }
  1001.  
  1002. func HashH(b []byte) Hash {
  1003.         return Hash(sha256.Sum256(b))
  1004. }
  1005.  
  1006. func DoubleHashB(b []byte) []byte {
  1007.         first := sha256.Sum256(b)
  1008.         second := sha256.Sum256(first[:])
  1009.         return second[:]
  1010. }
  1011.  
  1012. func DoubleHashH(b []byte) Hash {
  1013.         first := sha256.Sum256(b)
  1014.         return Hash(sha256.Sum256(first[:]))
  1015. }
  1016.  
  1017. const HashSize = 32
  1018.  
  1019. const MaxHashStringSize = HashSize * 2
  1020.  
  1021. var ErrHashStrSize = fmt.Errorf("max hash string length is %v bytes", MaxHashStringSize)
  1022.  
  1023. type Hash [HashSize]byte
  1024.  
  1025. func (hash Hash) String() string {
  1026.         for i := 0; i < HashSize/2; i++ {
  1027.                 hash[i], hash[HashSize-1-i] = hash[HashSize-1-i], hash[i]
  1028.         }
  1029.         return hex.EncodeToString(hash[:])
  1030. }
  1031.  
  1032. func (hash *Hash) CloneBytes() []byte {
  1033.         newHash := make([]byte, HashSize)
  1034.         copy(newHash, hash[:])
  1035.  
  1036.         return newHash
  1037. }
  1038.  
  1039. func (hash *Hash) SetBytes(newHash []byte) error {
  1040.         nhlen := len(newHash)
  1041.         if nhlen != HashSize {
  1042.                 return fmt.Errorf("invalid hash length of %v, want %v", nhlen,
  1043.                         HashSize)
  1044.         }
  1045.         copy(hash[:], newHash)
  1046.  
  1047.         return nil
  1048. }
  1049.  
  1050. func (hash *Hash) IsEqual(target *Hash) bool {
  1051.         if hash == nil && target == nil {
  1052.                 return true
  1053.         }
  1054.         if hash == nil || target == nil {
  1055.                 return false
  1056.         }
  1057.         return *hash == *target
  1058. }
  1059.  
  1060. func NewHash(newHash []byte) (*Hash, error) {
  1061.         var sh Hash
  1062.         err := sh.SetBytes(newHash)
  1063.         if err != nil {
  1064.                 return nil, err
  1065.         }
  1066.         return &sh, err
  1067. }
  1068.  
  1069. func NewHashFromStr(hash string) (*Hash, error) {
  1070.         ret := new(Hash)
  1071.         err := Decode(ret, hash)
  1072.         if err != nil {
  1073.                 return nil, err
  1074.         }
  1075.         return ret, nil
  1076. }
  1077.  
  1078. func Decode(dst *Hash, src string) error {
  1079.  
  1080.         if len(src) > MaxHashStringSize {
  1081.                 return ErrHashStrSize
  1082.         }
  1083.  
  1084.         var srcBytes []byte
  1085.         if len(src)%2 == 0 {
  1086.                 srcBytes = []byte(src)
  1087.         } else {
  1088.                 srcBytes = make([]byte, 1+len(src))
  1089.                 srcBytes[0] = '0'
  1090.                 copy(srcBytes[1:], src)
  1091.         }
  1092.  
  1093.         var reversedHash Hash
  1094.         _, err := hex.Decode(reversedHash[HashSize-hex.DecodedLen(len(srcBytes)):], srcBytes)
  1095.         if err != nil {
  1096.                 return err
  1097.         }
  1098.  
  1099.         for i, b := range reversedHash[:HashSize/2] {
  1100.                 dst[i], dst[HashSize-1-i] = reversedHash[HashSize-1-i], b
  1101.         }
  1102.  
  1103.         return nil
  1104. }
  1105.  
  1106. const (
  1107.         MaxInvPerMsg = 50000
  1108.  
  1109.         maxInvVectPayload = 4 + HashSize
  1110.  
  1111.         InvWitnessFlag = 1 << 30
  1112. )
  1113.  
  1114. type InvType uint32
  1115.  
  1116. const (
  1117.         InvTypeError                InvType = 0
  1118.         InvTypeTx                   InvType = 1
  1119.         InvTypeBlock                InvType = 2
  1120.         InvTypeFilteredBlock        InvType = 3
  1121.         InvTypeWitnessBlock         InvType = InvTypeBlock | InvWitnessFlag
  1122.         InvTypeWitnessTx            InvType = InvTypeTx | InvWitnessFlag
  1123.         InvTypeFilteredWitnessBlock InvType = InvTypeFilteredBlock | InvWitnessFlag
  1124. )
  1125.  
  1126. var ivStrings = map[InvType]string{
  1127.         InvTypeError:                "ERROR",
  1128.         InvTypeTx:                   "MSG_TX",
  1129.         InvTypeBlock:                "MSG_BLOCK",
  1130.         InvTypeFilteredBlock:        "MSG_FILTERED_BLOCK",
  1131.         InvTypeWitnessBlock:         "MSG_WITNESS_BLOCK",
  1132.         InvTypeWitnessTx:            "MSG_WITNESS_TX",
  1133.         InvTypeFilteredWitnessBlock: "MSG_FILTERED_WITNESS_BLOCK",
  1134. }
  1135.  
  1136. func (invtype InvType) String() string {
  1137.         if s, ok := ivStrings[invtype]; ok {
  1138.                 return s
  1139.         }
  1140.  
  1141.         return fmt.Sprintf("Unknown InvType (%d)", uint32(invtype))
  1142. }
  1143.  
  1144. type InvVect struct {
  1145.         Type InvType
  1146.         Hash Hash
  1147. }
  1148.  
  1149. func NewInvVect(typ InvType, hash *Hash) *InvVect {
  1150.         return &InvVect{
  1151.                 Type: typ,
  1152.                 Hash: *hash,
  1153.         }
  1154. }
  1155.  
  1156. func readInvVect(r io.Reader, pver uint32, iv *InvVect) error {
  1157.         return readElements(r, &iv.Type, &iv.Hash)
  1158. }
  1159.  
  1160. func writeInvVect(w io.Writer, pver uint32, iv *InvVect) error {
  1161.         return writeElements(w, iv.Type, &iv.Hash)
  1162. }
  1163.  
  1164. func NewMsgVersionFromConn(conn net.Conn, nonce uint64,
  1165.         lastBlock int32, sf ServiceFlag) *MsgVersion {
  1166.  
  1167.         lna := NewNetAddress(conn.LocalAddr().(*net.TCPAddr), sf)
  1168.  
  1169.         rna := NewNetAddress(conn.RemoteAddr().(*net.TCPAddr), sf)
  1170.  
  1171.         return NewMsgVersion(lna, rna, nonce, lastBlock)
  1172. }
  1173.  
  1174. func main() {
  1175.  
  1176.         hashStr := "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
  1177.         locatorHash, err := NewHashFromStr(hashStr)
  1178.         if err != nil {
  1179.                 log.Printf("NewShaHashFromStr: %v", err)
  1180.         }
  1181.         myPut(locatorHash, 0)
  1182.  
  1183.         var cru = []string{
  1184.                 "bitcoin.vable.ch:8333", "testrestful.net:8333", "8an.z.praha12.net:8333", "greentheatre.kiev.ua:8333",
  1185.  
  1186.                 "seed.bitcoin.sipa.be:8333",
  1187.                 "dnsseed.bluematt.me:8333",
  1188.                 "dnsseed.bitcoin.dashjr.org:8333",
  1189.                 "seed.bitcoinstats.com:8333",
  1190.                 "seed.bitcoin.jonasschnelli.ch:8333",
  1191.                 "seed.btc.petertodd.org:8333",
  1192.         }
  1193.  
  1194.         start_cruises(cru)
  1195.  
  1196.         for cruiser_pending_extra_address() {
  1197.                 time.Sleep(1 * time.Second)
  1198.         }
  1199.  
  1200.         end_cruises(cru)
  1201.  
  1202.         pver := ProtocolVersion
  1203.         btcnet := MainNet
  1204.         var conn net.Conn
  1205.         connect, addr := cruised_conn()
  1206.         if connect == nil {
  1207.                 var addr string
  1208.                 for {
  1209.                         var err error
  1210.  
  1211.                         addr = cruised_address()
  1212.  
  1213.                         log.Printf("Connecting to %s\n", addr)
  1214.                         conn, err = net.DialTimeout("tcp", addr, 3*time.Second)
  1215.                         if err != nil {
  1216.                                 log.Print(err)
  1217.                                 continue
  1218.                         }
  1219.  
  1220.                 }
  1221.  
  1222.                 defer conn.Close()
  1223.                 log.Printf("Connected to %s\n", addr)
  1224.  
  1225.                 nonce, err := RandomUint64()
  1226.                 if err != nil {
  1227.                         log.Fatal(err)
  1228.                 }
  1229.                 msgVersion := NewMsgVersionFromConn(conn, nonce, 0, SFNodeNetwork|SFNodeWitness)
  1230.                 if err := WriteMessage(conn, msgVersion, pver, btcnet); err != nil {
  1231.                         log.Fatal(err)
  1232.                 }
  1233.                 if err := msgVersion.AddUserAgent("Satoshi", "0.20.1"); err != nil {
  1234.                         log.Fatal(err)
  1235.                 }
  1236.                 log.Printf("Version message sent to %s\n", addr)
  1237.  
  1238.                 msg, _, err := ReadMessage(conn, pver, btcnet)
  1239.                 if err != nil {
  1240.                         log.Fatal(err)
  1241.                 }
  1242.                 vmsg, ok := msg.(*MsgVersion)
  1243.                 if !ok {
  1244.                         log.Fatalf("Did not receive version message: %T", vmsg)
  1245.                         return
  1246.                 }
  1247.  
  1248.                 if uint32(vmsg.ProtocolVersion) < pver {
  1249.                         pver = uint32(vmsg.ProtocolVersion)
  1250.                 }
  1251.                 log.Printf("Version response received from %s\n", addr)
  1252.  
  1253.                 if err := WriteMessage(conn, NewMsgVerAck(), pver, btcnet); err != nil {
  1254.                         log.Fatal(err)
  1255.                 }
  1256.         } else {
  1257.  
  1258.                 log.Printf("Ending other cruisers than %s\n", addr)
  1259.                 end_other_cruiser_conn(connect)
  1260.                 log.Printf("Retaining connection %s\n", addr)
  1261.                 conn = *connect
  1262.  
  1263.                 nonce, err := RandomUint64()
  1264.                 if err != nil {
  1265.                         log.Fatal("RandomUint64: Error generating nonce: %v", err)
  1266.                 }
  1267.                 pingMsg := NewMsgPing(nonce)
  1268.                 if err := WriteMessage(conn, pingMsg, pver, btcnet); err != nil {
  1269.                         log.Fatal(err)
  1270.                 }
  1271.  
  1272.                 newHdrs := NewMsgGetHeaders()
  1273.  
  1274.                 newHdrs.ProtocolVersion = pver
  1275.                 newHdrs.AddBlockLocatorHash(locatorHash)
  1276.  
  1277.                 if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1278.                         log.Fatal(err)
  1279.                 }
  1280.         }
  1281.  
  1282.         SetupCloseHandler(&conn)
  1283.  
  1284.         var commits_db *os.File
  1285.         var commits_db_checksum [32]byte
  1286.         var headerSyncOver bool
  1287.  
  1288.         bar := Bar{Graph: "#", Unit: "headers"}
  1289.  
  1290.         var total_coins uint64
  1291.         var obviously_claimed_coins uint64
  1292.  
  1293.         for {
  1294.                 msg, _, err := ReadMessage(conn, pver, btcnet)
  1295.                 if err != nil {
  1296.                         bar.Hide()
  1297.                         log.Printf("Failed to read message: %v", err)
  1298.                         bar.Finish()
  1299.                         if headerSyncOver {
  1300.                                 commits_db.Write(commits_db_checksum[0:32])
  1301.                                 commits_db.Close()
  1302.                         }
  1303.                         break
  1304.                 }
  1305.  
  1306.                 switch tmsg := msg.(type) {
  1307.                 case *MsgInv:
  1308.  
  1309.                         var is_new_block = false
  1310.  
  1311.                         for _, inv := range tmsg.InvList {
  1312.                                 if inv.Type == InvTypeBlock {
  1313.  
  1314.                                         if !myHas(&inv.Hash) {
  1315.  
  1316.                                                 is_new_block = true
  1317.  
  1318.                                         }
  1319.  
  1320.                                 }
  1321.                         }
  1322.  
  1323.                         if is_new_block && headerSyncOver {
  1324.  
  1325.                                 newHdrs := NewMsgGetHeaders()
  1326.  
  1327.                                 newHdrs.ProtocolVersion = pver
  1328.  
  1329.                                 myLocator(10, 6, func(id uint64, hash *Hash) {
  1330.                                         newHdrs.AddBlockLocatorHash(hash)
  1331.                                 })
  1332.  
  1333.                                 if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1334.                                         log.Fatal(err)
  1335.                                 }
  1336.  
  1337.                         }
  1338.  
  1339.                         continue
  1340.                 case *MsgPing:
  1341.                         bar.Hide()
  1342.                         log.Printf("ping received from %s\n", addr)
  1343.                         bar.Replay()
  1344.  
  1345.                         if err := WriteMessage(conn, NewMsgPong(tmsg.Nonce), pver, btcnet); err != nil {
  1346.                                 log.Fatal(err)
  1347.                         }
  1348.                 case *MsgHeaders:
  1349.  
  1350.                         var oldStatus = myStatus(func(tot uint64, hsh *Hash) {
  1351.                                 bar.Hide()
  1352.                                 log.Printf("top header %d %s\n", tot, *hsh)
  1353.                                 bar.Replay()
  1354.                         })
  1355.  
  1356.                         for _, hdr := range tmsg.Headers {
  1357.  
  1358.                                 myAttach(hdr, func(ra, rb *Hash) {
  1359.                                         bar.Hide()
  1360.                                         log.Println("Reorg %s %s\n", *ra, *rb)
  1361.                                         bar.Replay()
  1362.                                 })
  1363.  
  1364.                         }
  1365.  
  1366.                         if oldStatus != myStatus(func(tot uint64, hsh *Hash) {
  1367.                                 bar.Hide()
  1368.                                 log.Printf("tip header %d %s\n", tot, *hsh)
  1369.  
  1370.                                 if headerSyncOver {
  1371.  
  1372.                                         bar.Replay()
  1373.  
  1374.                                 } else {
  1375.  
  1376.                                         bar.Play(0, int64(tot), myTotalBlocksEstimate())
  1377.  
  1378.                                 }
  1379.                         }) {
  1380.  
  1381.                                 newHdrs := NewMsgGetHeaders()
  1382.  
  1383.                                 newHdrs.ProtocolVersion = pver
  1384.  
  1385.                                 myLocator(10, 0, func(id uint64, hash *Hash) {
  1386.                                         newHdrs.AddBlockLocatorHash(hash)
  1387.                                 })
  1388.  
  1389.                                 if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1390.                                         log.Fatal(err)
  1391.                                 }
  1392.                         } else {
  1393.  
  1394.                                 if !headerSyncOver {
  1395.                                         headerSyncOver = true
  1396.                                         data_downloader(&conn, pver, btcnet)
  1397.  
  1398.                                         bar.Restart("blocks")
  1399.  
  1400.                                         var err8 error
  1401.  
  1402.                                         commits_db, err = os.Create("commits.db")
  1403.                                         if err8 != nil {
  1404.                                                 log.Fatal(err8)
  1405.                                         }
  1406.                                 }
  1407.                         }
  1408.                 case *MsgVerAck:
  1409.                         bar.Hide()
  1410.                         log.Printf("Version ack received from %s\n", addr)
  1411.                         bar.Replay()
  1412.  
  1413.                         newHdrs := NewMsgGetHeaders()
  1414.  
  1415.                         newHdrs.ProtocolVersion = pver
  1416.                         newHdrs.AddBlockLocatorHash(locatorHash)
  1417.  
  1418.                         if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1419.                                 log.Fatal(err)
  1420.                         }
  1421.  
  1422.                         continue
  1423.  
  1424.                 case *MsgAddr:
  1425.  
  1426.                         for _, address := range tmsg.AddrList {
  1427.                                 bar.Hide()
  1428.                                 log.Printf("Node address received: %s %d\n", address.IP, address.Port)
  1429.                                 bar.Replay()
  1430.                         }
  1431.  
  1432.                 case *MsgBlock:
  1433.  
  1434.                         var height = downloader_height(&tmsg.Header.PrevBlock)
  1435.  
  1436.                         var combbase = true
  1437.  
  1438.                         if height >= 0 {
  1439.  
  1440.                                 var blkHash = tmsg.Header.BlockHash()
  1441.                                 if !myHas(&blkHash) {
  1442.                                         bar.Hide()
  1443.                                         log.Fatalf("Received block %s on height %d not in chain\n", blkHash, height)
  1444.                                 }
  1445.  
  1446.                                 var merkle []Hash
  1447.  
  1448.                                 var q = 0
  1449.  
  1450.                                 for i, tx := range tmsg.Transactions {
  1451.  
  1452.                                         var hash = tx.TxHash()
  1453.                                         merkle = append(merkle, hash)
  1454.  
  1455.                                         for j, txout := range tx.TxOut {
  1456.  
  1457.                                                 if len(txout.PkScript) == 34 {
  1458.                                                         if txout.PkScript[0] == 0 && txout.PkScript[1] == 0x20 {
  1459.  
  1460.                                                                 var buf [32]byte
  1461.                                                                 var buf2 [8]byte
  1462.                                                                 copy(buf[0:32], txout.PkScript[2:])
  1463.  
  1464.                                                                 if is_previously_unseen_make_seen(&buf) {
  1465.  
  1466.                                                                         if combbase {
  1467.                                                                                 combbase = false
  1468.                                                                                 var log = math.Log2(float64(height))
  1469.                                                                                 log = log * log * log * log * log * log
  1470.                                                                                 var combbase_value = 210000000 - uint64(log)
  1471.                                                                                 total_coins += combbase_value
  1472.  
  1473.                                                                                 if height >= 601002 && (txout.Value == 546 || txout.Value == 330) {
  1474.                                                                                         obviously_claimed_coins += combbase_value
  1475.                                                                                 }
  1476.  
  1477.                                                                         }
  1478.  
  1479.                                                                         if height >= 620000 {
  1480.  
  1481.                                                                                 BCDFromUint(uint64(height), buf2[0:4])
  1482.                                                                                 BCDFromUint(uint64(q), buf2[4:8])
  1483.                                                                                 bar.Hide()
  1484.                                                                                 log.Printf("%X %08d %08d %d", buf, height, q, txout.Value)
  1485.                                                                                 bar.Replay()
  1486.                                                                         } else {
  1487.  
  1488.                                                                                 BCDFromUint(uint64(height), buf2[0:4])
  1489.                                                                                 BCDFromUint(uint64(i), buf2[4:6])
  1490.                                                                                 BCDFromUint(uint64(j), buf2[6:8])
  1491.                                                                                 bar.Hide()
  1492.                                                                                 log.Printf("%X %08d %04d %04d %d", buf, height, i, j, txout.Value)
  1493.                                                                                 bar.Replay()
  1494.                                                                         }
  1495.  
  1496.                                                                         commits_db.Write(buf[0:32])
  1497.                                                                         commits_db.Write(buf2[0:8])
  1498.  
  1499.                                                                         aes_checksum(&buf, &commits_db_checksum)
  1500.                                                                 }
  1501.  
  1502.                                                                 q++
  1503.  
  1504.                                                         }
  1505.                                                 }
  1506.  
  1507.                                         }
  1508.                                 }
  1509.  
  1510.                                 if merkleTree(merkle) != tmsg.Header.MerkleRoot {
  1511.  
  1512.                                         bar.Hide()
  1513.                                         log.Fatalf("Received block %d merkle root is not valid\n", height)
  1514.                                 }
  1515.  
  1516.                                 bar.Play(downloader_start_height, height, int64(myStatus(nil)))
  1517.  
  1518.                                 if headerSyncOver {
  1519.                                         if !continue_downloader(&conn, pver, btcnet) {
  1520.  
  1521.                                                 commits_db.Write(commits_db_checksum[0:32])
  1522.                                                 commits_db.Close()
  1523.                                                 bar.Hide()
  1524.                                                 log.Printf("Success! Total coins: %d.%08d, obviously claimed coins: %d.%08d\n",
  1525.                                                         total_coins/100000000, total_coins%100000000,
  1526.                                                         obviously_claimed_coins/100000000, obviously_claimed_coins%100000000)
  1527.                                                 os.Exit(0)
  1528.                                         }
  1529.                                 }
  1530.  
  1531.                         } else {
  1532.                                 bar.Hide()
  1533.                                 log.Fatalf("Received block %s not in headers chain", tmsg.Header.BlockHash())
  1534.  
  1535.                         }
  1536.  
  1537.                 default:
  1538.  
  1539.                         continue
  1540.                 }
  1541.         }
  1542. }
  1543.  
  1544. func merkleTree(merkle []Hash) Hash {
  1545.  
  1546.         if len(merkle) == 0 {
  1547.                 return Hash{}
  1548.         }
  1549.  
  1550.         if len(merkle) == 1 {
  1551.                 return merkle[0]
  1552.         }
  1553.  
  1554.         for len(merkle) > 1 {
  1555.  
  1556.                 if len(merkle)%2 != 0 {
  1557.                         merkle = append(merkle, merkle[len(merkle)-1])
  1558.                 }
  1559.  
  1560.                 var newMerkle []Hash
  1561.  
  1562.                 for i := 0; i < len(merkle)/2; i++ {
  1563.  
  1564.                         var buf [64]byte
  1565.  
  1566.                         copy(buf[0:32], merkle[2*i][0:])
  1567.                         copy(buf[32:64], merkle[2*i+1][0:])
  1568.  
  1569.                         newMerkle = append(newMerkle, DoubleHashH(buf[0:64]))
  1570.  
  1571.                 }
  1572.  
  1573.                 merkle = newMerkle
  1574.  
  1575.         }
  1576.         return merkle[0]
  1577. }
  1578.  
  1579. const MessageHeaderSize = 24
  1580.  
  1581. const CommandSize = 12
  1582.  
  1583. const MaxMessagePayload = (1024 * 1024 * 32)
  1584.  
  1585. const (
  1586.         CmdVersion      = "version"
  1587.         CmdVerAck       = "verack"
  1588.         CmdGetAddr      = "getaddr"
  1589.         CmdAddr         = "addr"
  1590.         CmdGetBlocks    = "getblocks"
  1591.         CmdInv          = "inv"
  1592.         CmdGetData      = "getdata"
  1593.         CmdNotFound     = "notfound"
  1594.         CmdBlock        = "block"
  1595.         CmdTx           = "tx"
  1596.         CmdGetHeaders   = "getheaders"
  1597.         CmdHeaders      = "headers"
  1598.         CmdPing         = "ping"
  1599.         CmdPong         = "pong"
  1600.         CmdAlert        = "alert"
  1601.         CmdMemPool      = "mempool"
  1602.         CmdFilterAdd    = "filteradd"
  1603.         CmdFilterClear  = "filterclear"
  1604.         CmdFilterLoad   = "filterload"
  1605.         CmdMerkleBlock  = "merkleblock"
  1606.         CmdReject       = "reject"
  1607.         CmdSendHeaders  = "sendheaders"
  1608.         CmdFeeFilter    = "feefilter"
  1609.         CmdGetCFilters  = "getcfilters"
  1610.         CmdGetCFHeaders = "getcfheaders"
  1611.         CmdGetCFCheckpt = "getcfcheckpt"
  1612.         CmdCFilter      = "cfilter"
  1613.         CmdCFHeaders    = "cfheaders"
  1614.         CmdCFCheckpt    = "cfcheckpt"
  1615. )
  1616.  
  1617. type MessageEncoding uint32
  1618.  
  1619. const (
  1620.         BaseEncoding MessageEncoding = 1 << iota
  1621.  
  1622.         WitnessEncoding
  1623. )
  1624.  
  1625. var LatestEncoding = WitnessEncoding
  1626.  
  1627. type Message interface {
  1628.         BtcDecode(io.Reader, uint32, MessageEncoding) error
  1629.         BtcEncode(io.Writer, uint32, MessageEncoding) error
  1630.         Command() string
  1631.         MaxPayloadLength(uint32) uint32
  1632. }
  1633.  
  1634. func makeEmptyMessage(command string) (Message, error) {
  1635.         var msg Message
  1636.         switch command {
  1637.         case CmdVersion:
  1638.                 msg = &MsgVersion{}
  1639.  
  1640.         case CmdVerAck:
  1641.                 msg = &MsgVerAck{}
  1642.  
  1643.         case CmdGetAddr:
  1644.                 msg = &MsgGetAddr{}
  1645.  
  1646.         case CmdAddr:
  1647.                 msg = &MsgAddr{}
  1648.  
  1649.         case CmdGetBlocks:
  1650.                 msg = &MsgGetBlocks{}
  1651.  
  1652.         case CmdBlock:
  1653.                 msg = &MsgBlock{}
  1654.  
  1655.         case CmdInv:
  1656.                 msg = &MsgInv{}
  1657.  
  1658.         case CmdGetData:
  1659.                 msg = &MsgGetData{}
  1660.  
  1661.         case CmdNotFound:
  1662.                 msg = &MsgNotFound{}
  1663.  
  1664.         case CmdTx:
  1665.                 msg = &MsgTx{}
  1666.  
  1667.         case CmdPing:
  1668.                 msg = &MsgPing{}
  1669.  
  1670.         case CmdPong:
  1671.                 msg = &MsgPong{}
  1672.  
  1673.         case CmdGetHeaders:
  1674.                 msg = &MsgGetHeaders{}
  1675.  
  1676.         case CmdHeaders:
  1677.                 msg = &MsgHeaders{}
  1678.  
  1679.         case CmdAlert:
  1680.                 msg = &MsgAlert{}
  1681.  
  1682.         case CmdMemPool:
  1683.                 msg = &MsgMemPool{}
  1684.  
  1685.         case CmdFilterAdd:
  1686.                 msg = &MsgFilterAdd{}
  1687.  
  1688.         case CmdFilterClear:
  1689.                 msg = &MsgFilterClear{}
  1690.  
  1691.         case CmdFilterLoad:
  1692.                 msg = &MsgFilterLoad{}
  1693.  
  1694.         case CmdMerkleBlock:
  1695.                 msg = &MsgMerkleBlock{}
  1696.  
  1697.         case CmdReject:
  1698.                 msg = &MsgReject{}
  1699.  
  1700.         case CmdSendHeaders:
  1701.                 msg = &MsgSendHeaders{}
  1702.  
  1703.         case CmdFeeFilter:
  1704.                 msg = &MsgFeeFilter{}
  1705.  
  1706.         case CmdGetCFilters:
  1707.                 msg = &MsgGetCFilters{}
  1708.  
  1709.         case CmdGetCFHeaders:
  1710.                 msg = &MsgGetCFHeaders{}
  1711.  
  1712.         case CmdGetCFCheckpt:
  1713.                 msg = &MsgGetCFCheckpt{}
  1714.  
  1715.         case CmdCFilter:
  1716.                 msg = &MsgCFilter{}
  1717.  
  1718.         case CmdCFHeaders:
  1719.                 msg = &MsgCFHeaders{}
  1720.  
  1721.         case CmdCFCheckpt:
  1722.                 msg = &MsgCFCheckpt{}
  1723.  
  1724.         default:
  1725.                 return nil, fmt.Errorf("unhandled command [%s]", command)
  1726.         }
  1727.         return msg, nil
  1728. }
  1729.  
  1730. type messageHeader struct {
  1731.         magic    BitcoinNet
  1732.         command  string
  1733.         length   uint32
  1734.         checksum [4]byte
  1735. }
  1736.  
  1737. func readMessageHeader(r io.Reader) (int, *messageHeader, error) {
  1738.  
  1739.         var headerBytes [MessageHeaderSize]byte
  1740.         n, err := io.ReadFull(r, headerBytes[:])
  1741.         if err != nil {
  1742.                 return n, nil, err
  1743.         }
  1744.         hr := bytes.NewReader(headerBytes[:])
  1745.  
  1746.         hdr := messageHeader{}
  1747.         var command [CommandSize]byte
  1748.         readElements(hr, &hdr.magic, &command, &hdr.length, &hdr.checksum)
  1749.  
  1750.         hdr.command = string(bytes.TrimRight(command[:], "\x00"))
  1751.  
  1752.         return n, &hdr, nil
  1753. }
  1754.  
  1755. func discardInput(r io.Reader, n uint32) {
  1756.         maxSize := uint32(10 * 1024)
  1757.         numReads := n / maxSize
  1758.         bytesRemaining := n % maxSize
  1759.         if n > 0 {
  1760.                 buf := make([]byte, maxSize)
  1761.                 for i := uint32(0); i < numReads; i++ {
  1762.                         io.ReadFull(r, buf)
  1763.                 }
  1764.         }
  1765.         if bytesRemaining > 0 {
  1766.                 buf := make([]byte, bytesRemaining)
  1767.                 io.ReadFull(r, buf)
  1768.         }
  1769. }
  1770.  
  1771. func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
  1772.         return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
  1773. }
  1774.  
  1775. func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
  1776.         _, err := WriteMessageN(w, msg, pver, btcnet)
  1777.         return err
  1778. }
  1779.  
  1780. func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
  1781.         btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
  1782.  
  1783.         totalBytes := 0
  1784.  
  1785.         var command [CommandSize]byte
  1786.         cmd := msg.Command()
  1787.         if len(cmd) > CommandSize {
  1788.                 str := fmt.Sprintf("command [%s] is too long [max %v]",
  1789.                         cmd, CommandSize)
  1790.                 return totalBytes, messageError("WriteMessage", str)
  1791.         }
  1792.         copy(command[:], []byte(cmd))
  1793.  
  1794.         var bw bytes.Buffer
  1795.         err := msg.BtcEncode(&bw, pver, encoding)
  1796.         if err != nil {
  1797.                 return totalBytes, err
  1798.         }
  1799.         payload := bw.Bytes()
  1800.         lenp := len(payload)
  1801.  
  1802.         if lenp > MaxMessagePayload {
  1803.                 str := fmt.Sprintf("message payload is too large - encoded "+
  1804.                         "%d bytes, but maximum message payload is %d bytes",
  1805.                         lenp, MaxMessagePayload)
  1806.                 return totalBytes, messageError("WriteMessage", str)
  1807.         }
  1808.  
  1809.         mpl := msg.MaxPayloadLength(pver)
  1810.         if uint32(lenp) > mpl {
  1811.                 str := fmt.Sprintf("message payload is too large - encoded "+
  1812.                         "%d bytes, but maximum message payload size for "+
  1813.                         "messages of type [%s] is %d.", lenp, cmd, mpl)
  1814.                 return totalBytes, messageError("WriteMessage", str)
  1815.         }
  1816.  
  1817.         hdr := messageHeader{}
  1818.         hdr.magic = btcnet
  1819.         hdr.command = cmd
  1820.         hdr.length = uint32(lenp)
  1821.         copy(hdr.checksum[:], DoubleHashB(payload)[0:4])
  1822.  
  1823.         hw := bytes.NewBuffer(make([]byte, 0, MessageHeaderSize))
  1824.         writeElements(hw, hdr.magic, command, hdr.length, hdr.checksum)
  1825.  
  1826.         n, err := w.Write(hw.Bytes())
  1827.         totalBytes += n
  1828.         if err != nil {
  1829.                 return totalBytes, err
  1830.         }
  1831.  
  1832.         if len(payload) > 0 {
  1833.                 n, err = w.Write(payload)
  1834.                 totalBytes += n
  1835.         }
  1836.  
  1837.         return totalBytes, err
  1838. }
  1839.  
  1840. func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
  1841.         enc MessageEncoding) (int, Message, []byte, error) {
  1842.  
  1843.         totalBytes := 0
  1844.         n, hdr, err := readMessageHeader(r)
  1845.         totalBytes += n
  1846.         if err != nil {
  1847.                 return totalBytes, nil, nil, err
  1848.         }
  1849.  
  1850.         if hdr.length > MaxMessagePayload {
  1851.                 str := fmt.Sprintf("message payload is too large - header "+
  1852.                         "indicates %d bytes, but max message payload is %d "+
  1853.                         "bytes.", hdr.length, MaxMessagePayload)
  1854.                 return totalBytes, nil, nil, messageError("ReadMessage", str)
  1855.  
  1856.         }
  1857.  
  1858.         if hdr.magic != btcnet {
  1859.                 discardInput(r, hdr.length)
  1860.                 str := fmt.Sprintf("message from other network [%v]", hdr.magic)
  1861.                 return totalBytes, nil, nil, messageError("ReadMessage", str)
  1862.         }
  1863.  
  1864.         command := hdr.command
  1865.         if !utf8.ValidString(command) {
  1866.                 discardInput(r, hdr.length)
  1867.                 str := fmt.Sprintf("invalid command %v", []byte(command))
  1868.                 return totalBytes, nil, nil, messageError("ReadMessage", str)
  1869.         }
  1870.  
  1871.         msg, err := makeEmptyMessage(command)
  1872.         if err != nil {
  1873.                 discardInput(r, hdr.length)
  1874.                 return totalBytes, nil, nil, messageError("ReadMessage",
  1875.                         err.Error())
  1876.         }
  1877.  
  1878.         mpl := msg.MaxPayloadLength(pver)
  1879.         if hdr.length > mpl {
  1880.                 discardInput(r, hdr.length)
  1881.                 str := fmt.Sprintf("payload exceeds max length - header "+
  1882.                         "indicates %v bytes, but max payload size for "+
  1883.                         "messages of type [%v] is %v.", hdr.length, command, mpl)
  1884.                 return totalBytes, nil, nil, messageError("ReadMessage", str)
  1885.         }
  1886.  
  1887.         payload := make([]byte, hdr.length)
  1888.         n, err = io.ReadFull(r, payload)
  1889.         totalBytes += n
  1890.         if err != nil {
  1891.                 return totalBytes, nil, nil, err
  1892.         }
  1893.  
  1894.         checksum := DoubleHashB(payload)[0:4]
  1895.         if !bytes.Equal(checksum[:], hdr.checksum[:]) {
  1896.                 str := fmt.Sprintf("payload checksum failed - header "+
  1897.                         "indicates %v, but actual checksum is %v.",
  1898.                         hdr.checksum, checksum)
  1899.                 return totalBytes, nil, nil, messageError("ReadMessage", str)
  1900.         }
  1901.  
  1902.         pr := bytes.NewBuffer(payload)
  1903.         err = msg.BtcDecode(pr, pver, enc)
  1904.         if err != nil {
  1905.                 return totalBytes, nil, nil, err
  1906.         }
  1907.  
  1908.         return totalBytes, msg, payload, nil
  1909. }
  1910.  
  1911. func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
  1912.         return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
  1913. }
  1914.  
  1915. func ReadMessage(r io.Reader, pver uint32, btcnet BitcoinNet) (Message, []byte, error) {
  1916.         _, msg, buf, err := ReadMessageN(r, pver, btcnet)
  1917.         return msg, buf, err
  1918. }
  1919.  
  1920. const MaxAddrPerMsg = 1000
  1921.  
  1922. type MsgAddr struct {
  1923.         AddrList []*NetAddress
  1924. }
  1925.  
  1926. func (msg *MsgAddr) AddAddress(na *NetAddress) error {
  1927.         if len(msg.AddrList)+1 > MaxAddrPerMsg {
  1928.                 str := fmt.Sprintf("too many addresses in message [max %v]",
  1929.                         MaxAddrPerMsg)
  1930.                 return messageError("MsgAddr.AddAddress", str)
  1931.         }
  1932.  
  1933.         msg.AddrList = append(msg.AddrList, na)
  1934.         return nil
  1935. }
  1936.  
  1937. func (msg *MsgAddr) AddAddresses(netAddrs ...*NetAddress) error {
  1938.         for _, na := range netAddrs {
  1939.                 err := msg.AddAddress(na)
  1940.                 if err != nil {
  1941.                         return err
  1942.                 }
  1943.         }
  1944.         return nil
  1945. }
  1946.  
  1947. func (msg *MsgAddr) ClearAddresses() {
  1948.         msg.AddrList = []*NetAddress{}
  1949. }
  1950.  
  1951. func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  1952.         count, err := ReadVarInt(r, pver)
  1953.         if err != nil {
  1954.                 return err
  1955.         }
  1956.  
  1957.         if count > MaxAddrPerMsg {
  1958.                 str := fmt.Sprintf("too many addresses for message "+
  1959.                         "[count %v, max %v]", count, MaxAddrPerMsg)
  1960.                 return messageError("MsgAddr.BtcDecode", str)
  1961.         }
  1962.  
  1963.         addrList := make([]NetAddress, count)
  1964.         msg.AddrList = make([]*NetAddress, 0, count)
  1965.         for i := uint64(0); i < count; i++ {
  1966.                 na := &addrList[i]
  1967.                 err := readNetAddress(r, pver, na, true)
  1968.                 if err != nil {
  1969.                         return err
  1970.                 }
  1971.                 msg.AddAddress(na)
  1972.         }
  1973.         return nil
  1974. }
  1975.  
  1976. func (msg *MsgAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  1977.  
  1978.         count := len(msg.AddrList)
  1979.         if pver < MultipleAddressVersion && count > 1 {
  1980.                 str := fmt.Sprintf("too many addresses for message of "+
  1981.                         "protocol version %v [count %v, max 1]", pver, count)
  1982.                 return messageError("MsgAddr.BtcEncode", str)
  1983.  
  1984.         }
  1985.         if count > MaxAddrPerMsg {
  1986.                 str := fmt.Sprintf("too many addresses for message "+
  1987.                         "[count %v, max %v]", count, MaxAddrPerMsg)
  1988.                 return messageError("MsgAddr.BtcEncode", str)
  1989.         }
  1990.  
  1991.         err := WriteVarInt(w, pver, uint64(count))
  1992.         if err != nil {
  1993.                 return err
  1994.         }
  1995.  
  1996.         for _, na := range msg.AddrList {
  1997.                 err = writeNetAddress(w, pver, na, true)
  1998.                 if err != nil {
  1999.                         return err
  2000.                 }
  2001.         }
  2002.  
  2003.         return nil
  2004. }
  2005.  
  2006. func (msg *MsgAddr) Command() string {
  2007.         return CmdAddr
  2008. }
  2009.  
  2010. func (msg *MsgAddr) MaxPayloadLength(pver uint32) uint32 {
  2011.         if pver < MultipleAddressVersion {
  2012.  
  2013.                 return MaxVarIntPayload + maxNetAddressPayload(pver)
  2014.         }
  2015.  
  2016.         return MaxVarIntPayload + (MaxAddrPerMsg * maxNetAddressPayload(pver))
  2017. }
  2018.  
  2019. func NewMsgAddr() *MsgAddr {
  2020.         return &MsgAddr{
  2021.                 AddrList: make([]*NetAddress, 0, MaxAddrPerMsg),
  2022.         }
  2023. }
  2024.  
  2025. const fixedAlertSize = 45
  2026.  
  2027. const maxSignatureSize = 72
  2028.  
  2029. const maxAlertSize = MaxMessagePayload - maxSignatureSize - MaxVarIntPayload - 1
  2030.  
  2031. const maxCountSetCancel = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 4
  2032.  
  2033. const maxCountSetSubVer = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 256
  2034.  
  2035. type Alert struct {
  2036.         Version int32
  2037.  
  2038.         RelayUntil int64
  2039.  
  2040.         Expiration int64
  2041.  
  2042.         ID int32
  2043.  
  2044.         Cancel int32
  2045.  
  2046.         SetCancel []int32
  2047.  
  2048.         MinVer int32
  2049.  
  2050.         MaxVer int32
  2051.  
  2052.         SetSubVer []string
  2053.  
  2054.         Priority int32
  2055.  
  2056.         Comment string
  2057.  
  2058.         StatusBar string
  2059.  
  2060.         Reserved string
  2061. }
  2062.  
  2063. func (alert *Alert) Serialize(w io.Writer, pver uint32) error {
  2064.         err := writeElements(w, alert.Version, alert.RelayUntil,
  2065.                 alert.Expiration, alert.ID, alert.Cancel)
  2066.         if err != nil {
  2067.                 return err
  2068.         }
  2069.  
  2070.         count := len(alert.SetCancel)
  2071.         if count > maxCountSetCancel {
  2072.                 str := fmt.Sprintf("too many cancel alert IDs for alert "+
  2073.                         "[count %v, max %v]", count, maxCountSetCancel)
  2074.                 return messageError("Alert.Serialize", str)
  2075.         }
  2076.         err = WriteVarInt(w, pver, uint64(count))
  2077.         if err != nil {
  2078.                 return err
  2079.         }
  2080.         for i := 0; i < count; i++ {
  2081.                 err = writeElement(w, alert.SetCancel[i])
  2082.                 if err != nil {
  2083.                         return err
  2084.                 }
  2085.         }
  2086.  
  2087.         err = writeElements(w, alert.MinVer, alert.MaxVer)
  2088.         if err != nil {
  2089.                 return err
  2090.         }
  2091.  
  2092.         count = len(alert.SetSubVer)
  2093.         if count > maxCountSetSubVer {
  2094.                 str := fmt.Sprintf("too many sub versions for alert "+
  2095.                         "[count %v, max %v]", count, maxCountSetSubVer)
  2096.                 return messageError("Alert.Serialize", str)
  2097.         }
  2098.         err = WriteVarInt(w, pver, uint64(count))
  2099.         if err != nil {
  2100.                 return err
  2101.         }
  2102.         for i := 0; i < count; i++ {
  2103.                 err = WriteVarString(w, pver, alert.SetSubVer[i])
  2104.                 if err != nil {
  2105.                         return err
  2106.                 }
  2107.         }
  2108.  
  2109.         err = writeElement(w, alert.Priority)
  2110.         if err != nil {
  2111.                 return err
  2112.         }
  2113.         err = WriteVarString(w, pver, alert.Comment)
  2114.         if err != nil {
  2115.                 return err
  2116.         }
  2117.         err = WriteVarString(w, pver, alert.StatusBar)
  2118.         if err != nil {
  2119.                 return err
  2120.         }
  2121.         return WriteVarString(w, pver, alert.Reserved)
  2122. }
  2123.  
  2124. func (alert *Alert) Deserialize(r io.Reader, pver uint32) error {
  2125.         err := readElements(r, &alert.Version, &alert.RelayUntil,
  2126.                 &alert.Expiration, &alert.ID, &alert.Cancel)
  2127.         if err != nil {
  2128.                 return err
  2129.         }
  2130.  
  2131.         count, err := ReadVarInt(r, pver)
  2132.         if err != nil {
  2133.                 return err
  2134.         }
  2135.         if count > maxCountSetCancel {
  2136.                 str := fmt.Sprintf("too many cancel alert IDs for alert "+
  2137.                         "[count %v, max %v]", count, maxCountSetCancel)
  2138.                 return messageError("Alert.Deserialize", str)
  2139.         }
  2140.         alert.SetCancel = make([]int32, count)
  2141.         for i := 0; i < int(count); i++ {
  2142.                 err := readElement(r, &alert.SetCancel[i])
  2143.                 if err != nil {
  2144.                         return err
  2145.                 }
  2146.         }
  2147.  
  2148.         err = readElements(r, &alert.MinVer, &alert.MaxVer)
  2149.         if err != nil {
  2150.                 return err
  2151.         }
  2152.  
  2153.         count, err = ReadVarInt(r, pver)
  2154.         if err != nil {
  2155.                 return err
  2156.         }
  2157.         if count > maxCountSetSubVer {
  2158.                 str := fmt.Sprintf("too many sub versions for alert "+
  2159.                         "[count %v, max %v]", count, maxCountSetSubVer)
  2160.                 return messageError("Alert.Deserialize", str)
  2161.         }
  2162.         alert.SetSubVer = make([]string, count)
  2163.         for i := 0; i < int(count); i++ {
  2164.                 alert.SetSubVer[i], err = ReadVarString(r, pver)
  2165.                 if err != nil {
  2166.                         return err
  2167.                 }
  2168.         }
  2169.  
  2170.         err = readElement(r, &alert.Priority)
  2171.         if err != nil {
  2172.                 return err
  2173.         }
  2174.         alert.Comment, err = ReadVarString(r, pver)
  2175.         if err != nil {
  2176.                 return err
  2177.         }
  2178.         alert.StatusBar, err = ReadVarString(r, pver)
  2179.         if err != nil {
  2180.                 return err
  2181.         }
  2182.         alert.Reserved, err = ReadVarString(r, pver)
  2183.         return err
  2184. }
  2185.  
  2186. func NewAlert(version int32, relayUntil int64, expiration int64,
  2187.         id int32, cancel int32, setCancel []int32, minVer int32,
  2188.         maxVer int32, setSubVer []string, priority int32, comment string,
  2189.         statusBar string) *Alert {
  2190.         return &Alert{
  2191.                 Version:    version,
  2192.                 RelayUntil: relayUntil,
  2193.                 Expiration: expiration,
  2194.                 ID:         id,
  2195.                 Cancel:     cancel,
  2196.                 SetCancel:  setCancel,
  2197.                 MinVer:     minVer,
  2198.                 MaxVer:     maxVer,
  2199.                 SetSubVer:  setSubVer,
  2200.                 Priority:   priority,
  2201.                 Comment:    comment,
  2202.                 StatusBar:  statusBar,
  2203.                 Reserved:   "",
  2204.         }
  2205. }
  2206.  
  2207. func NewAlertFromPayload(serializedPayload []byte, pver uint32) (*Alert, error) {
  2208.         var alert Alert
  2209.         r := bytes.NewReader(serializedPayload)
  2210.         err := alert.Deserialize(r, pver)
  2211.         if err != nil {
  2212.                 return nil, err
  2213.         }
  2214.         return &alert, nil
  2215. }
  2216.  
  2217. type MsgAlert struct {
  2218.         SerializedPayload []byte
  2219.  
  2220.         Signature []byte
  2221.  
  2222.         Payload *Alert
  2223. }
  2224.  
  2225. func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2226.         var err error
  2227.  
  2228.         msg.SerializedPayload, err = ReadVarBytes(r, pver, MaxMessagePayload,
  2229.                 "alert serialized payload")
  2230.         if err != nil {
  2231.                 return err
  2232.         }
  2233.  
  2234.         msg.Payload, err = NewAlertFromPayload(msg.SerializedPayload, pver)
  2235.         if err != nil {
  2236.                 msg.Payload = nil
  2237.         }
  2238.  
  2239.         msg.Signature, err = ReadVarBytes(r, pver, MaxMessagePayload,
  2240.                 "alert signature")
  2241.         return err
  2242. }
  2243.  
  2244. func (msg *MsgAlert) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2245.         var err error
  2246.         var serializedpayload []byte
  2247.         if msg.Payload != nil {
  2248.  
  2249.                 r := new(bytes.Buffer)
  2250.                 err = msg.Payload.Serialize(r, pver)
  2251.                 if err != nil {
  2252.  
  2253.                         serializedpayload = msg.SerializedPayload
  2254.                 } else {
  2255.                         serializedpayload = r.Bytes()
  2256.                 }
  2257.         } else {
  2258.                 serializedpayload = msg.SerializedPayload
  2259.         }
  2260.         slen := uint64(len(serializedpayload))
  2261.         if slen == 0 {
  2262.                 return messageError("MsgAlert.BtcEncode", "empty serialized payload")
  2263.         }
  2264.         err = WriteVarBytes(w, pver, serializedpayload)
  2265.         if err != nil {
  2266.                 return err
  2267.         }
  2268.         return WriteVarBytes(w, pver, msg.Signature)
  2269. }
  2270.  
  2271. func (msg *MsgAlert) Command() string {
  2272.         return CmdAlert
  2273. }
  2274.  
  2275. func (msg *MsgAlert) MaxPayloadLength(pver uint32) uint32 {
  2276.  
  2277.         return MaxMessagePayload
  2278. }
  2279.  
  2280. func NewMsgAlert(serializedPayload []byte, signature []byte) *MsgAlert {
  2281.         return &MsgAlert{
  2282.                 SerializedPayload: serializedPayload,
  2283.                 Signature:         signature,
  2284.                 Payload:           nil,
  2285.         }
  2286. }
  2287.  
  2288. const defaultTransactionAlloc = 2048
  2289.  
  2290. const MaxBlocksPerMsg = 500
  2291.  
  2292. const MaxBlockPayload = 4000000
  2293.  
  2294. const maxTxPerBlock = (MaxBlockPayload / minTxPayload) + 1
  2295.  
  2296. type TxLoc struct {
  2297.         TxStart int
  2298.         TxLen   int
  2299. }
  2300.  
  2301. type MsgBlock struct {
  2302.         Header       BlockHeader
  2303.         Transactions []*MsgTx
  2304. }
  2305.  
  2306. func (msg *MsgBlock) AddTransaction(tx *MsgTx) error {
  2307.         msg.Transactions = append(msg.Transactions, tx)
  2308.         return nil
  2309.  
  2310. }
  2311.  
  2312. func (msg *MsgBlock) ClearTransactions() {
  2313.         msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
  2314. }
  2315.  
  2316. func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2317.         err := readBlockHeader(r, pver, &msg.Header)
  2318.         if err != nil {
  2319.                 return err
  2320.         }
  2321.  
  2322.         txCount, err := ReadVarInt(r, pver)
  2323.         if err != nil {
  2324.                 return err
  2325.         }
  2326.  
  2327.         if txCount > maxTxPerBlock {
  2328.                 str := fmt.Sprintf("too many transactions to fit into a block "+
  2329.                         "[count %d, max %d]", txCount, maxTxPerBlock)
  2330.                 return messageError("MsgBlock.BtcDecode", str)
  2331.         }
  2332.  
  2333.         msg.Transactions = make([]*MsgTx, 0, txCount)
  2334.         for i := uint64(0); i < txCount; i++ {
  2335.                 tx := MsgTx{}
  2336.                 err := tx.BtcDecode(r, pver, enc)
  2337.                 if err != nil {
  2338.                         return err
  2339.                 }
  2340.                 msg.Transactions = append(msg.Transactions, &tx)
  2341.         }
  2342.  
  2343.         return nil
  2344. }
  2345.  
  2346. func (msg *MsgBlock) Deserialize(r io.Reader) error {
  2347.  
  2348.         return msg.BtcDecode(r, 0, WitnessEncoding)
  2349. }
  2350.  
  2351. func (msg *MsgBlock) DeserializeNoWitness(r io.Reader) error {
  2352.         return msg.BtcDecode(r, 0, BaseEncoding)
  2353. }
  2354.  
  2355. func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
  2356.         fullLen := r.Len()
  2357.  
  2358.         err := readBlockHeader(r, 0, &msg.Header)
  2359.         if err != nil {
  2360.                 return nil, err
  2361.         }
  2362.  
  2363.         txCount, err := ReadVarInt(r, 0)
  2364.         if err != nil {
  2365.                 return nil, err
  2366.         }
  2367.  
  2368.         if txCount > maxTxPerBlock {
  2369.                 str := fmt.Sprintf("too many transactions to fit into a block "+
  2370.                         "[count %d, max %d]", txCount, maxTxPerBlock)
  2371.                 return nil, messageError("MsgBlock.DeserializeTxLoc", str)
  2372.         }
  2373.  
  2374.         msg.Transactions = make([]*MsgTx, 0, txCount)
  2375.         txLocs := make([]TxLoc, txCount)
  2376.         for i := uint64(0); i < txCount; i++ {
  2377.                 txLocs[i].TxStart = fullLen - r.Len()
  2378.                 tx := MsgTx{}
  2379.                 err := tx.Deserialize(r)
  2380.                 if err != nil {
  2381.                         return nil, err
  2382.                 }
  2383.                 msg.Transactions = append(msg.Transactions, &tx)
  2384.                 txLocs[i].TxLen = (fullLen - r.Len()) - txLocs[i].TxStart
  2385.         }
  2386.  
  2387.         return txLocs, nil
  2388. }
  2389.  
  2390. func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2391.         err := writeBlockHeader(w, pver, &msg.Header)
  2392.         if err != nil {
  2393.                 return err
  2394.         }
  2395.  
  2396.         err = WriteVarInt(w, pver, uint64(len(msg.Transactions)))
  2397.         if err != nil {
  2398.                 return err
  2399.         }
  2400.  
  2401.         for _, tx := range msg.Transactions {
  2402.                 err = tx.BtcEncode(w, pver, enc)
  2403.                 if err != nil {
  2404.                         return err
  2405.                 }
  2406.         }
  2407.  
  2408.         return nil
  2409. }
  2410.  
  2411. func (msg *MsgBlock) Serialize(w io.Writer) error {
  2412.  
  2413.         return msg.BtcEncode(w, 0, WitnessEncoding)
  2414. }
  2415.  
  2416. func (msg *MsgBlock) SerializeNoWitness(w io.Writer) error {
  2417.         return msg.BtcEncode(w, 0, BaseEncoding)
  2418. }
  2419.  
  2420. func (msg *MsgBlock) SerializeSize() int {
  2421.  
  2422.         n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
  2423.  
  2424.         for _, tx := range msg.Transactions {
  2425.                 n += tx.SerializeSize()
  2426.         }
  2427.  
  2428.         return n
  2429. }
  2430.  
  2431. func (msg *MsgBlock) SerializeSizeStripped() int {
  2432.  
  2433.         n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
  2434.  
  2435.         for _, tx := range msg.Transactions {
  2436.                 n += tx.SerializeSizeStripped()
  2437.         }
  2438.  
  2439.         return n
  2440. }
  2441.  
  2442. func (msg *MsgBlock) Command() string {
  2443.         return CmdBlock
  2444. }
  2445.  
  2446. func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
  2447.  
  2448.         return MaxBlockPayload
  2449. }
  2450.  
  2451. func (msg *MsgBlock) BlockHash() Hash {
  2452.         return msg.Header.BlockHash()
  2453. }
  2454.  
  2455. func (msg *MsgBlock) TxHashes() ([]Hash, error) {
  2456.         hashList := make([]Hash, 0, len(msg.Transactions))
  2457.         for _, tx := range msg.Transactions {
  2458.                 hashList = append(hashList, tx.TxHash())
  2459.         }
  2460.         return hashList, nil
  2461. }
  2462.  
  2463. func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
  2464.         return &MsgBlock{
  2465.                 Header:       *blockHeader,
  2466.                 Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),
  2467.         }
  2468. }
  2469.  
  2470. const (
  2471.         CFCheckptInterval = 1000
  2472.  
  2473.         maxCFHeadersLen = 100000
  2474. )
  2475.  
  2476. var ErrInsaneCFHeaderCount = errors.New(
  2477.         "refusing to decode unreasonable number of filter headers")
  2478.  
  2479. type MsgCFCheckpt struct {
  2480.         FilterType    FilterType
  2481.         StopHash      Hash
  2482.         FilterHeaders []*Hash
  2483. }
  2484.  
  2485. func (msg *MsgCFCheckpt) AddCFHeader(header *Hash) error {
  2486.         if len(msg.FilterHeaders) == cap(msg.FilterHeaders) {
  2487.                 str := fmt.Sprintf("FilterHeaders has insufficient capacity for "+
  2488.                         "additional header: len = %d", len(msg.FilterHeaders))
  2489.                 return messageError("MsgCFCheckpt.AddCFHeader", str)
  2490.         }
  2491.  
  2492.         msg.FilterHeaders = append(msg.FilterHeaders, header)
  2493.         return nil
  2494. }
  2495.  
  2496. func (msg *MsgCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2497.  
  2498.         err := readElement(r, &msg.FilterType)
  2499.         if err != nil {
  2500.                 return err
  2501.         }
  2502.  
  2503.         err = readElement(r, &msg.StopHash)
  2504.         if err != nil {
  2505.                 return err
  2506.         }
  2507.  
  2508.         count, err := ReadVarInt(r, pver)
  2509.         if err != nil {
  2510.                 return err
  2511.         }
  2512.  
  2513.         if count > maxCFHeadersLen {
  2514.                 return ErrInsaneCFHeaderCount
  2515.         }
  2516.  
  2517.         msg.FilterHeaders = make([]*Hash, count)
  2518.         for i := uint64(0); i < count; i++ {
  2519.                 var cfh Hash
  2520.                 err := readElement(r, &cfh)
  2521.                 if err != nil {
  2522.                         return err
  2523.                 }
  2524.                 msg.FilterHeaders[i] = &cfh
  2525.         }
  2526.  
  2527.         return nil
  2528. }
  2529.  
  2530. func (msg *MsgCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2531.  
  2532.         err := writeElement(w, msg.FilterType)
  2533.         if err != nil {
  2534.                 return err
  2535.         }
  2536.  
  2537.         err = writeElement(w, msg.StopHash)
  2538.         if err != nil {
  2539.                 return err
  2540.         }
  2541.  
  2542.         count := len(msg.FilterHeaders)
  2543.         err = WriteVarInt(w, pver, uint64(count))
  2544.         if err != nil {
  2545.                 return err
  2546.         }
  2547.  
  2548.         for _, cfh := range msg.FilterHeaders {
  2549.                 err := writeElement(w, cfh)
  2550.                 if err != nil {
  2551.                         return err
  2552.                 }
  2553.         }
  2554.  
  2555.         return nil
  2556. }
  2557.  
  2558. func (msg *MsgCFCheckpt) Deserialize(r io.Reader) error {
  2559.  
  2560.         return msg.BtcDecode(r, 0, BaseEncoding)
  2561. }
  2562.  
  2563. func (msg *MsgCFCheckpt) Command() string {
  2564.         return CmdCFCheckpt
  2565. }
  2566.  
  2567. func (msg *MsgCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
  2568.  
  2569.         return MaxMessagePayload
  2570. }
  2571.  
  2572. func NewMsgCFCheckpt(filterType FilterType, stopHash *Hash,
  2573.         headersCount int) *MsgCFCheckpt {
  2574.         return &MsgCFCheckpt{
  2575.                 FilterType:    filterType,
  2576.                 StopHash:      *stopHash,
  2577.                 FilterHeaders: make([]*Hash, 0, headersCount),
  2578.         }
  2579. }
  2580.  
  2581. const (
  2582.         MaxCFHeaderPayload = HashSize
  2583.  
  2584.         MaxCFHeadersPerMsg = 2000
  2585. )
  2586.  
  2587. type MsgCFHeaders struct {
  2588.         FilterType       FilterType
  2589.         StopHash         Hash
  2590.         PrevFilterHeader Hash
  2591.         FilterHashes     []*Hash
  2592. }
  2593.  
  2594. func (msg *MsgCFHeaders) AddCFHash(hash *Hash) error {
  2595.         if len(msg.FilterHashes)+1 > MaxCFHeadersPerMsg {
  2596.                 str := fmt.Sprintf("too many block headers in message [max %v]",
  2597.                         MaxBlockHeadersPerMsg)
  2598.                 return messageError("MsgCFHeaders.AddCFHash", str)
  2599.         }
  2600.  
  2601.         msg.FilterHashes = append(msg.FilterHashes, hash)
  2602.         return nil
  2603. }
  2604.  
  2605. func (msg *MsgCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2606.  
  2607.         err := readElement(r, &msg.FilterType)
  2608.         if err != nil {
  2609.                 return err
  2610.         }
  2611.  
  2612.         err = readElement(r, &msg.StopHash)
  2613.         if err != nil {
  2614.                 return err
  2615.         }
  2616.  
  2617.         err = readElement(r, &msg.PrevFilterHeader)
  2618.         if err != nil {
  2619.                 return err
  2620.         }
  2621.  
  2622.         count, err := ReadVarInt(r, pver)
  2623.         if err != nil {
  2624.                 return err
  2625.         }
  2626.  
  2627.         if count > MaxCFHeadersPerMsg {
  2628.                 str := fmt.Sprintf("too many committed filter headers for "+
  2629.                         "message [count %v, max %v]", count,
  2630.                         MaxBlockHeadersPerMsg)
  2631.                 return messageError("MsgCFHeaders.BtcDecode", str)
  2632.         }
  2633.  
  2634.         msg.FilterHashes = make([]*Hash, 0, count)
  2635.         for i := uint64(0); i < count; i++ {
  2636.                 var cfh Hash
  2637.                 err := readElement(r, &cfh)
  2638.                 if err != nil {
  2639.                         return err
  2640.                 }
  2641.                 msg.AddCFHash(&cfh)
  2642.         }
  2643.  
  2644.         return nil
  2645. }
  2646.  
  2647. func (msg *MsgCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2648.  
  2649.         err := writeElement(w, msg.FilterType)
  2650.         if err != nil {
  2651.                 return err
  2652.         }
  2653.  
  2654.         err = writeElement(w, msg.StopHash)
  2655.         if err != nil {
  2656.                 return err
  2657.         }
  2658.  
  2659.         err = writeElement(w, msg.PrevFilterHeader)
  2660.         if err != nil {
  2661.                 return err
  2662.         }
  2663.  
  2664.         count := len(msg.FilterHashes)
  2665.         if count > MaxCFHeadersPerMsg {
  2666.                 str := fmt.Sprintf("too many committed filter headers for "+
  2667.                         "message [count %v, max %v]", count,
  2668.                         MaxBlockHeadersPerMsg)
  2669.                 return messageError("MsgCFHeaders.BtcEncode", str)
  2670.         }
  2671.  
  2672.         err = WriteVarInt(w, pver, uint64(count))
  2673.         if err != nil {
  2674.                 return err
  2675.         }
  2676.  
  2677.         for _, cfh := range msg.FilterHashes {
  2678.                 err := writeElement(w, cfh)
  2679.                 if err != nil {
  2680.                         return err
  2681.                 }
  2682.         }
  2683.  
  2684.         return nil
  2685. }
  2686.  
  2687. func (msg *MsgCFHeaders) Deserialize(r io.Reader) error {
  2688.  
  2689.         return msg.BtcDecode(r, 0, BaseEncoding)
  2690. }
  2691.  
  2692. func (msg *MsgCFHeaders) Command() string {
  2693.         return CmdCFHeaders
  2694. }
  2695.  
  2696. func (msg *MsgCFHeaders) MaxPayloadLength(pver uint32) uint32 {
  2697.  
  2698.         return 1 + HashSize + HashSize + MaxVarIntPayload +
  2699.                 (MaxCFHeaderPayload * MaxCFHeadersPerMsg)
  2700. }
  2701.  
  2702. func NewMsgCFHeaders() *MsgCFHeaders {
  2703.         return &MsgCFHeaders{
  2704.                 FilterHashes: make([]*Hash, 0, MaxCFHeadersPerMsg),
  2705.         }
  2706. }
  2707.  
  2708. type FilterType uint8
  2709.  
  2710. const (
  2711.         GCSFilterRegular FilterType = iota
  2712. )
  2713.  
  2714. const (
  2715.         MaxCFilterDataSize = 256 * 1024
  2716. )
  2717.  
  2718. type MsgCFilter struct {
  2719.         FilterType FilterType
  2720.         BlockHash  Hash
  2721.         Data       []byte
  2722. }
  2723.  
  2724. func (msg *MsgCFilter) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2725.  
  2726.         err := readElement(r, &msg.FilterType)
  2727.         if err != nil {
  2728.                 return err
  2729.         }
  2730.  
  2731.         err = readElement(r, &msg.BlockHash)
  2732.         if err != nil {
  2733.                 return err
  2734.         }
  2735.  
  2736.         msg.Data, err = ReadVarBytes(r, pver, MaxCFilterDataSize,
  2737.                 "cfilter data")
  2738.         return err
  2739. }
  2740.  
  2741. func (msg *MsgCFilter) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2742.         size := len(msg.Data)
  2743.         if size > MaxCFilterDataSize {
  2744.                 str := fmt.Sprintf("cfilter size too large for message "+
  2745.                         "[size %v, max %v]", size, MaxCFilterDataSize)
  2746.                 return messageError("MsgCFilter.BtcEncode", str)
  2747.         }
  2748.  
  2749.         err := writeElement(w, msg.FilterType)
  2750.         if err != nil {
  2751.                 return err
  2752.         }
  2753.  
  2754.         err = writeElement(w, msg.BlockHash)
  2755.         if err != nil {
  2756.                 return err
  2757.         }
  2758.  
  2759.         return WriteVarBytes(w, pver, msg.Data)
  2760. }
  2761.  
  2762. func (msg *MsgCFilter) Deserialize(r io.Reader) error {
  2763.  
  2764.         return msg.BtcDecode(r, 0, BaseEncoding)
  2765. }
  2766.  
  2767. func (msg *MsgCFilter) Command() string {
  2768.         return CmdCFilter
  2769. }
  2770.  
  2771. func (msg *MsgCFilter) MaxPayloadLength(pver uint32) uint32 {
  2772.         return uint32(VarIntSerializeSize(MaxCFilterDataSize)) +
  2773.                 MaxCFilterDataSize + HashSize + 1
  2774. }
  2775.  
  2776. func NewMsgCFilter(filterType FilterType, blockHash *Hash,
  2777.         data []byte) *MsgCFilter {
  2778.         return &MsgCFilter{
  2779.                 FilterType: filterType,
  2780.                 BlockHash:  *blockHash,
  2781.                 Data:       data,
  2782.         }
  2783. }
  2784.  
  2785. type MsgFeeFilter struct {
  2786.         MinFee int64
  2787. }
  2788.  
  2789. func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2790.         if pver < FeeFilterVersion {
  2791.                 str := fmt.Sprintf("feefilter message invalid for protocol "+
  2792.                         "version %d", pver)
  2793.                 return messageError("MsgFeeFilter.BtcDecode", str)
  2794.         }
  2795.  
  2796.         return readElement(r, &msg.MinFee)
  2797. }
  2798.  
  2799. func (msg *MsgFeeFilter) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2800.         if pver < FeeFilterVersion {
  2801.                 str := fmt.Sprintf("feefilter message invalid for protocol "+
  2802.                         "version %d", pver)
  2803.                 return messageError("MsgFeeFilter.BtcEncode", str)
  2804.         }
  2805.  
  2806.         return writeElement(w, msg.MinFee)
  2807. }
  2808.  
  2809. func (msg *MsgFeeFilter) Command() string {
  2810.         return CmdFeeFilter
  2811. }
  2812.  
  2813. func (msg *MsgFeeFilter) MaxPayloadLength(pver uint32) uint32 {
  2814.         return 8
  2815. }
  2816.  
  2817. func NewMsgFeeFilter(minfee int64) *MsgFeeFilter {
  2818.         return &MsgFeeFilter{
  2819.                 MinFee: minfee,
  2820.         }
  2821. }
  2822.  
  2823. const (
  2824.         MaxFilterAddDataSize = 520
  2825. )
  2826.  
  2827. type MsgFilterAdd struct {
  2828.         Data []byte
  2829. }
  2830.  
  2831. func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2832.         if pver < BIP0037Version {
  2833.                 str := fmt.Sprintf("filteradd message invalid for protocol "+
  2834.                         "version %d", pver)
  2835.                 return messageError("MsgFilterAdd.BtcDecode", str)
  2836.         }
  2837.  
  2838.         var err error
  2839.         msg.Data, err = ReadVarBytes(r, pver, MaxFilterAddDataSize,
  2840.                 "filteradd data")
  2841.         return err
  2842. }
  2843.  
  2844. func (msg *MsgFilterAdd) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2845.         if pver < BIP0037Version {
  2846.                 str := fmt.Sprintf("filteradd message invalid for protocol "+
  2847.                         "version %d", pver)
  2848.                 return messageError("MsgFilterAdd.BtcEncode", str)
  2849.         }
  2850.  
  2851.         size := len(msg.Data)
  2852.         if size > MaxFilterAddDataSize {
  2853.                 str := fmt.Sprintf("filteradd size too large for message "+
  2854.                         "[size %v, max %v]", size, MaxFilterAddDataSize)
  2855.                 return messageError("MsgFilterAdd.BtcEncode", str)
  2856.         }
  2857.  
  2858.         return WriteVarBytes(w, pver, msg.Data)
  2859. }
  2860.  
  2861. func (msg *MsgFilterAdd) Command() string {
  2862.         return CmdFilterAdd
  2863. }
  2864.  
  2865. func (msg *MsgFilterAdd) MaxPayloadLength(pver uint32) uint32 {
  2866.         return uint32(VarIntSerializeSize(MaxFilterAddDataSize)) +
  2867.                 MaxFilterAddDataSize
  2868. }
  2869.  
  2870. func NewMsgFilterAdd(data []byte) *MsgFilterAdd {
  2871.         return &MsgFilterAdd{
  2872.                 Data: data,
  2873.         }
  2874. }
  2875.  
  2876. type MsgFilterClear struct{}
  2877.  
  2878. func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2879.         if pver < BIP0037Version {
  2880.                 str := fmt.Sprintf("filterclear message invalid for protocol "+
  2881.                         "version %d", pver)
  2882.                 return messageError("MsgFilterClear.BtcDecode", str)
  2883.         }
  2884.  
  2885.         return nil
  2886. }
  2887.  
  2888. func (msg *MsgFilterClear) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2889.         if pver < BIP0037Version {
  2890.                 str := fmt.Sprintf("filterclear message invalid for protocol "+
  2891.                         "version %d", pver)
  2892.                 return messageError("MsgFilterClear.BtcEncode", str)
  2893.         }
  2894.  
  2895.         return nil
  2896. }
  2897.  
  2898. func (msg *MsgFilterClear) Command() string {
  2899.         return CmdFilterClear
  2900. }
  2901.  
  2902. func (msg *MsgFilterClear) MaxPayloadLength(pver uint32) uint32 {
  2903.         return 0
  2904. }
  2905.  
  2906. func NewMsgFilterClear() *MsgFilterClear {
  2907.         return &MsgFilterClear{}
  2908. }
  2909.  
  2910. type BloomUpdateType uint8
  2911.  
  2912. const (
  2913.         BloomUpdateNone BloomUpdateType = 0
  2914.  
  2915.         BloomUpdateAll BloomUpdateType = 1
  2916.  
  2917.         BloomUpdateP2PubkeyOnly BloomUpdateType = 2
  2918. )
  2919.  
  2920. const (
  2921.         MaxFilterLoadHashFuncs = 50
  2922.  
  2923.         MaxFilterLoadFilterSize = 36000
  2924. )
  2925.  
  2926. type MsgFilterLoad struct {
  2927.         Filter    []byte
  2928.         HashFuncs uint32
  2929.         Tweak     uint32
  2930.         Flags     BloomUpdateType
  2931. }
  2932.  
  2933. func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2934.         if pver < BIP0037Version {
  2935.                 str := fmt.Sprintf("filterload message invalid for protocol "+
  2936.                         "version %d", pver)
  2937.                 return messageError("MsgFilterLoad.BtcDecode", str)
  2938.         }
  2939.  
  2940.         var err error
  2941.         msg.Filter, err = ReadVarBytes(r, pver, MaxFilterLoadFilterSize,
  2942.                 "filterload filter size")
  2943.         if err != nil {
  2944.                 return err
  2945.         }
  2946.  
  2947.         err = readElements(r, &msg.HashFuncs, &msg.Tweak, &msg.Flags)
  2948.         if err != nil {
  2949.                 return err
  2950.         }
  2951.  
  2952.         if msg.HashFuncs > MaxFilterLoadHashFuncs {
  2953.                 str := fmt.Sprintf("too many filter hash functions for message "+
  2954.                         "[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
  2955.                 return messageError("MsgFilterLoad.BtcDecode", str)
  2956.         }
  2957.  
  2958.         return nil
  2959. }
  2960.  
  2961. func (msg *MsgFilterLoad) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2962.         if pver < BIP0037Version {
  2963.                 str := fmt.Sprintf("filterload message invalid for protocol "+
  2964.                         "version %d", pver)
  2965.                 return messageError("MsgFilterLoad.BtcEncode", str)
  2966.         }
  2967.  
  2968.         size := len(msg.Filter)
  2969.         if size > MaxFilterLoadFilterSize {
  2970.                 str := fmt.Sprintf("filterload filter size too large for message "+
  2971.                         "[size %v, max %v]", size, MaxFilterLoadFilterSize)
  2972.                 return messageError("MsgFilterLoad.BtcEncode", str)
  2973.         }
  2974.  
  2975.         if msg.HashFuncs > MaxFilterLoadHashFuncs {
  2976.                 str := fmt.Sprintf("too many filter hash functions for message "+
  2977.                         "[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
  2978.                 return messageError("MsgFilterLoad.BtcEncode", str)
  2979.         }
  2980.  
  2981.         err := WriteVarBytes(w, pver, msg.Filter)
  2982.         if err != nil {
  2983.                 return err
  2984.         }
  2985.  
  2986.         return writeElements(w, msg.HashFuncs, msg.Tweak, msg.Flags)
  2987. }
  2988.  
  2989. func (msg *MsgFilterLoad) Command() string {
  2990.         return CmdFilterLoad
  2991. }
  2992.  
  2993. func (msg *MsgFilterLoad) MaxPayloadLength(pver uint32) uint32 {
  2994.  
  2995.         return uint32(VarIntSerializeSize(MaxFilterLoadFilterSize)) +
  2996.                 MaxFilterLoadFilterSize + 9
  2997. }
  2998.  
  2999. func NewMsgFilterLoad(filter []byte, hashFuncs uint32, tweak uint32, flags BloomUpdateType) *MsgFilterLoad {
  3000.         return &MsgFilterLoad{
  3001.                 Filter:    filter,
  3002.                 HashFuncs: hashFuncs,
  3003.                 Tweak:     tweak,
  3004.                 Flags:     flags,
  3005.         }
  3006. }
  3007.  
  3008. type MsgGetAddr struct{}
  3009.  
  3010. func (msg *MsgGetAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3011.         return nil
  3012. }
  3013.  
  3014. func (msg *MsgGetAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3015.         return nil
  3016. }
  3017.  
  3018. func (msg *MsgGetAddr) Command() string {
  3019.         return CmdGetAddr
  3020. }
  3021.  
  3022. func (msg *MsgGetAddr) MaxPayloadLength(pver uint32) uint32 {
  3023.         return 0
  3024. }
  3025.  
  3026. func NewMsgGetAddr() *MsgGetAddr {
  3027.         return &MsgGetAddr