GO 14
Haircomb commits.db downloader Guest on 17th October 2020 06:33:45 PM
  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{}
  3028. }
  3029.  
  3030. const MaxBlockLocatorsPerMsg = 500
  3031.  
  3032. type MsgGetBlocks struct {
  3033.         ProtocolVersion    uint32
  3034.         BlockLocatorHashes []*Hash
  3035.         HashStop           Hash
  3036. }
  3037.  
  3038. func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *Hash) error {
  3039.         if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
  3040.                 str := fmt.Sprintf("too many block locator hashes for message [max %v]",
  3041.                         MaxBlockLocatorsPerMsg)
  3042.                 return messageError("MsgGetBlocks.AddBlockLocatorHash", str)
  3043.         }
  3044.  
  3045.         msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
  3046.         return nil
  3047. }
  3048.  
  3049. func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3050.         err := readElement(r, &msg.ProtocolVersion)
  3051.         if err != nil {
  3052.                 return err
  3053.         }
  3054.  
  3055.         count, err := ReadVarInt(r, pver)
  3056.         if err != nil {
  3057.                 return err
  3058.         }
  3059.         if count > MaxBlockLocatorsPerMsg {
  3060.                 str := fmt.Sprintf("too many block locator hashes for message "+
  3061.                         "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3062.                 return messageError("MsgGetBlocks.BtcDecode", str)
  3063.         }
  3064.  
  3065.         locatorHashes := make([]Hash, count)
  3066.         msg.BlockLocatorHashes = make([]*Hash, 0, count)
  3067.         for i := uint64(0); i < count; i++ {
  3068.                 hash := &locatorHashes[i]
  3069.                 err := readElement(r, hash)
  3070.                 if err != nil {
  3071.                         return err
  3072.                 }
  3073.                 msg.AddBlockLocatorHash(hash)
  3074.         }
  3075.  
  3076.         return readElement(r, &msg.HashStop)
  3077. }
  3078.  
  3079. func (msg *MsgGetBlocks) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3080.         count := len(msg.BlockLocatorHashes)
  3081.         if count > MaxBlockLocatorsPerMsg {
  3082.                 str := fmt.Sprintf("too many block locator hashes for message "+
  3083.                         "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3084.                 return messageError("MsgGetBlocks.BtcEncode", str)
  3085.         }
  3086.  
  3087.         err := writeElement(w, msg.ProtocolVersion)
  3088.         if err != nil {
  3089.                 return err
  3090.         }
  3091.  
  3092.         err = WriteVarInt(w, pver, uint64(count))
  3093.         if err != nil {
  3094.                 return err
  3095.         }
  3096.  
  3097.         for _, hash := range msg.BlockLocatorHashes {
  3098.                 err = writeElement(w, hash)
  3099.                 if err != nil {
  3100.                         return err
  3101.                 }
  3102.         }
  3103.  
  3104.         return writeElement(w, &msg.HashStop)
  3105. }
  3106.  
  3107. func (msg *MsgGetBlocks) Command() string {
  3108.         return CmdGetBlocks
  3109. }
  3110.  
  3111. func (msg *MsgGetBlocks) MaxPayloadLength(pver uint32) uint32 {
  3112.  
  3113.         return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg * HashSize) + HashSize
  3114. }
  3115.  
  3116. func NewMsgGetBlocks(hashStop *Hash) *MsgGetBlocks {
  3117.         return &MsgGetBlocks{
  3118.                 ProtocolVersion:    ProtocolVersion,
  3119.                 BlockLocatorHashes: make([]*Hash, 0, MaxBlockLocatorsPerMsg),
  3120.                 HashStop:           *hashStop,
  3121.         }
  3122. }
  3123.  
  3124. type MsgGetCFCheckpt struct {
  3125.         FilterType FilterType
  3126.         StopHash   Hash
  3127. }
  3128.  
  3129. func (msg *MsgGetCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3130.         err := readElement(r, &msg.FilterType)
  3131.         if err != nil {
  3132.                 return err
  3133.         }
  3134.  
  3135.         return readElement(r, &msg.StopHash)
  3136. }
  3137.  
  3138. func (msg *MsgGetCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3139.         err := writeElement(w, msg.FilterType)
  3140.         if err != nil {
  3141.                 return err
  3142.         }
  3143.  
  3144.         return writeElement(w, &msg.StopHash)
  3145. }
  3146.  
  3147. func (msg *MsgGetCFCheckpt) Command() string {
  3148.         return CmdGetCFCheckpt
  3149. }
  3150.  
  3151. func (msg *MsgGetCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
  3152.  
  3153.         return 1 + HashSize
  3154. }
  3155.  
  3156. func NewMsgGetCFCheckpt(filterType FilterType, stopHash *Hash) *MsgGetCFCheckpt {
  3157.         return &MsgGetCFCheckpt{
  3158.                 FilterType: filterType,
  3159.                 StopHash:   *stopHash,
  3160.         }
  3161. }
  3162.  
  3163. type MsgGetCFHeaders struct {
  3164.         FilterType  FilterType
  3165.         StartHeight uint32
  3166.         StopHash    Hash
  3167. }
  3168.  
  3169. func (msg *MsgGetCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3170.         err := readElement(r, &msg.FilterType)
  3171.         if err != nil {
  3172.                 return err
  3173.         }
  3174.  
  3175.         err = readElement(r, &msg.StartHeight)
  3176.         if err != nil {
  3177.                 return err
  3178.         }
  3179.  
  3180.         return readElement(r, &msg.StopHash)
  3181. }
  3182.  
  3183. func (msg *MsgGetCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3184.         err := writeElement(w, msg.FilterType)
  3185.         if err != nil {
  3186.                 return err
  3187.         }
  3188.  
  3189.         err = writeElement(w, &msg.StartHeight)
  3190.         if err != nil {
  3191.                 return err
  3192.         }
  3193.  
  3194.         return writeElement(w, &msg.StopHash)
  3195. }
  3196.  
  3197. func (msg *MsgGetCFHeaders) Command() string {
  3198.         return CmdGetCFHeaders
  3199. }
  3200.  
  3201. func (msg *MsgGetCFHeaders) MaxPayloadLength(pver uint32) uint32 {
  3202.  
  3203.         return 1 + 4 + HashSize
  3204. }
  3205.  
  3206. func NewMsgGetCFHeaders(filterType FilterType, startHeight uint32,
  3207.         stopHash *Hash) *MsgGetCFHeaders {
  3208.         return &MsgGetCFHeaders{
  3209.                 FilterType:  filterType,
  3210.                 StartHeight: startHeight,
  3211.                 StopHash:    *stopHash,
  3212.         }
  3213. }
  3214.  
  3215. const MaxGetCFiltersReqRange = 1000
  3216.  
  3217. type MsgGetCFilters struct {
  3218.         FilterType  FilterType
  3219.         StartHeight uint32
  3220.         StopHash    Hash
  3221. }
  3222.  
  3223. func (msg *MsgGetCFilters) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3224.         err := readElement(r, &msg.FilterType)
  3225.         if err != nil {
  3226.                 return err
  3227.         }
  3228.  
  3229.         err = readElement(r, &msg.StartHeight)
  3230.         if err != nil {
  3231.                 return err
  3232.         }
  3233.  
  3234.         return readElement(r, &msg.StopHash)
  3235. }
  3236.  
  3237. func (msg *MsgGetCFilters) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3238.         err := writeElement(w, msg.FilterType)
  3239.         if err != nil {
  3240.                 return err
  3241.         }
  3242.  
  3243.         err = writeElement(w, &msg.StartHeight)
  3244.         if err != nil {
  3245.                 return err
  3246.         }
  3247.  
  3248.         return writeElement(w, &msg.StopHash)
  3249. }
  3250.  
  3251. func (msg *MsgGetCFilters) Command() string {
  3252.         return CmdGetCFilters
  3253. }
  3254.  
  3255. func (msg *MsgGetCFilters) MaxPayloadLength(pver uint32) uint32 {
  3256.  
  3257.         return 1 + 4 + HashSize
  3258. }
  3259.  
  3260. func NewMsgGetCFilters(filterType FilterType, startHeight uint32,
  3261.         stopHash *Hash) *MsgGetCFilters {
  3262.         return &MsgGetCFilters{
  3263.                 FilterType:  filterType,
  3264.                 StartHeight: startHeight,
  3265.                 StopHash:    *stopHash,
  3266.         }
  3267. }
  3268.  
  3269. type MsgGetData struct {
  3270.         InvList []*InvVect
  3271. }
  3272.  
  3273. func (msg *MsgGetData) AddInvVect(iv *InvVect) error {
  3274.         if len(msg.InvList)+1 > MaxInvPerMsg {
  3275.                 str := fmt.Sprintf("too many invvect in message [max %v]",
  3276.                         MaxInvPerMsg)
  3277.                 return messageError("MsgGetData.AddInvVect", str)
  3278.         }
  3279.  
  3280.         msg.InvList = append(msg.InvList, iv)
  3281.         return nil
  3282. }
  3283.  
  3284. func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3285.         count, err := ReadVarInt(r, pver)
  3286.         if err != nil {
  3287.                 return err
  3288.         }
  3289.  
  3290.         if count > MaxInvPerMsg {
  3291.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3292.                 return messageError("MsgGetData.BtcDecode", str)
  3293.         }
  3294.  
  3295.         invList := make([]InvVect, count)
  3296.         msg.InvList = make([]*InvVect, 0, count)
  3297.         for i := uint64(0); i < count; i++ {
  3298.                 iv := &invList[i]
  3299.                 err := readInvVect(r, pver, iv)
  3300.                 if err != nil {
  3301.                         return err
  3302.                 }
  3303.                 msg.AddInvVect(iv)
  3304.         }
  3305.  
  3306.         return nil
  3307. }
  3308.  
  3309. func (msg *MsgGetData) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3310.  
  3311.         count := len(msg.InvList)
  3312.         if count > MaxInvPerMsg {
  3313.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3314.                 return messageError("MsgGetData.BtcEncode", str)
  3315.         }
  3316.  
  3317.         err := WriteVarInt(w, pver, uint64(count))
  3318.         if err != nil {
  3319.                 return err
  3320.         }
  3321.  
  3322.         for _, iv := range msg.InvList {
  3323.                 err := writeInvVect(w, pver, iv)
  3324.                 if err != nil {
  3325.                         return err
  3326.                 }
  3327.         }
  3328.  
  3329.         return nil
  3330. }
  3331.  
  3332. func (msg *MsgGetData) Command() string {
  3333.         return CmdGetData
  3334. }
  3335.  
  3336. func (msg *MsgGetData) MaxPayloadLength(pver uint32) uint32 {
  3337.  
  3338.         return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3339. }
  3340.  
  3341. func NewMsgGetData() *MsgGetData {
  3342.         return &MsgGetData{
  3343.                 InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3344.         }
  3345. }
  3346.  
  3347. func NewMsgGetDataSizeHint(sizeHint uint) *MsgGetData {
  3348.  
  3349.         if sizeHint > MaxInvPerMsg {
  3350.                 sizeHint = MaxInvPerMsg
  3351.         }
  3352.  
  3353.         return &MsgGetData{
  3354.                 InvList: make([]*InvVect, 0, sizeHint),
  3355.         }
  3356. }
  3357.  
  3358. type MsgGetHeaders struct {
  3359.         ProtocolVersion    uint32
  3360.         BlockLocatorHashes []*Hash
  3361.         HashStop           Hash
  3362. }
  3363.  
  3364. func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *Hash) error {
  3365.         if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
  3366.                 str := fmt.Sprintf("too many block locator hashes for message [max %v]",
  3367.                         MaxBlockLocatorsPerMsg)
  3368.                 return messageError("MsgGetHeaders.AddBlockLocatorHash", str)
  3369.         }
  3370.  
  3371.         msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
  3372.         return nil
  3373. }
  3374.  
  3375. func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3376.         err := readElement(r, &msg.ProtocolVersion)
  3377.         if err != nil {
  3378.                 return err
  3379.         }
  3380.  
  3381.         count, err := ReadVarInt(r, pver)
  3382.         if err != nil {
  3383.                 return err
  3384.         }
  3385.         if count > MaxBlockLocatorsPerMsg {
  3386.                 str := fmt.Sprintf("too many block locator hashes for message "+
  3387.                         "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3388.                 return messageError("MsgGetHeaders.BtcDecode", str)
  3389.         }
  3390.  
  3391.         locatorHashes := make([]Hash, count)
  3392.         msg.BlockLocatorHashes = make([]*Hash, 0, count)
  3393.         for i := uint64(0); i < count; i++ {
  3394.                 hash := &locatorHashes[i]
  3395.                 err := readElement(r, hash)
  3396.                 if err != nil {
  3397.                         return err
  3398.                 }
  3399.                 msg.AddBlockLocatorHash(hash)
  3400.         }
  3401.  
  3402.         return readElement(r, &msg.HashStop)
  3403. }
  3404.  
  3405. func (msg *MsgGetHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3406.  
  3407.         count := len(msg.BlockLocatorHashes)
  3408.         if count > MaxBlockLocatorsPerMsg {
  3409.                 str := fmt.Sprintf("too many block locator hashes for message "+
  3410.                         "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3411.                 return messageError("MsgGetHeaders.BtcEncode", str)
  3412.         }
  3413.  
  3414.         err := writeElement(w, msg.ProtocolVersion)
  3415.         if err != nil {
  3416.                 return err
  3417.         }
  3418.  
  3419.         err = WriteVarInt(w, pver, uint64(count))
  3420.         if err != nil {
  3421.                 return err
  3422.         }
  3423.  
  3424.         for _, hash := range msg.BlockLocatorHashes {
  3425.                 err := writeElement(w, hash)
  3426.                 if err != nil {
  3427.                         return err
  3428.                 }
  3429.         }
  3430.  
  3431.         return writeElement(w, &msg.HashStop)
  3432. }
  3433.  
  3434. func (msg *MsgGetHeaders) Command() string {
  3435.         return CmdGetHeaders
  3436. }
  3437.  
  3438. func (msg *MsgGetHeaders) MaxPayloadLength(pver uint32) uint32 {
  3439.  
  3440.         return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg *
  3441.                 HashSize) + HashSize
  3442. }
  3443.  
  3444. func NewMsgGetHeaders() *MsgGetHeaders {
  3445.         return &MsgGetHeaders{
  3446.                 BlockLocatorHashes: make([]*Hash, 0,
  3447.                         MaxBlockLocatorsPerMsg),
  3448.         }
  3449. }
  3450.  
  3451. const MaxBlockHeadersPerMsg = 2000
  3452.  
  3453. type MsgHeaders struct {
  3454.         Headers []*BlockHeader
  3455. }
  3456.  
  3457. func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
  3458.         if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
  3459.                 str := fmt.Sprintf("too many block headers in message [max %v]",
  3460.                         MaxBlockHeadersPerMsg)
  3461.                 return messageError("MsgHeaders.AddBlockHeader", str)
  3462.         }
  3463.  
  3464.         msg.Headers = append(msg.Headers, bh)
  3465.         return nil
  3466. }
  3467.  
  3468. func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3469.         count, err := ReadVarInt(r, pver)
  3470.         if err != nil {
  3471.                 return err
  3472.         }
  3473.  
  3474.         if count > MaxBlockHeadersPerMsg {
  3475.                 str := fmt.Sprintf("too many block headers for message "+
  3476.                         "[count %v, max %v]", count, MaxBlockHeadersPerMsg)
  3477.                 return messageError("MsgHeaders.BtcDecode", str)
  3478.         }
  3479.  
  3480.         headers := make([]BlockHeader, count)
  3481.         msg.Headers = make([]*BlockHeader, 0, count)
  3482.         for i := uint64(0); i < count; i++ {
  3483.                 bh := &headers[i]
  3484.                 err := readBlockHeader(r, pver, bh)
  3485.                 if err != nil {
  3486.                         return err
  3487.                 }
  3488.  
  3489.                 txCount, err := ReadVarInt(r, pver)
  3490.                 if err != nil {
  3491.                         return err
  3492.                 }
  3493.  
  3494.                 if txCount > 0 {
  3495.                         str := fmt.Sprintf("block headers may not contain "+
  3496.                                 "transactions [count %v]", txCount)
  3497.                         return messageError("MsgHeaders.BtcDecode", str)
  3498.                 }
  3499.                 msg.AddBlockHeader(bh)
  3500.         }
  3501.  
  3502.         return nil
  3503. }
  3504.  
  3505. func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3506.  
  3507.         count := len(msg.Headers)
  3508.         if count > MaxBlockHeadersPerMsg {
  3509.                 str := fmt.Sprintf("too many block headers for message "+
  3510.                         "[count %v, max %v]", count, MaxBlockHeadersPerMsg)
  3511.                 return messageError("MsgHeaders.BtcEncode", str)
  3512.         }
  3513.  
  3514.         err := WriteVarInt(w, pver, uint64(count))
  3515.         if err != nil {
  3516.                 return err
  3517.         }
  3518.  
  3519.         for _, bh := range msg.Headers {
  3520.                 err := writeBlockHeader(w, pver, bh)
  3521.                 if err != nil {
  3522.                         return err
  3523.                 }
  3524.  
  3525.                 err = WriteVarInt(w, pver, 0)
  3526.                 if err != nil {
  3527.                         return err
  3528.                 }
  3529.         }
  3530.  
  3531.         return nil
  3532. }
  3533.  
  3534. func (msg *MsgHeaders) Command() string {
  3535.         return CmdHeaders
  3536. }
  3537.  
  3538. func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32 {
  3539.  
  3540.         return MaxVarIntPayload + ((MaxBlockHeaderPayload + 1) *
  3541.                 MaxBlockHeadersPerMsg)
  3542. }
  3543.  
  3544. func NewMsgHeaders() *MsgHeaders {
  3545.         return &MsgHeaders{
  3546.                 Headers: make([]*BlockHeader, 0, MaxBlockHeadersPerMsg),
  3547.         }
  3548. }
  3549.  
  3550. const defaultInvListAlloc = 1000
  3551.  
  3552. type MsgInv struct {
  3553.         InvList []*InvVect
  3554. }
  3555.  
  3556. func (msg *MsgInv) AddInvVect(iv *InvVect) error {
  3557.         if len(msg.InvList)+1 > MaxInvPerMsg {
  3558.                 str := fmt.Sprintf("too many invvect in message [max %v]",
  3559.                         MaxInvPerMsg)
  3560.                 return messageError("MsgInv.AddInvVect", str)
  3561.         }
  3562.  
  3563.         msg.InvList = append(msg.InvList, iv)
  3564.         return nil
  3565. }
  3566.  
  3567. func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3568.         count, err := ReadVarInt(r, pver)
  3569.         if err != nil {
  3570.                 return err
  3571.         }
  3572.  
  3573.         if count > MaxInvPerMsg {
  3574.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3575.                 return messageError("MsgInv.BtcDecode", str)
  3576.         }
  3577.  
  3578.         invList := make([]InvVect, count)
  3579.         msg.InvList = make([]*InvVect, 0, count)
  3580.         for i := uint64(0); i < count; i++ {
  3581.                 iv := &invList[i]
  3582.                 err := readInvVect(r, pver, iv)
  3583.                 if err != nil {
  3584.                         return err
  3585.                 }
  3586.                 msg.AddInvVect(iv)
  3587.         }
  3588.  
  3589.         return nil
  3590. }
  3591.  
  3592. func (msg *MsgInv) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3593.  
  3594.         count := len(msg.InvList)
  3595.         if count > MaxInvPerMsg {
  3596.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3597.                 return messageError("MsgInv.BtcEncode", str)
  3598.         }
  3599.  
  3600.         err := WriteVarInt(w, pver, uint64(count))
  3601.         if err != nil {
  3602.                 return err
  3603.         }
  3604.  
  3605.         for _, iv := range msg.InvList {
  3606.                 err := writeInvVect(w, pver, iv)
  3607.                 if err != nil {
  3608.                         return err
  3609.                 }
  3610.         }
  3611.  
  3612.         return nil
  3613. }
  3614.  
  3615. func (msg *MsgInv) Command() string {
  3616.         return CmdInv
  3617. }
  3618.  
  3619. func (msg *MsgInv) MaxPayloadLength(pver uint32) uint32 {
  3620.  
  3621.         return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3622. }
  3623.  
  3624. func NewMsgInv() *MsgInv {
  3625.         return &MsgInv{
  3626.                 InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3627.         }
  3628. }
  3629.  
  3630. func NewMsgInvSizeHint(sizeHint uint) *MsgInv {
  3631.  
  3632.         if sizeHint > MaxInvPerMsg {
  3633.                 sizeHint = MaxInvPerMsg
  3634.         }
  3635.  
  3636.         return &MsgInv{
  3637.                 InvList: make([]*InvVect, 0, sizeHint),
  3638.         }
  3639. }
  3640.  
  3641. type MsgMemPool struct{}
  3642.  
  3643. func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3644.         if pver < BIP0035Version {
  3645.                 str := fmt.Sprintf("mempool message invalid for protocol "+
  3646.                         "version %d", pver)
  3647.                 return messageError("MsgMemPool.BtcDecode", str)
  3648.         }
  3649.  
  3650.         return nil
  3651. }
  3652.  
  3653. func (msg *MsgMemPool) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3654.         if pver < BIP0035Version {
  3655.                 str := fmt.Sprintf("mempool message invalid for protocol "+
  3656.                         "version %d", pver)
  3657.                 return messageError("MsgMemPool.BtcEncode", str)
  3658.         }
  3659.  
  3660.         return nil
  3661. }
  3662.  
  3663. func (msg *MsgMemPool) Command() string {
  3664.         return CmdMemPool
  3665. }
  3666.  
  3667. func (msg *MsgMemPool) MaxPayloadLength(pver uint32) uint32 {
  3668.         return 0
  3669. }
  3670.  
  3671. func NewMsgMemPool() *MsgMemPool {
  3672.         return &MsgMemPool{}
  3673. }
  3674.  
  3675. const maxFlagsPerMerkleBlock = maxTxPerBlock / 8
  3676.  
  3677. type MsgMerkleBlock struct {
  3678.         Header       BlockHeader
  3679.         Transactions uint32
  3680.         Hashes       []*Hash
  3681.         Flags        []byte
  3682. }
  3683.  
  3684. func (msg *MsgMerkleBlock) AddTxHash(hash *Hash) error {
  3685.         if len(msg.Hashes)+1 > maxTxPerBlock {
  3686.                 str := fmt.Sprintf("too many tx hashes for message [max %v]",
  3687.                         maxTxPerBlock)
  3688.                 return messageError("MsgMerkleBlock.AddTxHash", str)
  3689.         }
  3690.  
  3691.         msg.Hashes = append(msg.Hashes, hash)
  3692.         return nil
  3693. }
  3694.  
  3695. func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3696.         if pver < BIP0037Version {
  3697.                 str := fmt.Sprintf("merkleblock message invalid for protocol "+
  3698.                         "version %d", pver)
  3699.                 return messageError("MsgMerkleBlock.BtcDecode", str)
  3700.         }
  3701.  
  3702.         err := readBlockHeader(r, pver, &msg.Header)
  3703.         if err != nil {
  3704.                 return err
  3705.         }
  3706.  
  3707.         err = readElement(r, &msg.Transactions)
  3708.         if err != nil {
  3709.                 return err
  3710.         }
  3711.  
  3712.         count, err := ReadVarInt(r, pver)
  3713.         if err != nil {
  3714.                 return err
  3715.         }
  3716.         if count > maxTxPerBlock {
  3717.                 str := fmt.Sprintf("too many transaction hashes for message "+
  3718.                         "[count %v, max %v]", count, maxTxPerBlock)
  3719.                 return messageError("MsgMerkleBlock.BtcDecode", str)
  3720.         }
  3721.  
  3722.         hashes := make([]Hash, count)
  3723.         msg.Hashes = make([]*Hash, 0, count)
  3724.         for i := uint64(0); i < count; i++ {
  3725.                 hash := &hashes[i]
  3726.                 err := readElement(r, hash)
  3727.                 if err != nil {
  3728.                         return err
  3729.                 }
  3730.                 msg.AddTxHash(hash)
  3731.         }
  3732.  
  3733.         msg.Flags, err = ReadVarBytes(r, pver, maxFlagsPerMerkleBlock,
  3734.                 "merkle block flags size")
  3735.         return err
  3736. }
  3737.  
  3738. func (msg *MsgMerkleBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3739.         if pver < BIP0037Version {
  3740.                 str := fmt.Sprintf("merkleblock message invalid for protocol "+
  3741.                         "version %d", pver)
  3742.                 return messageError("MsgMerkleBlock.BtcEncode", str)
  3743.         }
  3744.  
  3745.         numHashes := len(msg.Hashes)
  3746.         if numHashes > maxTxPerBlock {
  3747.                 str := fmt.Sprintf("too many transaction hashes for message "+
  3748.                         "[count %v, max %v]", numHashes, maxTxPerBlock)
  3749.                 return messageError("MsgMerkleBlock.BtcDecode", str)
  3750.         }
  3751.         numFlagBytes := len(msg.Flags)
  3752.         if numFlagBytes > maxFlagsPerMerkleBlock {
  3753.                 str := fmt.Sprintf("too many flag bytes for message [count %v, "+
  3754.                         "max %v]", numFlagBytes, maxFlagsPerMerkleBlock)
  3755.                 return messageError("MsgMerkleBlock.BtcDecode", str)
  3756.         }
  3757.  
  3758.         err := writeBlockHeader(w, pver, &msg.Header)
  3759.         if err != nil {
  3760.                 return err
  3761.         }
  3762.  
  3763.         err = writeElement(w, msg.Transactions)
  3764.         if err != nil {
  3765.                 return err
  3766.         }
  3767.  
  3768.         err = WriteVarInt(w, pver, uint64(numHashes))
  3769.         if err != nil {
  3770.                 return err
  3771.         }
  3772.         for _, hash := range msg.Hashes {
  3773.                 err = writeElement(w, hash)
  3774.                 if err != nil {
  3775.                         return err
  3776.                 }
  3777.         }
  3778.  
  3779.         return WriteVarBytes(w, pver, msg.Flags)
  3780. }
  3781.  
  3782. func (msg *MsgMerkleBlock) Command() string {
  3783.         return CmdMerkleBlock
  3784. }
  3785.  
  3786. func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32 {
  3787.         return MaxBlockPayload
  3788. }
  3789.  
  3790. func NewMsgMerkleBlock(bh *BlockHeader) *MsgMerkleBlock {
  3791.         return &MsgMerkleBlock{
  3792.                 Header:       *bh,
  3793.                 Transactions: 0,
  3794.                 Hashes:       make([]*Hash, 0),
  3795.                 Flags:        make([]byte, 0),
  3796.         }
  3797. }
  3798.  
  3799. type MsgNotFound struct {
  3800.         InvList []*InvVect
  3801. }
  3802.  
  3803. func (msg *MsgNotFound) AddInvVect(iv *InvVect) error {
  3804.         if len(msg.InvList)+1 > MaxInvPerMsg {
  3805.                 str := fmt.Sprintf("too many invvect in message [max %v]",
  3806.                         MaxInvPerMsg)
  3807.                 return messageError("MsgNotFound.AddInvVect", str)
  3808.         }
  3809.  
  3810.         msg.InvList = append(msg.InvList, iv)
  3811.         return nil
  3812. }
  3813.  
  3814. func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3815.         count, err := ReadVarInt(r, pver)
  3816.         if err != nil {
  3817.                 return err
  3818.         }
  3819.  
  3820.         if count > MaxInvPerMsg {
  3821.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3822.                 return messageError("MsgNotFound.BtcDecode", str)
  3823.         }
  3824.  
  3825.         invList := make([]InvVect, count)
  3826.         msg.InvList = make([]*InvVect, 0, count)
  3827.         for i := uint64(0); i < count; i++ {
  3828.                 iv := &invList[i]
  3829.                 err := readInvVect(r, pver, iv)
  3830.                 if err != nil {
  3831.                         return err
  3832.                 }
  3833.                 msg.AddInvVect(iv)
  3834.         }
  3835.  
  3836.         return nil
  3837. }
  3838.  
  3839. func (msg *MsgNotFound) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3840.  
  3841.         count := len(msg.InvList)
  3842.         if count > MaxInvPerMsg {
  3843.                 str := fmt.Sprintf("too many invvect in message [%v]", count)
  3844.                 return messageError("MsgNotFound.BtcEncode", str)
  3845.         }
  3846.  
  3847.         err := WriteVarInt(w, pver, uint64(count))
  3848.         if err != nil {
  3849.                 return err
  3850.         }
  3851.  
  3852.         for _, iv := range msg.InvList {
  3853.                 err := writeInvVect(w, pver, iv)
  3854.                 if err != nil {
  3855.                         return err
  3856.                 }
  3857.         }
  3858.  
  3859.         return nil
  3860. }
  3861.  
  3862. func (msg *MsgNotFound) Command() string {
  3863.         return CmdNotFound
  3864. }
  3865.  
  3866. func (msg *MsgNotFound) MaxPayloadLength(pver uint32) uint32 {
  3867.  
  3868.         return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3869. }
  3870.  
  3871. func NewMsgNotFound() *MsgNotFound {
  3872.         return &MsgNotFound{
  3873.                 InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3874.         }
  3875. }
  3876.  
  3877. type MsgPing struct {
  3878.         Nonce uint64
  3879. }
  3880.  
  3881. func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3882.  
  3883.         if pver > BIP0031Version {
  3884.                 err := readElement(r, &msg.Nonce)
  3885.                 if err != nil {
  3886.                         return err
  3887.                 }
  3888.         }
  3889.  
  3890.         return nil
  3891. }
  3892.  
  3893. func (msg *MsgPing) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3894.  
  3895.         if pver > BIP0031Version {
  3896.                 err := writeElement(w, msg.Nonce)
  3897.                 if err != nil {
  3898.                         return err
  3899.                 }
  3900.         }
  3901.  
  3902.         return nil
  3903. }
  3904.  
  3905. func (msg *MsgPing) Command() string {
  3906.         return CmdPing
  3907. }
  3908.  
  3909. func (msg *MsgPing) MaxPayloadLength(pver uint32) uint32 {
  3910.         plen := uint32(0)
  3911.  
  3912.         if pver > BIP0031Version {
  3913.  
  3914.                 plen += 8
  3915.         }
  3916.  
  3917.         return plen
  3918. }
  3919.  
  3920. func NewMsgPing(nonce uint64) *MsgPing {
  3921.         return &MsgPing{
  3922.                 Nonce: nonce,
  3923.         }
  3924. }
  3925.  
  3926. type MsgPong struct {
  3927.         Nonce uint64
  3928. }
  3929.  
  3930. func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3931.  
  3932.         if pver <= BIP0031Version {
  3933.                 str := fmt.Sprintf("pong message invalid for protocol "+
  3934.                         "version %d", pver)
  3935.                 return messageError("MsgPong.BtcDecode", str)
  3936.         }
  3937.  
  3938.         return readElement(r, &msg.Nonce)
  3939. }
  3940.  
  3941. func (msg *MsgPong) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3942.  
  3943.         if pver <= BIP0031Version {
  3944.                 str := fmt.Sprintf("pong message invalid for protocol "+
  3945.                         "version %d", pver)
  3946.                 return messageError("MsgPong.BtcEncode", str)
  3947.         }
  3948.  
  3949.         return writeElement(w, msg.Nonce)
  3950. }
  3951.  
  3952. func (msg *MsgPong) Command() string {
  3953.         return CmdPong
  3954. }
  3955.  
  3956. func (msg *MsgPong) MaxPayloadLength(pver uint32) uint32 {
  3957.         plen := uint32(0)
  3958.  
  3959.         if pver > BIP0031Version {
  3960.  
  3961.                 plen += 8
  3962.         }
  3963.  
  3964.         return plen
  3965. }
  3966.  
  3967. func NewMsgPong(nonce uint64) *MsgPong {
  3968.         return &MsgPong{
  3969.                 Nonce: nonce,
  3970.         }
  3971. }
  3972.  
  3973. type RejectCode uint8
  3974.  
  3975. const (
  3976.         RejectMalformed       RejectCode = 0x01
  3977.         RejectInvalid         RejectCode = 0x10
  3978.         RejectObsolete        RejectCode = 0x11
  3979.         RejectDuplicate       RejectCode = 0x12
  3980.         RejectNonstandard     RejectCode = 0x40
  3981.         RejectDust            RejectCode = 0x41
  3982.         RejectInsufficientFee RejectCode = 0x42
  3983.         RejectCheckpoint      RejectCode = 0x43
  3984. )
  3985.  
  3986. var rejectCodeStrings = map[RejectCode]string{
  3987.         RejectMalformed:       "REJECT_MALFORMED",
  3988.         RejectInvalid:         "REJECT_INVALID",
  3989.         RejectObsolete:        "REJECT_OBSOLETE",
  3990.         RejectDuplicate:       "REJECT_DUPLICATE",
  3991.         RejectNonstandard:     "REJECT_NONSTANDARD",
  3992.         RejectDust:            "REJECT_DUST",
  3993.         RejectInsufficientFee: "REJECT_INSUFFICIENTFEE",
  3994.         RejectCheckpoint:      "REJECT_CHECKPOINT",
  3995. }
  3996.  
  3997. func (code RejectCode) String() string {
  3998.         if s, ok := rejectCodeStrings[code]; ok {
  3999.                 return s
  4000.         }
  4001.  
  4002.         return fmt.Sprintf("Unknown RejectCode (%d)", uint8(code))
  4003. }
  4004.  
  4005. type MsgReject struct {
  4006.         Cmd string
  4007.  
  4008.         Code RejectCode
  4009.  
  4010.         Reason string
  4011.  
  4012.         Hash Hash
  4013. }
  4014.  
  4015. func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4016.         if pver < RejectVersion {
  4017.                 str := fmt.Sprintf("reject message invalid for protocol "+
  4018.                         "version %d", pver)
  4019.                 return messageError("MsgReject.BtcDecode", str)
  4020.         }
  4021.  
  4022.         cmd, err := ReadVarString(r, pver)
  4023.         if err != nil {
  4024.                 return err
  4025.         }
  4026.         msg.Cmd = cmd
  4027.  
  4028.         err = readElement(r, &msg.Code)
  4029.         if err != nil {
  4030.                 return err
  4031.         }
  4032.  
  4033.         reason, err := ReadVarString(r, pver)
  4034.         if err != nil {
  4035.                 return err
  4036.         }
  4037.         msg.Reason = reason
  4038.  
  4039.         if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
  4040.                 err := readElement(r, &msg.Hash)
  4041.                 if err != nil {
  4042.                         return err
  4043.                 }
  4044.         }
  4045.  
  4046.         return nil
  4047. }
  4048.  
  4049. func (msg *MsgReject) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4050.         if pver < RejectVersion {
  4051.                 str := fmt.Sprintf("reject message invalid for protocol "+
  4052.                         "version %d", pver)
  4053.                 return messageError("MsgReject.BtcEncode", str)
  4054.         }
  4055.  
  4056.         err := WriteVarString(w, pver, msg.Cmd)
  4057.         if err != nil {
  4058.                 return err
  4059.         }
  4060.  
  4061.         err = writeElement(w, msg.Code)
  4062.         if err != nil {
  4063.                 return err
  4064.         }
  4065.  
  4066.         err = WriteVarString(w, pver, msg.Reason)
  4067.         if err != nil {
  4068.                 return err
  4069.         }
  4070.  
  4071.         if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
  4072.                 err := writeElement(w, &msg.Hash)
  4073.                 if err != nil {
  4074.                         return err
  4075.                 }
  4076.         }
  4077.  
  4078.         return nil
  4079. }
  4080.  
  4081. func (msg *MsgReject) Command() string {
  4082.         return CmdReject
  4083. }
  4084.  
  4085. func (msg *MsgReject) MaxPayloadLength(pver uint32) uint32 {
  4086.         plen := uint32(0)
  4087.  
  4088.         if pver >= RejectVersion {
  4089.  
  4090.                 plen = MaxMessagePayload
  4091.         }
  4092.  
  4093.         return plen
  4094. }
  4095.  
  4096. func NewMsgReject(command string, code RejectCode, reason string) *MsgReject {
  4097.         return &MsgReject{
  4098.                 Cmd:    command,
  4099.                 Code:   code,
  4100.                 Reason: reason,
  4101.         }
  4102. }
  4103.  
  4104. type MsgSendHeaders struct{}
  4105.  
  4106. func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4107.         if pver < SendHeadersVersion {
  4108.                 str := fmt.Sprintf("sendheaders message invalid for protocol "+
  4109.                         "version %d", pver)
  4110.                 return messageError("MsgSendHeaders.BtcDecode", str)
  4111.         }
  4112.  
  4113.         return nil
  4114. }
  4115.  
  4116. func (msg *MsgSendHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4117.         if pver < SendHeadersVersion {
  4118.                 str := fmt.Sprintf("sendheaders message invalid for protocol "+
  4119.                         "version %d", pver)
  4120.                 return messageError("MsgSendHeaders.BtcEncode", str)
  4121.         }
  4122.  
  4123.         return nil
  4124. }
  4125.  
  4126. func (msg *MsgSendHeaders) Command() string {
  4127.         return CmdSendHeaders
  4128. }
  4129.  
  4130. func (msg *MsgSendHeaders) MaxPayloadLength(pver uint32) uint32 {
  4131.         return 0
  4132. }
  4133.  
  4134. func NewMsgSendHeaders() *MsgSendHeaders {
  4135.         return &MsgSendHeaders{}
  4136. }
  4137.  
  4138. const (
  4139.         TxVersion = 1
  4140.  
  4141.         MaxTxInSequenceNum uint32 = 0xffffffff
  4142.  
  4143.         MaxPrevOutIndex uint32 = 0xffffffff
  4144.  
  4145.         SequenceLockTimeDisabled = 1 << 31
  4146.  
  4147.         SequenceLockTimeIsSeconds = 1 << 22
  4148.  
  4149.         SequenceLockTimeMask = 0x0000ffff
  4150.  
  4151.         SequenceLockTimeGranularity = 9
  4152.  
  4153.         defaultTxInOutAlloc = 15
  4154.  
  4155.         minTxInPayload = 9 + HashSize
  4156.  
  4157.         maxTxInPerMessage = (MaxMessagePayload / minTxInPayload) + 1
  4158.  
  4159.         MinTxOutPayload = 9
  4160.  
  4161.         maxTxOutPerMessage = (MaxMessagePayload / MinTxOutPayload) + 1
  4162.  
  4163.         minTxPayload = 10
  4164.  
  4165.         freeListMaxScriptSize = 512
  4166.  
  4167.         freeListMaxItems = 12500
  4168.  
  4169.         maxWitnessItemsPerInput = 500000
  4170.  
  4171.         maxWitnessItemSize = 11000
  4172. )
  4173.  
  4174. const TxFlagMarker = 0x00
  4175.  
  4176. type TxFlag = byte
  4177.  
  4178. const (
  4179.         WitnessFlag TxFlag = 0x01
  4180. )
  4181.  
  4182. type scriptFreeList chan []byte
  4183.  
  4184. func (c scriptFreeList) Borrow(size uint64) []byte {
  4185.         if size > freeListMaxScriptSize {
  4186.                 return make([]byte, size)
  4187.         }
  4188.  
  4189.         var buf []byte
  4190.         select {
  4191.         case buf = <-c:
  4192.         default:
  4193.                 buf = make([]byte, freeListMaxScriptSize)
  4194.         }
  4195.         return buf[:size]
  4196. }
  4197.  
  4198. func (c scriptFreeList) Return(buf []byte) {
  4199.  
  4200.         if cap(buf) != freeListMaxScriptSize {
  4201.                 return
  4202.         }
  4203.  
  4204.         select {
  4205.         case c <- buf:
  4206.         default:
  4207.  
  4208.         }
  4209. }
  4210.  
  4211. var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)
  4212.  
  4213. type OutPoint struct {
  4214.         Hash  Hash
  4215.         Index uint32
  4216. }
  4217.  
  4218. func NewOutPoint(hash *Hash, index uint32) *OutPoint {
  4219.         return &OutPoint{
  4220.                 Hash:  *hash,
  4221.                 Index: index,
  4222.         }
  4223. }
  4224.  
  4225. func (o OutPoint) String() string {
  4226.  
  4227.         buf := make([]byte, 2*HashSize+1, 2*HashSize+1+10)
  4228.         copy(buf, o.Hash.String())
  4229.         buf[2*HashSize] = ':'
  4230.         buf = strconv.AppendUint(buf, uint64(o.Index), 10)
  4231.         return string(buf)
  4232. }
  4233.  
  4234. type TxIn struct {
  4235.         PreviousOutPoint OutPoint
  4236.         SignatureScript  []byte
  4237.         Witness          TxWitness
  4238.         Sequence         uint32
  4239. }
  4240.  
  4241. func (t *TxIn) SerializeSize() int {
  4242.  
  4243.         return 40 + VarIntSerializeSize(uint64(len(t.SignatureScript))) +
  4244.                 len(t.SignatureScript)
  4245. }
  4246.  
  4247. func NewTxIn(prevOut *OutPoint, signatureScript []byte, witness [][]byte) *TxIn {
  4248.         return &TxIn{
  4249.                 PreviousOutPoint: *prevOut,
  4250.                 SignatureScript:  signatureScript,
  4251.                 Witness:          witness,
  4252.                 Sequence:         MaxTxInSequenceNum,
  4253.         }
  4254. }
  4255.  
  4256. type TxWitness [][]byte
  4257.  
  4258. func (t TxWitness) SerializeSize() int {
  4259.  
  4260.         n := VarIntSerializeSize(uint64(len(t)))
  4261.  
  4262.         for _, witItem := range t {
  4263.                 n += VarIntSerializeSize(uint64(len(witItem)))
  4264.                 n += len(witItem)
  4265.         }
  4266.  
  4267.         return n
  4268. }
  4269.  
  4270. type TxOut struct {
  4271.         Value    int64
  4272.         PkScript []byte
  4273. }
  4274.  
  4275. func (t *TxOut) SerializeSize() int {
  4276.  
  4277.         return 8 + VarIntSerializeSize(uint64(len(t.PkScript))) + len(t.PkScript)
  4278. }
  4279.  
  4280. func NewTxOut(value int64, pkScript []byte) *TxOut {
  4281.         return &TxOut{
  4282.                 Value:    value,
  4283.                 PkScript: pkScript,
  4284.         }
  4285. }
  4286.  
  4287. type MsgTx struct {
  4288.         Version  int32
  4289.         TxIn     []*TxIn
  4290.         TxOut    []*TxOut
  4291.         LockTime uint32
  4292. }
  4293.  
  4294. func (msg *MsgTx) AddTxIn(ti *TxIn) {
  4295.         msg.TxIn = append(msg.TxIn, ti)
  4296. }
  4297.  
  4298. func (msg *MsgTx) AddTxOut(to *TxOut) {
  4299.         msg.TxOut = append(msg.TxOut, to)
  4300. }
  4301.  
  4302. func (msg *MsgTx) TxHash() Hash {
  4303.  
  4304.         buf := bytes.NewBuffer(make([]byte, 0, msg.SerializeSizeStripped()))
  4305.         _ = msg.SerializeNoWitness(buf)
  4306.         return DoubleHashH(buf.Bytes())
  4307. }
  4308.  
  4309. func (msg *MsgTx) WitnessHash() Hash {
  4310.         if msg.HasWitness() {
  4311.                 buf := bytes.NewBuffer(make([]byte, 0, msg.SerializeSize()))
  4312.                 _ = msg.Serialize(buf)
  4313.                 return DoubleHashH(buf.Bytes())
  4314.         }
  4315.  
  4316.         return msg.TxHash()
  4317. }
  4318.  
  4319. func (msg *MsgTx) Copy() *MsgTx {
  4320.  
  4321.         newTx := MsgTx{
  4322.                 Version:  msg.Version,
  4323.                 TxIn:     make([]*TxIn, 0, len(msg.TxIn)),
  4324.                 TxOut:    make([]*TxOut, 0, len(msg.TxOut)),
  4325.                 LockTime: msg.LockTime,
  4326.         }
  4327.  
  4328.         for _, oldTxIn := range msg.TxIn {
  4329.  
  4330.                 oldOutPoint := oldTxIn.PreviousOutPoint
  4331.                 newOutPoint := OutPoint{}
  4332.                 newOutPoint.Hash.SetBytes(oldOutPoint.Hash[:])
  4333.                 newOutPoint.Index = oldOutPoint.Index
  4334.  
  4335.                 var newScript []byte
  4336.                 oldScript := oldTxIn.SignatureScript
  4337.                 oldScriptLen := len(oldScript)
  4338.                 if oldScriptLen > 0 {
  4339.                         newScript = make([]byte, oldScriptLen)
  4340.                         copy(newScript, oldScript[:oldScriptLen])
  4341.                 }
  4342.  
  4343.                 newTxIn := TxIn{
  4344.                         PreviousOutPoint: newOutPoint,
  4345.                         SignatureScript:  newScript,
  4346.                         Sequence:         oldTxIn.Sequence,
  4347.                 }
  4348.  
  4349.                 if len(oldTxIn.Witness) != 0 {
  4350.  
  4351.                         newTxIn.Witness = make([][]byte, len(oldTxIn.Witness))
  4352.                         for i, oldItem := range oldTxIn.Witness {
  4353.                                 newItem := make([]byte, len(oldItem))
  4354.                                 copy(newItem, oldItem)
  4355.                                 newTxIn.Witness[i] = newItem
  4356.                         }
  4357.                 }
  4358.  
  4359.                 newTx.TxIn = append(newTx.TxIn, &newTxIn)
  4360.         }
  4361.  
  4362.         for _, oldTxOut := range msg.TxOut {
  4363.  
  4364.                 var newScript []byte
  4365.                 oldScript := oldTxOut.PkScript
  4366.                 oldScriptLen := len(oldScript)
  4367.                 if oldScriptLen > 0 {
  4368.                         newScript = make([]byte, oldScriptLen)
  4369.                         copy(newScript, oldScript[:oldScriptLen])
  4370.                 }
  4371.  
  4372.                 newTxOut := TxOut{
  4373.                         Value:    oldTxOut.Value,
  4374.                         PkScript: newScript,
  4375.                 }
  4376.                 newTx.TxOut = append(newTx.TxOut, &newTxOut)
  4377.         }
  4378.  
  4379.         return &newTx
  4380. }
  4381.  
  4382. func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4383.         version, err := binarySerializer.Uint32(r, littleEndian)
  4384.         if err != nil {
  4385.                 return err
  4386.         }
  4387.         msg.Version = int32(version)
  4388.  
  4389.         count, err := ReadVarInt(r, pver)
  4390.         if err != nil {
  4391.                 return err
  4392.         }
  4393.  
  4394.         var flag [1]TxFlag
  4395.         if count == TxFlagMarker && enc == WitnessEncoding {
  4396.  
  4397.                 if _, err = io.ReadFull(r, flag[:]); err != nil {
  4398.                         return err
  4399.                 }
  4400.  
  4401.                 if flag[0] != WitnessFlag {
  4402.                         str := fmt.Sprintf("witness tx but flag byte is %x", flag)
  4403.                         return messageError("MsgTx.BtcDecode", str)
  4404.                 }
  4405.  
  4406.                 count, err = ReadVarInt(r, pver)
  4407.                 if err != nil {
  4408.                         return err
  4409.                 }
  4410.         }
  4411.  
  4412.         if count > uint64(maxTxInPerMessage) {
  4413.                 str := fmt.Sprintf("too many input transactions to fit into "+
  4414.                         "max message size [count %d, max %d]", count,
  4415.                         maxTxInPerMessage)
  4416.                 return messageError("MsgTx.BtcDecode", str)
  4417.         }
  4418.  
  4419.         returnScriptBuffers := func() {
  4420.                 for _, txIn := range msg.TxIn {
  4421.                         if txIn == nil {
  4422.                                 continue
  4423.                         }
  4424.  
  4425.                         if txIn.SignatureScript != nil {
  4426.                                 scriptPool.Return(txIn.SignatureScript)
  4427.                         }
  4428.  
  4429.                         for _, witnessElem := range txIn.Witness {
  4430.                                 if witnessElem != nil {
  4431.                                         scriptPool.Return(witnessElem)
  4432.                                 }
  4433.                         }
  4434.                 }
  4435.                 for _, txOut := range msg.TxOut {
  4436.                         if txOut == nil || txOut.PkScript == nil {
  4437.                                 continue
  4438.                         }
  4439.                         scriptPool.Return(txOut.PkScript)
  4440.                 }
  4441.         }
  4442.  
  4443.         var totalScriptSize uint64
  4444.         txIns := make([]TxIn, count)
  4445.         msg.TxIn = make([]*TxIn, count)
  4446.         for i := uint64(0); i < count; i++ {
  4447.  
  4448.                 ti := &txIns[i]
  4449.                 msg.TxIn[i] = ti
  4450.                 err = readTxIn(r, pver, msg.Version, ti)
  4451.                 if err != nil {
  4452.                         returnScriptBuffers()
  4453.                         return err
  4454.                 }
  4455.                 totalScriptSize += uint64(len(ti.SignatureScript))
  4456.         }
  4457.  
  4458.         count, err = ReadVarInt(r, pver)
  4459.         if err != nil {
  4460.                 returnScriptBuffers()
  4461.                 return err
  4462.         }
  4463.  
  4464.         if count > uint64(maxTxOutPerMessage) {
  4465.                 returnScriptBuffers()
  4466.                 str := fmt.Sprintf("too many output transactions to fit into "+
  4467.                         "max message size [count %d, max %d]", count,
  4468.                         maxTxOutPerMessage)
  4469.                 return messageError("MsgTx.BtcDecode", str)
  4470.         }
  4471.  
  4472.         txOuts := make([]TxOut, count)
  4473.         msg.TxOut = make([]*TxOut, count)
  4474.         for i := uint64(0); i < count; i++ {
  4475.  
  4476.                 to := &txOuts[i]
  4477.                 msg.TxOut[i] = to
  4478.                 err = readTxOut(r, pver, msg.Version, to)
  4479.                 if err != nil {
  4480.                         returnScriptBuffers()
  4481.                         return err
  4482.                 }
  4483.                 totalScriptSize += uint64(len(to.PkScript))
  4484.         }
  4485.  
  4486.         if flag[0] != 0 && enc == WitnessEncoding {
  4487.                 for _, txin := range msg.TxIn {
  4488.  
  4489.                         witCount, err := ReadVarInt(r, pver)
  4490.                         if err != nil {
  4491.                                 returnScriptBuffers()
  4492.                                 return err
  4493.                         }
  4494.  
  4495.                         if witCount > maxWitnessItemsPerInput {
  4496.                                 returnScriptBuffers()
  4497.                                 str := fmt.Sprintf("too many witness items to fit "+
  4498.                                         "into max message size [count %d, max %d]",
  4499.                                         witCount, maxWitnessItemsPerInput)
  4500.                                 return messageError("MsgTx.BtcDecode", str)
  4501.                         }
  4502.  
  4503.                         txin.Witness = make([][]byte, witCount)
  4504.                         for j := uint64(0); j < witCount; j++ {
  4505.                                 txin.Witness[j], err = readScript(r, pver,
  4506.                                         maxWitnessItemSize, "script witness item")
  4507.                                 if err != nil {
  4508.                                         returnScriptBuffers()
  4509.                                         return err
  4510.                                 }
  4511.                                 totalScriptSize += uint64(len(txin.Witness[j]))
  4512.                         }
  4513.                 }
  4514.         }
  4515.  
  4516.         msg.LockTime, err = binarySerializer.Uint32(r, littleEndian)
  4517.         if err != nil {
  4518.                 returnScriptBuffers()
  4519.                 return err
  4520.         }
  4521.  
  4522.         var offset uint64
  4523.         scripts := make([]byte, totalScriptSize)
  4524.         for i := 0; i < len(msg.TxIn); i++ {
  4525.  
  4526.                 signatureScript := msg.TxIn[i].SignatureScript
  4527.                 copy(scripts[offset:], signatureScript)
  4528.  
  4529.                 scriptSize := uint64(len(signatureScript))
  4530.                 end := offset + scriptSize
  4531.                 msg.TxIn[i].SignatureScript = scripts[offset:end:end]
  4532.                 offset += scriptSize
  4533.  
  4534.                 scriptPool.Return(signatureScript)
  4535.  
  4536.                 for j := 0; j < len(msg.TxIn[i].Witness); j++ {
  4537.  
  4538.                         witnessElem := msg.TxIn[i].Witness[j]
  4539.                         copy(scripts[offset:], witnessElem)
  4540.  
  4541.                         witnessElemSize := uint64(len(witnessElem))
  4542.                         end := offset + witnessElemSize
  4543.                         msg.TxIn[i].Witness[j] = scripts[offset:end:end]
  4544.                         offset += witnessElemSize
  4545.  
  4546.                         scriptPool.Return(witnessElem)
  4547.                 }
  4548.         }
  4549.         for i := 0; i < len(msg.TxOut); i++ {
  4550.  
  4551.                 pkScript := msg.TxOut[i].PkScript
  4552.                 copy(scripts[offset:], pkScript)
  4553.  
  4554.                 scriptSize := uint64(len(pkScript))
  4555.                 end := offset + scriptSize
  4556.                 msg.TxOut[i].PkScript = scripts[offset:end:end]
  4557.                 offset += scriptSize
  4558.  
  4559.                 scriptPool.Return(pkScript)
  4560.         }
  4561.  
  4562.         return nil
  4563. }
  4564.  
  4565. func (msg *MsgTx) Deserialize(r io.Reader) error {
  4566.  
  4567.         return msg.BtcDecode(r, 0, WitnessEncoding)
  4568. }
  4569.  
  4570. func (msg *MsgTx) DeserializeNoWitness(r io.Reader) error {
  4571.         return msg.BtcDecode(r, 0, BaseEncoding)
  4572. }
  4573.  
  4574. func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4575.         err := binarySerializer.PutUint32(w, littleEndian, uint32(msg.Version))
  4576.         if err != nil {
  4577.                 return err
  4578.         }
  4579.  
  4580.         doWitness := enc == WitnessEncoding && msg.HasWitness()
  4581.         if doWitness {
  4582.  
  4583.                 if _, err := w.Write([]byte{TxFlagMarker, WitnessFlag}); err != nil {
  4584.                         return err
  4585.                 }
  4586.         }
  4587.  
  4588.         count := uint64(len(msg.TxIn))
  4589.         err = WriteVarInt(w, pver, count)
  4590.         if err != nil {
  4591.                 return err
  4592.         }
  4593.  
  4594.         for _, ti := range msg.TxIn {
  4595.                 err = writeTxIn(w, pver, msg.Version, ti)
  4596.                 if err != nil {
  4597.                         return err
  4598.                 }
  4599.         }
  4600.  
  4601.         count = uint64(len(msg.TxOut))
  4602.         err = WriteVarInt(w, pver, count)
  4603.         if err != nil {
  4604.                 return err
  4605.         }
  4606.  
  4607.         for _, to := range msg.TxOut {
  4608.                 err = WriteTxOut(w, pver, msg.Version, to)
  4609.                 if err != nil {
  4610.                         return err
  4611.                 }
  4612.         }
  4613.  
  4614.         if doWitness {
  4615.                 for _, ti := range msg.TxIn {
  4616.                         err = writeTxWitness(w, pver, msg.Version, ti.Witness)
  4617.                         if err != nil {
  4618.                                 return err
  4619.                         }
  4620.                 }
  4621.         }
  4622.  
  4623.         return binarySerializer.PutUint32(w, littleEndian, msg.LockTime)
  4624. }
  4625.  
  4626. func (msg *MsgTx) HasWitness() bool {
  4627.         for _, txIn := range msg.TxIn {
  4628.                 if len(txIn.Witness) != 0 {
  4629.                         return true
  4630.                 }
  4631.         }
  4632.  
  4633.         return false
  4634. }
  4635.  
  4636. func (msg *MsgTx) Serialize(w io.Writer) error {
  4637.  
  4638.         return msg.BtcEncode(w, 0, WitnessEncoding)
  4639. }
  4640.  
  4641. func (msg *MsgTx) SerializeNoWitness(w io.Writer) error {
  4642.         return msg.BtcEncode(w, 0, BaseEncoding)
  4643. }
  4644.  
  4645. func (msg *MsgTx) baseSize() int {
  4646.  
  4647.         n := 8 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
  4648.                 VarIntSerializeSize(uint64(len(msg.TxOut)))
  4649.  
  4650.         for _, txIn := range msg.TxIn {
  4651.                 n += txIn.SerializeSize()
  4652.         }
  4653.  
  4654.         for _, txOut := range msg.TxOut {
  4655.                 n += txOut.SerializeSize()
  4656.         }
  4657.  
  4658.         return n
  4659. }
  4660.  
  4661. func (msg *MsgTx) SerializeSize() int {
  4662.         n := msg.baseSize()
  4663.  
  4664.         if msg.HasWitness() {
  4665.  
  4666.                 n += 2
  4667.  
  4668.                 for _, txin := range msg.TxIn {
  4669.                         n += txin.Witness.SerializeSize()
  4670.                 }
  4671.         }
  4672.  
  4673.         return n
  4674. }
  4675.  
  4676. func (msg *MsgTx) SerializeSizeStripped() int {
  4677.         return msg.baseSize()
  4678. }
  4679.  
  4680. func (msg *MsgTx) Command() string {
  4681.         return CmdTx
  4682. }
  4683.  
  4684. func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
  4685.         return MaxBlockPayload
  4686. }
  4687.  
  4688. func (msg *MsgTx) PkScriptLocs() []int {
  4689.         numTxOut := len(msg.TxOut)
  4690.         if numTxOut == 0 {
  4691.                 return nil
  4692.         }
  4693.  
  4694.         n := 4 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
  4695.                 VarIntSerializeSize(uint64(numTxOut))
  4696.  
  4697.         if len(msg.TxIn) > 0 && msg.TxIn[0].Witness != nil {
  4698.                 n += 2
  4699.         }
  4700.  
  4701.         for _, txIn := range msg.TxIn {
  4702.                 n += txIn.SerializeSize()
  4703.         }
  4704.  
  4705.         pkScriptLocs := make([]int, numTxOut)
  4706.         for i, txOut := range msg.TxOut {
  4707.  
  4708.                 n += 8 + VarIntSerializeSize(uint64(len(txOut.PkScript)))
  4709.                 pkScriptLocs[i] = n
  4710.                 n += len(txOut.PkScript)
  4711.         }
  4712.  
  4713.         return pkScriptLocs
  4714. }
  4715.  
  4716. func NewMsgTx(version int32) *MsgTx {
  4717.         return &MsgTx{
  4718.                 Version: version,
  4719.                 TxIn:    make([]*TxIn, 0, defaultTxInOutAlloc),
  4720.                 TxOut:   make([]*TxOut, 0, defaultTxInOutAlloc),
  4721.         }
  4722. }
  4723.  
  4724. func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
  4725.         _, err := io.ReadFull(r, op.Hash[:])
  4726.         if err != nil {
  4727.                 return err
  4728.         }
  4729.  
  4730.         op.Index, err = binarySerializer.Uint32(r, littleEndian)
  4731.         return err
  4732. }
  4733.  
  4734. func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
  4735.         _, err := w.Write(op.Hash[:])
  4736.         if err != nil {
  4737.                 return err
  4738.         }
  4739.  
  4740.         return binarySerializer.PutUint32(w, littleEndian, op.Index)
  4741. }
  4742.  
  4743. func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) ([]byte, error) {
  4744.         count, err := ReadVarInt(r, pver)
  4745.         if err != nil {
  4746.                 return nil, err
  4747.         }
  4748.  
  4749.         if count > uint64(maxAllowed) {
  4750.                 str := fmt.Sprintf("%s is larger than the max allowed size "+
  4751.                         "[count %d, max %d]", fieldName, count, maxAllowed)
  4752.                 return nil, messageError("readScript", str)
  4753.         }
  4754.  
  4755.         b := scriptPool.Borrow(count)
  4756.         _, err = io.ReadFull(r, b)
  4757.         if err != nil {
  4758.                 scriptPool.Return(b)
  4759.                 return nil, err
  4760.         }
  4761.         return b, nil
  4762. }
  4763.  
  4764. func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
  4765.         err := readOutPoint(r, pver, version, &ti.PreviousOutPoint)
  4766.         if err != nil {
  4767.                 return err
  4768.         }
  4769.  
  4770.         ti.SignatureScript, err = readScript(r, pver, MaxMessagePayload,
  4771.                 "transaction input signature script")
  4772.         if err != nil {
  4773.                 return err
  4774.         }
  4775.  
  4776.         return readElement(r, &ti.Sequence)
  4777. }
  4778.  
  4779. func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn) error {
  4780.         err := writeOutPoint(w, pver, version, &ti.PreviousOutPoint)
  4781.         if err != nil {
  4782.                 return err
  4783.         }
  4784.  
  4785.         err = WriteVarBytes(w, pver, ti.SignatureScript)
  4786.         if err != nil {
  4787.                 return err
  4788.         }
  4789.  
  4790.         return binarySerializer.PutUint32(w, littleEndian, ti.Sequence)
  4791. }
  4792.  
  4793. func readTxOut(r io.Reader, pver uint32, version int32, to *TxOut) error {
  4794.         err := readElement(r, &to.Value)
  4795.         if err != nil {
  4796.                 return err
  4797.         }
  4798.  
  4799.         to.PkScript, err = readScript(r, pver, MaxMessagePayload,
  4800.                 "transaction output public key script")
  4801.         return err
  4802. }
  4803.  
  4804. func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error {
  4805.         err := binarySerializer.PutUint64(w, littleEndian, uint64(to.Value))
  4806.         if err != nil {
  4807.                 return err
  4808.         }
  4809.  
  4810.         return WriteVarBytes(w, pver, to.PkScript)
  4811. }
  4812.  
  4813. func writeTxWitness(w io.Writer, pver uint32, version int32, wit [][]byte) error {
  4814.         err := WriteVarInt(w, pver, uint64(len(wit)))
  4815.         if err != nil {
  4816.                 return err
  4817.         }
  4818.         for _, item := range wit {
  4819.                 err = WriteVarBytes(w, pver, item)
  4820.                 if err != nil {
  4821.                         return err
  4822.                 }
  4823.         }
  4824.         return nil
  4825. }
  4826.  
  4827. type MsgVerAck struct{}
  4828.  
  4829. func (msg *MsgVerAck) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4830.         return nil
  4831. }
  4832.  
  4833. func (msg *MsgVerAck) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4834.         return nil
  4835. }
  4836.  
  4837. func (msg *MsgVerAck) Command() string {
  4838.         return CmdVerAck
  4839. }
  4840.  
  4841. func (msg *MsgVerAck) MaxPayloadLength(pver uint32) uint32 {
  4842.         return 0
  4843. }
  4844.  
  4845. func NewMsgVerAck() *MsgVerAck {
  4846.         return &MsgVerAck{}
  4847. }
  4848.  
  4849. const MaxUserAgentLen = 256
  4850.  
  4851. const DefaultUserAgent = "/btc0.5.0/"
  4852.  
  4853. type MsgVersion struct {
  4854.         ProtocolVersion int32
  4855.  
  4856.         Services ServiceFlag
  4857.  
  4858.         Timestamp time.Time
  4859.  
  4860.         AddrYou NetAddress
  4861.  
  4862.         AddrMe NetAddress
  4863.  
  4864.         Nonce uint64
  4865.  
  4866.         UserAgent string
  4867.  
  4868.         LastBlock int32
  4869.  
  4870.         DisableRelayTx bool
  4871. }
  4872.  
  4873. func (msg *MsgVersion) HasService(service ServiceFlag) bool {
  4874.         return msg.Services&service == service
  4875. }
  4876.  
  4877. func (msg *MsgVersion) AddService(service ServiceFlag) {
  4878.         msg.Services |= service
  4879. }
  4880.  
  4881. func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4882.         buf, ok := r.(*bytes.Buffer)
  4883.         if !ok {
  4884.                 return fmt.Errorf("MsgVersion.BtcDecode reader is not a " +
  4885.                         "*bytes.Buffer")
  4886.         }
  4887.  
  4888.         err := readElements(buf, &msg.ProtocolVersion, &msg.Services,
  4889.                 (*int64Time)(&msg.Timestamp))
  4890.         if err != nil {
  4891.                 return err
  4892.         }
  4893.  
  4894.         err = readNetAddress(buf, pver, &msg.AddrYou, false)
  4895.         if err != nil {
  4896.                 return err
  4897.         }
  4898.  
  4899.         if buf.Len() > 0 {
  4900.                 err = readNetAddress(buf, pver, &msg.AddrMe, false)
  4901.                 if err != nil {
  4902.                         return err
  4903.                 }
  4904.         }
  4905.         if buf.Len() > 0 {
  4906.                 err = readElement(buf, &msg.Nonce)
  4907.                 if err != nil {
  4908.                         return err
  4909.                 }
  4910.         }
  4911.         if buf.Len() > 0 {
  4912.                 userAgent, err := ReadVarString(buf, pver)
  4913.                 if err != nil {
  4914.                         return err
  4915.                 }
  4916.                 err = validateUserAgent(userAgent)
  4917.                 if err != nil {
  4918.                         return err
  4919.                 }
  4920.                 msg.UserAgent = userAgent
  4921.         }
  4922.  
  4923.         if buf.Len() > 0 {
  4924.                 err = readElement(buf, &msg.LastBlock)
  4925.                 if err != nil {
  4926.                         return err
  4927.                 }
  4928.         }
  4929.  
  4930.         if buf.Len() > 0 {
  4931.  
  4932.                 var relayTx bool
  4933.                 readElement(r, &relayTx)
  4934.                 msg.DisableRelayTx = !relayTx
  4935.         }
  4936.  
  4937.         return nil
  4938. }
  4939.  
  4940. func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4941.         err := validateUserAgent(msg.UserAgent)
  4942.         if err != nil {
  4943.                 return err
  4944.         }
  4945.  
  4946.         err = writeElements(w, msg.ProtocolVersion, msg.Services,
  4947.                 msg.Timestamp.Unix())
  4948.         if err != nil {
  4949.                 return err
  4950.         }
  4951.  
  4952.         err = writeNetAddress(w, pver, &msg.AddrYou, false)
  4953.         if err != nil {
  4954.                 return err
  4955.         }
  4956.  
  4957.         err = writeNetAddress(w, pver, &msg.AddrMe, false)
  4958.         if err != nil {
  4959.                 return err
  4960.         }
  4961.  
  4962.         err = writeElement(w, msg.Nonce)
  4963.         if err != nil {
  4964.                 return err
  4965.         }
  4966.  
  4967.         err = WriteVarString(w, pver, msg.UserAgent)
  4968.         if err != nil {
  4969.                 return err
  4970.         }
  4971.  
  4972.         err = writeElement(w, msg.LastBlock)
  4973.         if err != nil {
  4974.                 return err
  4975.         }
  4976.  
  4977.         if pver >= BIP0037Version {
  4978.                 err = writeElement(w, !msg.DisableRelayTx)
  4979.                 if err != nil {
  4980.                         return err
  4981.                 }
  4982.         }
  4983.         return nil
  4984. }
  4985.  
  4986. func (msg *MsgVersion) Command() string {
  4987.         return CmdVersion
  4988. }
  4989.  
  4990. func (msg *MsgVersion) MaxPayloadLength(pver uint32) uint32 {
  4991.  
  4992.         return 33 + (maxNetAddressPayload(pver) * 2) + MaxVarIntPayload +
  4993.                 MaxUserAgentLen
  4994. }
  4995.  
  4996. func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
  4997.         lastBlock int32) *MsgVersion {
  4998.  
  4999.         return &MsgVersion{
  5000.                 ProtocolVersion: int32(ProtocolVersion),
  5001.                 Services:        0,
  5002.                 Timestamp:       time.Unix(time.Now().Unix(), 0),
  5003.                 AddrYou:         *you,
  5004.                 AddrMe:          *me,
  5005.                 Nonce:           nonce,
  5006.                 UserAgent:       DefaultUserAgent,
  5007.                 LastBlock:       lastBlock,
  5008.                 DisableRelayTx:  false,
  5009.         }
  5010. }
  5011.  
  5012. func validateUserAgent(userAgent string) error {
  5013.         if len(userAgent) > MaxUserAgentLen {
  5014.                 str := fmt.Sprintf("user agent too long [len %v, max %v]",
  5015.                         len(userAgent), MaxUserAgentLen)
  5016.                 return messageError("MsgVersion", str)
  5017.         }
  5018.         return nil
  5019. }
  5020.  
  5021. func (msg *MsgVersion) AddUserAgent(name string, version string,
  5022.         comments ...string) error {
  5023.  
  5024.         newUserAgent := fmt.Sprintf("%s:%s", name, version)
  5025.         if len(comments) != 0 {
  5026.                 newUserAgent = fmt.Sprintf("%s(%s)", newUserAgent,
  5027.                         strings.Join(comments, "; "))
  5028.         }
  5029.         newUserAgent = fmt.Sprintf("%s%s/", msg.UserAgent, newUserAgent)
  5030.         err := validateUserAgent(newUserAgent)
  5031.         if err != nil {
  5032.                 return err
  5033.         }
  5034.         msg.UserAgent = newUserAgent
  5035.         return nil
  5036. }
  5037.  
  5038. var myMutex sync.RWMutex
  5039. var myChain map[uint64]*Hash
  5040. var myHeaders map[Hash]*BlockHeader
  5041. var myTotal uint64
  5042.  
  5043. func init() {
  5044.         myChain = make(map[uint64]*Hash)
  5045.         myHeaders = make(map[Hash]*BlockHeader)
  5046. }
  5047.  
  5048. func myPut(bh *Hash, height uint64) {
  5049.         myMutex.Lock()
  5050.         if height == myTotal {
  5051.                 myChain[height] = bh
  5052.         }
  5053.         myMutex.Unlock()
  5054. }
  5055.  
  5056. func myGet(height uint64) (bh *Hash) {
  5057.         myMutex.RLock()
  5058.         bh = myChain[height]
  5059.         myMutex.RUnlock()
  5060.         return bh
  5061. }
  5062.  
  5063. func myHas(bh *Hash) (has bool) {
  5064.         myMutex.RLock()
  5065.         has = myHeaders[*bh] != nil
  5066.         myMutex.RUnlock()
  5067.         return has
  5068. }
  5069.  
  5070. func myGoodReorg(h uint64, depth uint64, bh *BlockHeader) bool {
  5071.         return h >= depth && bh != nil
  5072. }
  5073.  
  5074. func myAttach(bh *BlockHeader, reorg func(a, b *Hash)) {
  5075.         hash := bh.BlockHash()
  5076.         myMutex.Lock()
  5077.         myHeaders[hash] = bh
  5078.  
  5079.         if current, ok := myChain[myTotal]; ok && *current == bh.PrevBlock {
  5080.                 myTotal++
  5081.                 myChain[myTotal] = &hash
  5082.         }
  5083.  
  5084.         var reorg1 = myHeaders[bh.PrevBlock]
  5085.  
  5086.         if myGoodReorg(myTotal, 1, reorg1) {
  5087.                 if current, ok := myChain[myTotal-1]; ok && *current == reorg1.PrevBlock {
  5088.  
  5089.                         delete(myChain, myTotal)
  5090.                         myTotal--
  5091.                         myChain[myTotal] = &bh.PrevBlock
  5092.  
  5093.                         reorg(&bh.PrevBlock, &hash)
  5094.  
  5095.                         myTotal++
  5096.                         myChain[myTotal] = &hash
  5097.                 }
  5098.         }
  5099.  
  5100.         myMutex.Unlock()
  5101. }
  5102.  
  5103. func myTotalBlocksEstimate() int64 {
  5104.         myMutex.RLock()
  5105.         var tot = myTotal
  5106.         myMutex.RUnlock()
  5107.         const NOW_TIME = 1602787294
  5108.         const NOW_BLOCKS = 652888
  5109.         if tot < NOW_BLOCKS {
  5110.                 return NOW_BLOCKS + ((time.Now().Unix() - NOW_TIME) / 600)
  5111.         } else {
  5112.                 myMutex.RLock()
  5113.                 var blk = myHeaders[*myChain[tot]]
  5114.                 var blktime = blk.Timestamp
  5115.                 myMutex.RUnlock()
  5116.                 return int64(tot + ((uint64(time.Now().Unix()) - uint64(blktime.Unix())) / 600))
  5117.         }
  5118. }
  5119.  
  5120. func myStatus(fun func(tot uint64, hsh *Hash)) uint64 {
  5121.         myMutex.RLock()
  5122.  
  5123.         var tot = myTotal
  5124.         var hsh = myChain[myTotal]
  5125.  
  5126.         if fun != nil {
  5127.                 fun(tot, hsh)
  5128.         }
  5129.  
  5130.         myMutex.RUnlock()
  5131.         return tot
  5132. }
  5133.  
  5134. func myLocator(burst, depth byte, fun func(uint64, *Hash)) {
  5135.         myMutex.RLock()
  5136.         var i = int64(myTotal) - int64(depth)
  5137.         if i < 0 {
  5138.                 i = 0
  5139.         }
  5140.         myMutex.RUnlock()
  5141.  
  5142.         myLocatorHeight(i, burst, fun)
  5143. }
  5144.  
  5145. func myLocatorHeight(i int64, burst byte, fun func(uint64, *Hash)) {
  5146.  
  5147.         for j := i; j > i-int64(burst) && j >= 0; j-- {
  5148.                 myMutex.RLock()
  5149.                 hash := myChain[uint64(j)]
  5150.                 myMutex.RUnlock()
  5151.                 fun(uint64(j), hash)
  5152.         }
  5153.         var k int64 = 2
  5154.         for j := i - int64(burst) - 1; j >= 0; j -= k {
  5155.                 k *= 2
  5156.                 myMutex.RLock()
  5157.                 hash := myChain[uint64(j)]
  5158.                 myMutex.RUnlock()
  5159.                 fun(uint64(j), hash)
  5160.         }
  5161.  
  5162. }
  5163.  
  5164. func maxNetAddressPayload(pver uint32) uint32 {
  5165.  
  5166.         plen := uint32(26)
  5167.  
  5168.         if pver >= NetAddressTimeVersion {
  5169.  
  5170.                 plen += 4
  5171.         }
  5172.  
  5173.         return plen
  5174. }
  5175.  
  5176. type NetAddress struct {
  5177.         Timestamp time.Time
  5178.  
  5179.         Services ServiceFlag
  5180.  
  5181.         IP net.IP
  5182.  
  5183.         Port uint16
  5184. }
  5185.  
  5186. func (na *NetAddress) HasService(service ServiceFlag) bool {
  5187.         return na.Services&service == service
  5188. }
  5189.  
  5190. func (na *NetAddress) AddService(service ServiceFlag) {
  5191.         na.Services |= service
  5192. }
  5193.  
  5194. func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
  5195.         return NewNetAddressTimestamp(time.Now(), services, ip, port)
  5196. }
  5197.  
  5198. func NewNetAddressTimestamp(
  5199.         timestamp time.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
  5200.  
  5201.         na := NetAddress{
  5202.                 Timestamp: time.Unix(timestamp.Unix(), 0),
  5203.                 Services:  services,
  5204.                 IP:        ip,
  5205.                 Port:      port,
  5206.         }
  5207.         return &na
  5208. }
  5209.  
  5210. func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
  5211.         return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
  5212. }
  5213.  
  5214. func readNetAddress(r io.Reader, pver uint32, na *NetAddress, ts bool) error {
  5215.         var ip [16]byte
  5216.  
  5217.         if ts && pver >= NetAddressTimeVersion {
  5218.                 err := readElement(r, (*uint32Time)(&na.Timestamp))
  5219.                 if err != nil {
  5220.                         return err
  5221.                 }
  5222.         }
  5223.  
  5224.         err := readElements(r, &na.Services, &ip)
  5225.         if err != nil {
  5226.                 return err
  5227.         }
  5228.  
  5229.         port, err := binarySerializer.Uint16(r, bigEndian)
  5230.         if err != nil {
  5231.                 return err
  5232.         }
  5233.  
  5234.         *na = NetAddress{
  5235.                 Timestamp: na.Timestamp,
  5236.                 Services:  na.Services,
  5237.                 IP:        net.IP(ip[:]),
  5238.                 Port:      port,
  5239.         }
  5240.         return nil
  5241. }
  5242.  
  5243. func writeNetAddress(w io.Writer, pver uint32, na *NetAddress, ts bool) error {
  5244.  
  5245.         if ts && pver >= NetAddressTimeVersion {
  5246.                 err := writeElement(w, uint32(na.Timestamp.Unix()))
  5247.                 if err != nil {
  5248.                         return err
  5249.                 }
  5250.         }
  5251.  
  5252.         var ip [16]byte
  5253.         if na.IP != nil {
  5254.                 copy(ip[:], na.IP.To16())
  5255.         }
  5256.         err := writeElements(w, na.Services, ip)
  5257.         if err != nil {
  5258.                 return err
  5259.         }
  5260.  
  5261.         return binary.Write(w, bigEndian, na.Port)
  5262. }
  5263.  
  5264. var previously_seen_mutex sync.Mutex
  5265. var previously_seen map[[32]byte]struct{}
  5266.  
  5267. func init() {
  5268.         previously_seen_mutex.Lock()
  5269.         previously_seen = make(map[[32]byte]struct{})
  5270.         previously_seen_mutex.Unlock()
  5271. }
  5272.  
  5273. func is_previously_unseen_make_seen(hash *[32]byte) bool {
  5274.         previously_seen_mutex.Lock()
  5275.         if _, ok := previously_seen[*hash]; ok {
  5276.                 previously_seen_mutex.Unlock()
  5277.  
  5278.                 return false
  5279.         } else {
  5280.  
  5281.                 previously_seen[*hash] = struct{}{}
  5282.  
  5283.                 previously_seen_mutex.Unlock()
  5284.                 return true
  5285.         }
  5286.  
  5287. }
  5288.  
  5289. type Bar struct {
  5290.         percent int64
  5291.         beg     int64
  5292.         cur     int64
  5293.         total   int64
  5294.         rate    string
  5295.         Graph   string
  5296.         Unit    string
  5297. }
  5298.  
  5299. func (bar *Bar) getPercent() int64 {
  5300.         if bar.total == bar.beg {
  5301.                 return 0
  5302.         }
  5303.  
  5304.         return 100 * (bar.cur - bar.beg) / (bar.total - bar.beg)
  5305. }
  5306. func (bar *Bar) Replay() {
  5307.  
  5308.         bar.Play(bar.beg, bar.cur, bar.total)
  5309. }
  5310. func (bar *Bar) Play(beg, cur, total int64) {
  5311.         fmt.Print("\r")
  5312.         bar.play(beg, cur, total)
  5313. }
  5314. func (bar *Bar) play(beg, cur, total int64) {
  5315.         bar.beg = beg
  5316.         bar.cur = cur
  5317.         bar.total = total
  5318.         last := bar.percent
  5319.         bar.percent = bar.getPercent()
  5320.         if bar.percent != last && bar.percent%2 == 0 {
  5321.                 bar.rate += bar.Graph
  5322.         }
  5323.         fmt.Printf("[%-50s]%3d%% %8d/%d %s", bar.rate, bar.percent, bar.cur, bar.total, bar.Unit)
  5324. }
  5325. func (bar *Bar) Hide() {
  5326.         fmt.Print("\r\x1B[K\r")
  5327. }
  5328.  
  5329. func (bar *Bar) Finish() {
  5330.         fmt.Println("")
  5331. }
  5332.  
  5333. func (bar *Bar) Restart(unit string) {
  5334.         bar.rate = ""
  5335.         bar.Unit = unit
  5336. }
  5337.  
  5338. const (
  5339.         ProtocolVersion uint32 = 70013
  5340.  
  5341.         MultipleAddressVersion uint32 = 209
  5342.  
  5343.         NetAddressTimeVersion uint32 = 31402
  5344.  
  5345.         BIP0031Version uint32 = 60000
  5346.  
  5347.         BIP0035Version uint32 = 60002
  5348.  
  5349.         BIP0037Version uint32 = 70001
  5350.  
  5351.         RejectVersion uint32 = 70002
  5352.  
  5353.         BIP0111Version uint32 = 70011
  5354.  
  5355.         SendHeadersVersion uint32 = 70012
  5356.  
  5357.         FeeFilterVersion uint32 = 70013
  5358. )
  5359.  
  5360. type ServiceFlag uint64
  5361.  
  5362. const (
  5363.         SFNodeNetwork ServiceFlag = 1 << iota
  5364.  
  5365.         SFNodeGetUTXO
  5366.  
  5367.         SFNodeBloom
  5368.  
  5369.         SFNodeWitness
  5370.  
  5371.         SFNodeXthin
  5372.  
  5373.         SFNodeBit5
  5374.  
  5375.         SFNodeCF
  5376.  
  5377.         SFNode2X
  5378. )
  5379.  
  5380. var sfStrings = map[ServiceFlag]string{
  5381.         SFNodeNetwork: "SFNodeNetwork",
  5382.         SFNodeGetUTXO: "SFNodeGetUTXO",
  5383.         SFNodeBloom:   "SFNodeBloom",
  5384.         SFNodeWitness: "SFNodeWitness",
  5385.         SFNodeXthin:   "SFNodeXthin",
  5386.         SFNodeBit5:    "SFNodeBit5",
  5387.         SFNodeCF:      "SFNodeCF",
  5388.         SFNode2X:      "SFNode2X",
  5389. }
  5390.  
  5391. var orderedSFStrings = []ServiceFlag{
  5392.         SFNodeNetwork,
  5393.         SFNodeGetUTXO,
  5394.         SFNodeBloom,
  5395.         SFNodeWitness,
  5396.         SFNodeXthin,
  5397.         SFNodeBit5,
  5398.         SFNodeCF,
  5399.         SFNode2X,
  5400. }
  5401.  
  5402. func (f ServiceFlag) String() string {
  5403.  
  5404.         if f == 0 {
  5405.                 return "0x0"
  5406.         }
  5407.  
  5408.         s := ""
  5409.         for _, flag := range orderedSFStrings {
  5410.                 if f&flag == flag {
  5411.                         s += sfStrings[flag] + "|"
  5412.                         f -= flag
  5413.                 }
  5414.         }
  5415.  
  5416.         s = strings.TrimRight(s, "|")
  5417.         if f != 0 {
  5418.                 s += "|0x" + strconv.FormatUint(uint64(f), 16)
  5419.         }
  5420.         s = strings.TrimLeft(s, "|")
  5421.         return s
  5422. }
  5423.  
  5424. type BitcoinNet uint32
  5425.  
  5426. const (
  5427.         MainNet BitcoinNet = 0xd9b4bef9
  5428.  
  5429.         TestNet BitcoinNet = 0xdab5bffa
  5430.  
  5431.         TestNet3 BitcoinNet = 0x0709110b
  5432.  
  5433.         SimNet BitcoinNet = 0x12141c16
  5434. )
  5435.  
  5436. var bnStrings = map[BitcoinNet]string{
  5437.         MainNet:  "MainNet",
  5438.         TestNet:  "TestNet",
  5439.         TestNet3: "TestNet3",
  5440.         SimNet:   "SimNet",
  5441. }
  5442.  
  5443. func (n BitcoinNet) String() string {
  5444.         if s, ok := bnStrings[n]; ok {
  5445.                 return s
  5446.         }
  5447.  
  5448.         return fmt.Sprintf("Unknown BitcoinNet (%d)", uint32(n))
  5449. }
  5450.  
  5451. var shutdown_mutex sync.Mutex
  5452. var shutdown bool
  5453. var shutdown_conn *net.Conn
  5454.  
  5455. func SetupCloseHandler(conn *net.Conn) {
  5456.         shutdown_mutex.Lock()
  5457.         shutdown_conn = conn
  5458.         shutdown_mutex.Unlock()
  5459.  
  5460.         c := make(chan os.Signal)
  5461.         signal.Notify(c, os.Interrupt, syscall.SIGTERM)
  5462.         go func() {
  5463.                 <-c
  5464.                 shutdown_mutex.Lock()
  5465.                 shutdown = true
  5466.                 if shutdown_conn != nil {
  5467.                         (*shutdown_conn).Close()
  5468.                         shutdown_conn = nil
  5469.                 }
  5470.                 shutdown_mutex.Unlock()
  5471.         }()
  5472. }

Paste is for source code and general debugging text.

Login or Register to edit, delete and keep track of your pastes and more.

Raw Paste