API tools faq
paste
Advertisement
Guest User

commits.db downloader

a guest
Oct 17th, 2020
1,765
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Go 115.87 KB | None | 0 0
raw download clone embed print report
  1. //HAIRCOMB DOWNLOADER
  2. package main
  3.  
  4. import "crypto/aes"
  5. import "crypto/sha256"
  6.  
  7. import (
  8.     "bytes"
  9.     "io"
  10.     "time"
  11. )
  12.  
  13. import (
  14.     "crypto/rand"
  15.     "encoding/binary"
  16.     "fmt"
  17.     "math"
  18. )
  19.  
  20. import "net"
  21. import "sync"
  22.  
  23. import "log"
  24.  
  25. import (
  26.     "encoding/hex"
  27. )
  28.  
  29. import "os"
  30.  
  31. import (
  32.     "unicode/utf8"
  33. )
  34.  
  35. import (
  36.     "errors"
  37. )
  38.  
  39. import "os/signal"
  40. import "syscall"
  41.  
  42. import (
  43.     "strconv"
  44. )
  45.  
  46. import (
  47.     "strings"
  48. )
  49.  
  50. func aes_checksum(buf, load_aes *[32]byte) {
  51.     var aestmp [32]byte
  52.  
  53.     var aes, err5 = aes.NewCipher(buf[0:])
  54.     if err5 != nil {
  55.         panic("cannot use aes")
  56.     }
  57.  
  58.     aes.Encrypt(aestmp[0:16], load_aes[0:16])
  59.     aes.Decrypt(aestmp[16:32], load_aes[16:32])
  60.  
  61.     for i := 8; i < 16; i++ {
  62.         aestmp[i], aestmp[8+i] = aestmp[8+i], aestmp[i]
  63.     }
  64.  
  65.     aes.Encrypt(load_aes[0:16], aestmp[0:16])
  66.     aes.Decrypt(load_aes[16:32], aestmp[16:32])
  67. }
  68.  
  69. func BCDFromUint(value uint64, buf []byte) {
  70.     if value > 0 {
  71.         remainder := value
  72.         for pos := len(buf) - 1; pos >= 0 && remainder > 0; pos-- {
  73.             tail := byte(remainder % 100)
  74.             hi, lo := tail/10, tail%10
  75.             buf[pos] = byte(hi<<4 + lo)
  76.             remainder = remainder / 100
  77.         }
  78.     }
  79. }
  80.  
  81. const MaxBlockHeaderPayload = 16 + (HashSize * 2)
  82.  
  83. type BlockHeader struct {
  84.     Version int32
  85.  
  86.     PrevBlock Hash
  87.  
  88.     MerkleRoot Hash
  89.  
  90.     Timestamp time.Time
  91.  
  92.     Bits uint32
  93.  
  94.     Nonce uint32
  95. }
  96.  
  97. const blockHeaderLen = 80
  98.  
  99. func (h *BlockHeader) BlockHash() Hash {
  100.  
  101.     buf := bytes.NewBuffer(make([]byte, 0, MaxBlockHeaderPayload))
  102.     _ = writeBlockHeader(buf, 0, h)
  103.  
  104.     return DoubleHashH(buf.Bytes())
  105. }
  106.  
  107. func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  108.     return readBlockHeader(r, pver, h)
  109. }
  110.  
  111. func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  112.     return writeBlockHeader(w, pver, h)
  113. }
  114.  
  115. func (h *BlockHeader) Deserialize(r io.Reader) error {
  116.  
  117.     return readBlockHeader(r, 0, h)
  118. }
  119.  
  120. func (h *BlockHeader) Serialize(w io.Writer) error {
  121.  
  122.     return writeBlockHeader(w, 0, h)
  123. }
  124.  
  125. func NewBlockHeader(version int32, prevHash, merkleRootHash *Hash,
  126.     bits uint32, nonce uint32) *BlockHeader {
  127.  
  128.     return &BlockHeader{
  129.         Version:    version,
  130.         PrevBlock:  *prevHash,
  131.         MerkleRoot: *merkleRootHash,
  132.         Timestamp:  time.Unix(time.Now().Unix(), 0),
  133.         Bits:       bits,
  134.         Nonce:      nonce,
  135.     }
  136. }
  137.  
  138. func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
  139.     return readElements(r, &bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
  140.         (*uint32Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
  141. }
  142.  
  143. func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
  144.     sec := uint32(bh.Timestamp.Unix())
  145.     return writeElements(w, bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
  146.         sec, bh.Bits, bh.Nonce)
  147. }
  148.  
  149. const (
  150.     MaxVarIntPayload = 9
  151.  
  152.     binaryFreeListMaxItems = 1024
  153. )
  154.  
  155. var (
  156.     littleEndian = binary.LittleEndian
  157.  
  158.     bigEndian = binary.BigEndian
  159. )
  160.  
  161. type binaryFreeList chan []byte
  162.  
  163. func (l binaryFreeList) Borrow() []byte {
  164.     var buf []byte
  165.     select {
  166.     case buf = <-l:
  167.     default:
  168.         buf = make([]byte, 8)
  169.     }
  170.     return buf[:8]
  171. }
  172.  
  173. func (l binaryFreeList) Return(buf []byte) {
  174.     select {
  175.     case l <- buf:
  176.     default:
  177.  
  178.     }
  179. }
  180.  
  181. func (l binaryFreeList) Uint8(r io.Reader) (uint8, error) {
  182.     buf := l.Borrow()[:1]
  183.     if _, err := io.ReadFull(r, buf); err != nil {
  184.         l.Return(buf)
  185.         return 0, err
  186.     }
  187.     rv := buf[0]
  188.     l.Return(buf)
  189.     return rv, nil
  190. }
  191.  
  192. func (l binaryFreeList) Uint16(r io.Reader, byteOrder binary.ByteOrder) (uint16, error) {
  193.     buf := l.Borrow()[:2]
  194.     if _, err := io.ReadFull(r, buf); err != nil {
  195.         l.Return(buf)
  196.         return 0, err
  197.     }
  198.     rv := byteOrder.Uint16(buf)
  199.     l.Return(buf)
  200.     return rv, nil
  201. }
  202.  
  203. func (l binaryFreeList) Uint32(r io.Reader, byteOrder binary.ByteOrder) (uint32, error) {
  204.     buf := l.Borrow()[:4]
  205.     if _, err := io.ReadFull(r, buf); err != nil {
  206.         l.Return(buf)
  207.         return 0, err
  208.     }
  209.     rv := byteOrder.Uint32(buf)
  210.     l.Return(buf)
  211.     return rv, nil
  212. }
  213.  
  214. func (l binaryFreeList) Uint64(r io.Reader, byteOrder binary.ByteOrder) (uint64, error) {
  215.     buf := l.Borrow()[:8]
  216.     if _, err := io.ReadFull(r, buf); err != nil {
  217.         l.Return(buf)
  218.         return 0, err
  219.     }
  220.     rv := byteOrder.Uint64(buf)
  221.     l.Return(buf)
  222.     return rv, nil
  223. }
  224.  
  225. func (l binaryFreeList) PutUint8(w io.Writer, val uint8) error {
  226.     buf := l.Borrow()[:1]
  227.     buf[0] = val
  228.     _, err := w.Write(buf)
  229.     l.Return(buf)
  230.     return err
  231. }
  232.  
  233. func (l binaryFreeList) PutUint16(w io.Writer, byteOrder binary.ByteOrder, val uint16) error {
  234.     buf := l.Borrow()[:2]
  235.     byteOrder.PutUint16(buf, val)
  236.     _, err := w.Write(buf)
  237.     l.Return(buf)
  238.     return err
  239. }
  240.  
  241. func (l binaryFreeList) PutUint32(w io.Writer, byteOrder binary.ByteOrder, val uint32) error {
  242.     buf := l.Borrow()[:4]
  243.     byteOrder.PutUint32(buf, val)
  244.     _, err := w.Write(buf)
  245.     l.Return(buf)
  246.     return err
  247. }
  248.  
  249. func (l binaryFreeList) PutUint64(w io.Writer, byteOrder binary.ByteOrder, val uint64) error {
  250.     buf := l.Borrow()[:8]
  251.     byteOrder.PutUint64(buf, val)
  252.     _, err := w.Write(buf)
  253.     l.Return(buf)
  254.     return err
  255. }
  256.  
  257. var binarySerializer binaryFreeList = make(chan []byte, binaryFreeListMaxItems)
  258.  
  259. var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
  260.     "encode a value greater than %x"
  261.  
  262. type uint32Time time.Time
  263.  
  264. type int64Time time.Time
  265.  
  266. func readElement(r io.Reader, element interface{}) error {
  267.  
  268.     switch e := element.(type) {
  269.     case *int32:
  270.         rv, err := binarySerializer.Uint32(r, littleEndian)
  271.         if err != nil {
  272.             return err
  273.         }
  274.         *e = int32(rv)
  275.         return nil
  276.  
  277.     case *uint32:
  278.         rv, err := binarySerializer.Uint32(r, littleEndian)
  279.         if err != nil {
  280.             return err
  281.         }
  282.         *e = rv
  283.         return nil
  284.  
  285.     case *int64:
  286.         rv, err := binarySerializer.Uint64(r, littleEndian)
  287.         if err != nil {
  288.             return err
  289.         }
  290.         *e = int64(rv)
  291.         return nil
  292.  
  293.     case *uint64:
  294.         rv, err := binarySerializer.Uint64(r, littleEndian)
  295.         if err != nil {
  296.             return err
  297.         }
  298.         *e = rv
  299.         return nil
  300.  
  301.     case *bool:
  302.         rv, err := binarySerializer.Uint8(r)
  303.         if err != nil {
  304.             return err
  305.         }
  306.         if rv == 0x00 {
  307.             *e = false
  308.         } else {
  309.             *e = true
  310.         }
  311.         return nil
  312.  
  313.     case *uint32Time:
  314.         rv, err := binarySerializer.Uint32(r, binary.LittleEndian)
  315.         if err != nil {
  316.             return err
  317.         }
  318.         *e = uint32Time(time.Unix(int64(rv), 0))
  319.         return nil
  320.  
  321.     case *int64Time:
  322.         rv, err := binarySerializer.Uint64(r, binary.LittleEndian)
  323.         if err != nil {
  324.             return err
  325.         }
  326.         *e = int64Time(time.Unix(int64(rv), 0))
  327.         return nil
  328.  
  329.     case *[4]byte:
  330.         _, err := io.ReadFull(r, e[:])
  331.         if err != nil {
  332.             return err
  333.         }
  334.         return nil
  335.  
  336.     case *[CommandSize]uint8:
  337.         _, err := io.ReadFull(r, e[:])
  338.         if err != nil {
  339.             return err
  340.         }
  341.         return nil
  342.  
  343.     case *[16]byte:
  344.         _, err := io.ReadFull(r, e[:])
  345.         if err != nil {
  346.             return err
  347.         }
  348.         return nil
  349.  
  350.     case *Hash:
  351.         _, err := io.ReadFull(r, e[:])
  352.         if err != nil {
  353.             return err
  354.         }
  355.         return nil
  356.  
  357.     case *ServiceFlag:
  358.         rv, err := binarySerializer.Uint64(r, littleEndian)
  359.         if err != nil {
  360.             return err
  361.         }
  362.         *e = ServiceFlag(rv)
  363.         return nil
  364.  
  365.     case *InvType:
  366.         rv, err := binarySerializer.Uint32(r, littleEndian)
  367.         if err != nil {
  368.             return err
  369.         }
  370.         *e = InvType(rv)
  371.         return nil
  372.  
  373.     case *BitcoinNet:
  374.         rv, err := binarySerializer.Uint32(r, littleEndian)
  375.         if err != nil {
  376.             return err
  377.         }
  378.         *e = BitcoinNet(rv)
  379.         return nil
  380.  
  381.     case *BloomUpdateType:
  382.         rv, err := binarySerializer.Uint8(r)
  383.         if err != nil {
  384.             return err
  385.         }
  386.         *e = BloomUpdateType(rv)
  387.         return nil
  388.  
  389.     case *RejectCode:
  390.         rv, err := binarySerializer.Uint8(r)
  391.         if err != nil {
  392.             return err
  393.         }
  394.         *e = RejectCode(rv)
  395.         return nil
  396.     }
  397.  
  398.     return binary.Read(r, littleEndian, element)
  399. }
  400.  
  401. func readElements(r io.Reader, elements ...interface{}) error {
  402.     for _, element := range elements {
  403.         err := readElement(r, element)
  404.         if err != nil {
  405.             return err
  406.         }
  407.     }
  408.     return nil
  409. }
  410.  
  411. func writeElement(w io.Writer, element interface{}) error {
  412.  
  413.     switch e := element.(type) {
  414.     case int32:
  415.         err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  416.         if err != nil {
  417.             return err
  418.         }
  419.         return nil
  420.  
  421.     case uint32:
  422.         err := binarySerializer.PutUint32(w, littleEndian, e)
  423.         if err != nil {
  424.             return err
  425.         }
  426.         return nil
  427.  
  428.     case int64:
  429.         err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
  430.         if err != nil {
  431.             return err
  432.         }
  433.         return nil
  434.  
  435.     case uint64:
  436.         err := binarySerializer.PutUint64(w, littleEndian, e)
  437.         if err != nil {
  438.             return err
  439.         }
  440.         return nil
  441.  
  442.     case bool:
  443.         var err error
  444.         if e {
  445.             err = binarySerializer.PutUint8(w, 0x01)
  446.         } else {
  447.             err = binarySerializer.PutUint8(w, 0x00)
  448.         }
  449.         if err != nil {
  450.             return err
  451.         }
  452.         return nil
  453.  
  454.     case [4]byte:
  455.         _, err := w.Write(e[:])
  456.         if err != nil {
  457.             return err
  458.         }
  459.         return nil
  460.  
  461.     case [CommandSize]uint8:
  462.         _, err := w.Write(e[:])
  463.         if err != nil {
  464.             return err
  465.         }
  466.         return nil
  467.  
  468.     case [16]byte:
  469.         _, err := w.Write(e[:])
  470.         if err != nil {
  471.             return err
  472.         }
  473.         return nil
  474.  
  475.     case *Hash:
  476.         _, err := w.Write(e[:])
  477.         if err != nil {
  478.             return err
  479.         }
  480.         return nil
  481.  
  482.     case ServiceFlag:
  483.         err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
  484.         if err != nil {
  485.             return err
  486.         }
  487.         return nil
  488.  
  489.     case InvType:
  490.         err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  491.         if err != nil {
  492.             return err
  493.         }
  494.         return nil
  495.  
  496.     case BitcoinNet:
  497.         err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
  498.         if err != nil {
  499.             return err
  500.         }
  501.         return nil
  502.  
  503.     case BloomUpdateType:
  504.         err := binarySerializer.PutUint8(w, uint8(e))
  505.         if err != nil {
  506.             return err
  507.         }
  508.         return nil
  509.  
  510.     case RejectCode:
  511.         err := binarySerializer.PutUint8(w, uint8(e))
  512.         if err != nil {
  513.             return err
  514.         }
  515.         return nil
  516.     }
  517.  
  518.     return binary.Write(w, littleEndian, element)
  519. }
  520.  
  521. func writeElements(w io.Writer, elements ...interface{}) error {
  522.     for _, element := range elements {
  523.         err := writeElement(w, element)
  524.         if err != nil {
  525.             return err
  526.         }
  527.     }
  528.     return nil
  529. }
  530.  
  531. func ReadVarInt(r io.Reader, pver uint32) (uint64, error) {
  532.     discriminant, err := binarySerializer.Uint8(r)
  533.     if err != nil {
  534.         return 0, err
  535.     }
  536.  
  537.     var rv uint64
  538.     switch discriminant {
  539.     case 0xff:
  540.         sv, err := binarySerializer.Uint64(r, littleEndian)
  541.         if err != nil {
  542.             return 0, err
  543.         }
  544.         rv = sv
  545.  
  546.         min := uint64(0x100000000)
  547.         if rv < min {
  548.             return 0, messageError("ReadVarInt", fmt.Sprintf(
  549.                 errNonCanonicalVarInt, rv, discriminant, min))
  550.         }
  551.  
  552.     case 0xfe:
  553.         sv, err := binarySerializer.Uint32(r, littleEndian)
  554.         if err != nil {
  555.             return 0, err
  556.         }
  557.         rv = uint64(sv)
  558.  
  559.         min := uint64(0x10000)
  560.         if rv < min {
  561.             return 0, messageError("ReadVarInt", fmt.Sprintf(
  562.                 errNonCanonicalVarInt, rv, discriminant, min))
  563.         }
  564.  
  565.     case 0xfd:
  566.         sv, err := binarySerializer.Uint16(r, littleEndian)
  567.         if err != nil {
  568.             return 0, err
  569.         }
  570.         rv = uint64(sv)
  571.  
  572.         min := uint64(0xfd)
  573.         if rv < min {
  574.             return 0, messageError("ReadVarInt", fmt.Sprintf(
  575.                 errNonCanonicalVarInt, rv, discriminant, min))
  576.         }
  577.  
  578.     default:
  579.         rv = uint64(discriminant)
  580.     }
  581.  
  582.     return rv, nil
  583. }
  584.  
  585. func WriteVarInt(w io.Writer, pver uint32, val uint64) error {
  586.     if val < 0xfd {
  587.         return binarySerializer.PutUint8(w, uint8(val))
  588.     }
  589.  
  590.     if val <= math.MaxUint16 {
  591.         err := binarySerializer.PutUint8(w, 0xfd)
  592.         if err != nil {
  593.             return err
  594.         }
  595.         return binarySerializer.PutUint16(w, littleEndian, uint16(val))
  596.     }
  597.  
  598.     if val <= math.MaxUint32 {
  599.         err := binarySerializer.PutUint8(w, 0xfe)
  600.         if err != nil {
  601.             return err
  602.         }
  603.         return binarySerializer.PutUint32(w, littleEndian, uint32(val))
  604.     }
  605.  
  606.     err := binarySerializer.PutUint8(w, 0xff)
  607.     if err != nil {
  608.         return err
  609.     }
  610.     return binarySerializer.PutUint64(w, littleEndian, val)
  611. }
  612.  
  613. func VarIntSerializeSize(val uint64) int {
  614.  
  615.     if val < 0xfd {
  616.         return 1
  617.     }
  618.  
  619.     if val <= math.MaxUint16 {
  620.         return 3
  621.     }
  622.  
  623.     if val <= math.MaxUint32 {
  624.         return 5
  625.     }
  626.  
  627.     return 9
  628. }
  629.  
  630. func ReadVarString(r io.Reader, pver uint32) (string, error) {
  631.     count, err := ReadVarInt(r, pver)
  632.     if err != nil {
  633.         return "", err
  634.     }
  635.  
  636.     if count > MaxMessagePayload {
  637.         str := fmt.Sprintf("variable length string is too long "+
  638.             "[count %d, max %d]", count, MaxMessagePayload)
  639.         return "", messageError("ReadVarString", str)
  640.     }
  641.  
  642.     buf := make([]byte, count)
  643.     _, err = io.ReadFull(r, buf)
  644.     if err != nil {
  645.         return "", err
  646.     }
  647.     return string(buf), nil
  648. }
  649.  
  650. func WriteVarString(w io.Writer, pver uint32, str string) error {
  651.     err := WriteVarInt(w, pver, uint64(len(str)))
  652.     if err != nil {
  653.         return err
  654.     }
  655.     _, err = w.Write([]byte(str))
  656.     return err
  657. }
  658.  
  659. func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
  660.     fieldName string) ([]byte, error) {
  661.  
  662.     count, err := ReadVarInt(r, pver)
  663.     if err != nil {
  664.         return nil, err
  665.     }
  666.  
  667.     if count > uint64(maxAllowed) {
  668.         str := fmt.Sprintf("%s is larger than the max allowed size "+
  669.             "[count %d, max %d]", fieldName, count, maxAllowed)
  670.         return nil, messageError("ReadVarBytes", str)
  671.     }
  672.  
  673.     b := make([]byte, count)
  674.     _, err = io.ReadFull(r, b)
  675.     if err != nil {
  676.         return nil, err
  677.     }
  678.     return b, nil
  679. }
  680.  
  681. func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
  682.     slen := uint64(len(bytes))
  683.     err := WriteVarInt(w, pver, slen)
  684.     if err != nil {
  685.         return err
  686.     }
  687.  
  688.     _, err = w.Write(bytes)
  689.     return err
  690. }
  691.  
  692. func randomUint64(r io.Reader) (uint64, error) {
  693.     rv, err := binarySerializer.Uint64(r, bigEndian)
  694.     if err != nil {
  695.         return 0, err
  696.     }
  697.     return rv, nil
  698. }
  699.  
  700. func RandomUint64() (uint64, error) {
  701.     return randomUint64(rand.Reader)
  702. }
  703.  
  704. const max_cruisers = 64
  705. const extra_addresses = 1024
  706.  
  707. var current_cruisers_mutex sync.Mutex
  708. var current_ended bool
  709. var current_all_cruisers map[string]*net.Conn
  710. var current_extra_cruisers map[string]struct{}
  711.  
  712. func init() {
  713.     current_all_cruisers = make(map[string]*net.Conn)
  714.     current_extra_cruisers = make(map[string]struct{})
  715. }
  716.  
  717. func cruiser_pending_extra_address() bool {
  718.     current_cruisers_mutex.Lock()
  719.     var pending = len(current_extra_cruisers) < extra_addresses
  720.     current_cruisers_mutex.Unlock()
  721.     return pending
  722. }
  723. func start_cruises(cru []string) {
  724.     for _, str := range cru {
  725.         go func() {
  726.             if err := cruise(str); err != nil {
  727.                 fmt.Println(err)
  728.             }
  729.         }()
  730.     }
  731. }
  732. func has_cruiser(addr string) bool {
  733.     current_cruisers_mutex.Lock()
  734.     var ok2 = !current_ended
  735.     _, ok := current_all_cruisers[addr]
  736.     current_cruisers_mutex.Unlock()
  737.     return ok && ok2
  738. }
  739.  
  740. func end_cruises(cru []string) {
  741.     current_cruisers_mutex.Lock()
  742.     current_ended = true
  743.     for _, str := range cru {
  744.         conn := current_all_cruisers[str]
  745.         if conn != nil {
  746.             (*conn).Close()
  747.         }
  748.         delete(current_all_cruisers, str)
  749.     }
  750.     current_cruisers_mutex.Unlock()
  751. }
  752. func end_other_cruiser_conn(conn *net.Conn) {
  753.     current_cruisers_mutex.Lock()
  754.     for str, c := range current_all_cruisers {
  755.         if conn != c && c != nil {
  756.             (*c).Close()
  757.         }
  758.         delete(current_all_cruisers, str)
  759.     }
  760.     current_cruisers_mutex.Unlock()
  761. }
  762. func cruised_conn() (conn *net.Conn, addr string) {
  763.     current_cruisers_mutex.Lock()
  764.     for a, c := range current_all_cruisers {
  765.         if c != nil {
  766.             conn = c
  767.             addr = a
  768.             delete(current_all_cruisers, a)
  769.             break
  770.         }
  771.     }
  772.     current_cruisers_mutex.Unlock()
  773.     return conn, addr
  774. }
  775.  
  776. func cruised_address() (addr string) {
  777.     current_cruisers_mutex.Lock()
  778.     for a := range current_all_cruisers {
  779.         addr = a
  780.         break
  781.     }
  782.     if len(addr) == 0 {
  783.         for a := range current_extra_cruisers {
  784.             addr = a
  785.             break
  786.         }
  787.     }
  788.     current_cruisers_mutex.Unlock()
  789.     return addr
  790. }
  791.  
  792. func isIpV6(ip string) bool {
  793.     for i := 0; i < len(ip); i++ {
  794.         switch ip[i] {
  795.         case '.':
  796.             return false
  797.         case ':':
  798.             return true
  799.         }
  800.     }
  801.     return true
  802. }
  803.  
  804. func cruise(addr string) error {
  805.  
  806.     current_cruisers_mutex.Lock()
  807.     if current_ended {
  808.         current_cruisers_mutex.Unlock()
  809.         return nil
  810.     }
  811.     if len(current_all_cruisers) >= max_cruisers {
  812.         current_extra_cruisers[addr] = struct{}{}
  813.         current_cruisers_mutex.Unlock()
  814.         return fmt.Errorf("Max cruisers")
  815.     }
  816.     if _, ok := current_all_cruisers[addr]; ok {
  817.         current_cruisers_mutex.Unlock()
  818.         return nil
  819.     }
  820.     current_all_cruisers[addr] = nil
  821.     current_cruisers_mutex.Unlock()
  822.  
  823.     pver := ProtocolVersion
  824.     btcnet := MainNet
  825.  
  826.     conn, err := net.Dial("tcp", addr)
  827.     if err != nil {
  828.         return err
  829.     }
  830.  
  831.     current_cruisers_mutex.Lock()
  832.     current_all_cruisers[addr] = &conn
  833.     current_cruisers_mutex.Unlock()
  834.  
  835.     nonce, err := RandomUint64()
  836.     if err != nil {
  837.         conn.Close()
  838.         return err
  839.     }
  840.     msgVersion := NewMsgVersionFromConn(conn, nonce, 0, SFNodeNetwork|SFNodeWitness)
  841.     if err := WriteMessage(conn, msgVersion, pver, btcnet); err != nil {
  842.         conn.Close()
  843.         return err
  844.     }
  845.     if err := msgVersion.AddUserAgent("Satoshi", "0.20.1"); err != nil {
  846.         conn.Close()
  847.         return err
  848.     }
  849.  
  850.     msg, _, err := ReadMessage(conn, pver, btcnet)
  851.     if err != nil {
  852.         conn.Close()
  853.         return err
  854.     }
  855.     vmsg, ok := msg.(*MsgVersion)
  856.     if !ok {
  857.         conn.Close()
  858.         return fmt.Errorf("Cannot make msg version")
  859.     }
  860.  
  861.     if uint32(vmsg.ProtocolVersion) < pver {
  862.         pver = uint32(vmsg.ProtocolVersion)
  863.     }
  864.  
  865.     if err := WriteMessage(conn, NewMsgVerAck(), pver, btcnet); err != nil {
  866.         conn.Close()
  867.         return err
  868.     }
  869.  
  870.     getAddr := &MsgGetAddr{}
  871.  
  872.     if err := WriteMessage(conn, getAddr, pver, btcnet); err != nil {
  873.         conn.Close()
  874.         return err
  875.     }
  876.  
  877.     for has_cruiser(addr) {
  878.         msg, _, err := ReadMessage(conn, pver, btcnet)
  879.         if err != nil {
  880.             conn.Close()
  881.             return err
  882.         }
  883.  
  884.         if !has_cruiser(addr) {
  885.             return nil
  886.         }
  887.  
  888.         switch tmsg := msg.(type) {
  889.         case *MsgAddr:
  890.  
  891.             for _, address := range tmsg.AddrList {
  892.                 fmt.Printf("Node address received: %s %d\n", address.IP, address.Port)
  893.  
  894.                 if isIpV6(address.IP.String()) {
  895.                     go cruise(fmt.Sprintf("[%s]:%d", address.IP.String(), address.Port))
  896.                 } else {
  897.                     go cruise(fmt.Sprintf("%s:%d", address.IP.String(), address.Port))
  898.                 }
  899.             }
  900.  
  901.             getAddr := &MsgGetAddr{}
  902.  
  903.             if err := WriteMessage(conn, getAddr, pver, btcnet); err != nil {
  904.                 conn.Close()
  905.                 return err
  906.             }
  907.         }
  908.     }
  909.     return nil
  910. }
  911.  
  912. const downloader_start_height = 481824
  913.  
  914. var data_downloader_mutex sync.Mutex
  915. var data_downloader_active bool
  916. var data_download_height uint64
  917.  
  918. func data_downloader(conn *net.Conn, pver uint32, btcnet BitcoinNet) {
  919.  
  920.     data_downloader_mutex.Lock()
  921.  
  922.     if data_downloader_active {
  923.         data_downloader_mutex.Unlock()
  924.         return
  925.     }
  926.  
  927.     data_downloader_active = true
  928.     data_download_height = downloader_start_height
  929.     data_downloader_mutex.Unlock()
  930.  
  931.     firstBlock := myGet(downloader_start_height)
  932.  
  933.     newData := NewMsgGetData()
  934.  
  935.     newData.AddInvVect(NewInvVect(InvTypeBlock, firstBlock))
  936.  
  937.     if err := WriteMessage(*conn, newData, pver, btcnet); err != nil {
  938.         log.Fatal(err)
  939.     }
  940.  
  941. }
  942.  
  943. func downloader_height(hash *Hash) int64 {
  944.  
  945.     data_downloader_mutex.Lock()
  946.     var near = data_download_height - 1
  947.     data_downloader_mutex.Unlock()
  948.  
  949.     for i := near; i < near+3; i++ {
  950.         block := myGet(i)
  951.  
  952.         if *block == *hash {
  953.             return int64(i) + 1
  954.         }
  955.     }
  956.     return -1
  957. }
  958.  
  959. func continue_downloader(conn *net.Conn, pver uint32, btcnet BitcoinNet) bool {
  960.     data_downloader_mutex.Lock()
  961.     data_download_height++
  962.     var height = data_download_height
  963.     data_downloader_mutex.Unlock()
  964.  
  965.     firstBlock := myGet(height)
  966.  
  967.     if firstBlock == nil {
  968.         return false
  969.     }
  970.  
  971.     newData := NewMsgGetData()
  972.  
  973.     newData.AddInvVect(NewInvVect(InvTypeBlock, firstBlock))
  974.  
  975.     if err := WriteMessage(*conn, newData, pver, btcnet); err != nil {
  976.         log.Fatal(err)
  977.     }
  978.     return true
  979.  
  980. }
  981.  
  982. type MessageError struct {
  983.     Func        string
  984.     Description string
  985. }
  986.  
  987. func (e *MessageError) Error() string {
  988.     if e.Func != "" {
  989.         return fmt.Sprintf("%v: %v", e.Func, e.Description)
  990.     }
  991.     return e.Description
  992. }
  993.  
  994. func messageError(f string, desc string) *MessageError {
  995.     return &MessageError{Func: f, Description: desc}
  996. }
  997.  
  998. func HashB(b []byte) []byte {
  999.     hash := sha256.Sum256(b)
  1000.     return hash[:]
  1001. }
  1002.  
  1003. func HashH(b []byte) Hash {
  1004.     return Hash(sha256.Sum256(b))
  1005. }
  1006.  
  1007. func DoubleHashB(b []byte) []byte {
  1008.     first := sha256.Sum256(b)
  1009.     second := sha256.Sum256(first[:])
  1010.     return second[:]
  1011. }
  1012.  
  1013. func DoubleHashH(b []byte) Hash {
  1014.     first := sha256.Sum256(b)
  1015.     return Hash(sha256.Sum256(first[:]))
  1016. }
  1017.  
  1018. const HashSize = 32
  1019.  
  1020. const MaxHashStringSize = HashSize * 2
  1021.  
  1022. var ErrHashStrSize = fmt.Errorf("max hash string length is %v bytes", MaxHashStringSize)
  1023.  
  1024. type Hash [HashSize]byte
  1025.  
  1026. func (hash Hash) String() string {
  1027.     for i := 0; i < HashSize/2; i++ {
  1028.         hash[i], hash[HashSize-1-i] = hash[HashSize-1-i], hash[i]
  1029.     }
  1030.     return hex.EncodeToString(hash[:])
  1031. }
  1032.  
  1033. func (hash *Hash) CloneBytes() []byte {
  1034.     newHash := make([]byte, HashSize)
  1035.     copy(newHash, hash[:])
  1036.  
  1037.     return newHash
  1038. }
  1039.  
  1040. func (hash *Hash) SetBytes(newHash []byte) error {
  1041.     nhlen := len(newHash)
  1042.     if nhlen != HashSize {
  1043.         return fmt.Errorf("invalid hash length of %v, want %v", nhlen,
  1044.             HashSize)
  1045.     }
  1046.     copy(hash[:], newHash)
  1047.  
  1048.     return nil
  1049. }
  1050.  
  1051. func (hash *Hash) IsEqual(target *Hash) bool {
  1052.     if hash == nil && target == nil {
  1053.         return true
  1054.     }
  1055.     if hash == nil || target == nil {
  1056.         return false
  1057.     }
  1058.     return *hash == *target
  1059. }
  1060.  
  1061. func NewHash(newHash []byte) (*Hash, error) {
  1062.     var sh Hash
  1063.     err := sh.SetBytes(newHash)
  1064.     if err != nil {
  1065.         return nil, err
  1066.     }
  1067.     return &sh, err
  1068. }
  1069.  
  1070. func NewHashFromStr(hash string) (*Hash, error) {
  1071.     ret := new(Hash)
  1072.     err := Decode(ret, hash)
  1073.     if err != nil {
  1074.         return nil, err
  1075.     }
  1076.     return ret, nil
  1077. }
  1078.  
  1079. func Decode(dst *Hash, src string) error {
  1080.  
  1081.     if len(src) > MaxHashStringSize {
  1082.         return ErrHashStrSize
  1083.     }
  1084.  
  1085.     var srcBytes []byte
  1086.     if len(src)%2 == 0 {
  1087.         srcBytes = []byte(src)
  1088.     } else {
  1089.         srcBytes = make([]byte, 1+len(src))
  1090.         srcBytes[0] = '0'
  1091.         copy(srcBytes[1:], src)
  1092.     }
  1093.  
  1094.     var reversedHash Hash
  1095.     _, err := hex.Decode(reversedHash[HashSize-hex.DecodedLen(len(srcBytes)):], srcBytes)
  1096.     if err != nil {
  1097.         return err
  1098.     }
  1099.  
  1100.     for i, b := range reversedHash[:HashSize/2] {
  1101.         dst[i], dst[HashSize-1-i] = reversedHash[HashSize-1-i], b
  1102.     }
  1103.  
  1104.     return nil
  1105. }
  1106.  
  1107. const (
  1108.     MaxInvPerMsg = 50000
  1109.  
  1110.     maxInvVectPayload = 4 + HashSize
  1111.  
  1112.     InvWitnessFlag = 1 << 30
  1113. )
  1114.  
  1115. type InvType uint32
  1116.  
  1117. const (
  1118.     InvTypeError                InvType = 0
  1119.     InvTypeTx                   InvType = 1
  1120.     InvTypeBlock                InvType = 2
  1121.     InvTypeFilteredBlock        InvType = 3
  1122.     InvTypeWitnessBlock         InvType = InvTypeBlock | InvWitnessFlag
  1123.     InvTypeWitnessTx            InvType = InvTypeTx | InvWitnessFlag
  1124.     InvTypeFilteredWitnessBlock InvType = InvTypeFilteredBlock | InvWitnessFlag
  1125. )
  1126.  
  1127. var ivStrings = map[InvType]string{
  1128.     InvTypeError:                "ERROR",
  1129.     InvTypeTx:                   "MSG_TX",
  1130.     InvTypeBlock:                "MSG_BLOCK",
  1131.     InvTypeFilteredBlock:        "MSG_FILTERED_BLOCK",
  1132.     InvTypeWitnessBlock:         "MSG_WITNESS_BLOCK",
  1133.     InvTypeWitnessTx:            "MSG_WITNESS_TX",
  1134.     InvTypeFilteredWitnessBlock: "MSG_FILTERED_WITNESS_BLOCK",
  1135. }
  1136.  
  1137. func (invtype InvType) String() string {
  1138.     if s, ok := ivStrings[invtype]; ok {
  1139.         return s
  1140.     }
  1141.  
  1142.     return fmt.Sprintf("Unknown InvType (%d)", uint32(invtype))
  1143. }
  1144.  
  1145. type InvVect struct {
  1146.     Type InvType
  1147.     Hash Hash
  1148. }
  1149.  
  1150. func NewInvVect(typ InvType, hash *Hash) *InvVect {
  1151.     return &InvVect{
  1152.         Type: typ,
  1153.         Hash: *hash,
  1154.     }
  1155. }
  1156.  
  1157. func readInvVect(r io.Reader, pver uint32, iv *InvVect) error {
  1158.     return readElements(r, &iv.Type, &iv.Hash)
  1159. }
  1160.  
  1161. func writeInvVect(w io.Writer, pver uint32, iv *InvVect) error {
  1162.     return writeElements(w, iv.Type, &iv.Hash)
  1163. }
  1164.  
  1165. func NewMsgVersionFromConn(conn net.Conn, nonce uint64,
  1166.     lastBlock int32, sf ServiceFlag) *MsgVersion {
  1167.  
  1168.     lna := NewNetAddress(conn.LocalAddr().(*net.TCPAddr), sf)
  1169.  
  1170.     rna := NewNetAddress(conn.RemoteAddr().(*net.TCPAddr), sf)
  1171.  
  1172.     return NewMsgVersion(lna, rna, nonce, lastBlock)
  1173. }
  1174.  
  1175. func main() {
  1176.  
  1177.     hashStr := "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
  1178.     locatorHash, err := NewHashFromStr(hashStr)
  1179.     if err != nil {
  1180.         log.Printf("NewShaHashFromStr: %v", err)
  1181.     }
  1182.     myPut(locatorHash, 0)
  1183.  
  1184.     var cru = []string{
  1185.         "bitcoin.vable.ch:8333", "testrestful.net:8333", "8an.z.praha12.net:8333", "greentheatre.kiev.ua:8333",
  1186.  
  1187.         "seed.bitcoin.sipa.be:8333",
  1188.         "dnsseed.bluematt.me:8333",
  1189.         "dnsseed.bitcoin.dashjr.org:8333",
  1190.         "seed.bitcoinstats.com:8333",
  1191.         "seed.bitcoin.jonasschnelli.ch:8333",
  1192.         "seed.btc.petertodd.org:8333",
  1193.     }
  1194.  
  1195.     start_cruises(cru)
  1196.  
  1197.     for cruiser_pending_extra_address() {
  1198.         time.Sleep(1 * time.Second)
  1199.     }
  1200.  
  1201.     end_cruises(cru)
  1202.  
  1203.     pver := ProtocolVersion
  1204.     btcnet := MainNet
  1205.     var conn net.Conn
  1206.     connect, addr := cruised_conn()
  1207.     if connect == nil {
  1208.         var addr string
  1209.         for {
  1210.             var err error
  1211.  
  1212.             addr = cruised_address()
  1213.  
  1214.             log.Printf("Connecting to %s\n", addr)
  1215.             conn, err = net.DialTimeout("tcp", addr, 3*time.Second)
  1216.             if err != nil {
  1217.                 log.Print(err)
  1218.                 continue
  1219.             }
  1220.  
  1221.         }
  1222.  
  1223.         defer conn.Close()
  1224.         log.Printf("Connected to %s\n", addr)
  1225.  
  1226.         nonce, err := RandomUint64()
  1227.         if err != nil {
  1228.             log.Fatal(err)
  1229.         }
  1230.         msgVersion := NewMsgVersionFromConn(conn, nonce, 0, SFNodeNetwork|SFNodeWitness)
  1231.         if err := WriteMessage(conn, msgVersion, pver, btcnet); err != nil {
  1232.             log.Fatal(err)
  1233.         }
  1234.         if err := msgVersion.AddUserAgent("Satoshi", "0.20.1"); err != nil {
  1235.             log.Fatal(err)
  1236.         }
  1237.         log.Printf("Version message sent to %s\n", addr)
  1238.  
  1239.         msg, _, err := ReadMessage(conn, pver, btcnet)
  1240.         if err != nil {
  1241.             log.Fatal(err)
  1242.         }
  1243.         vmsg, ok := msg.(*MsgVersion)
  1244.         if !ok {
  1245.             log.Fatalf("Did not receive version message: %T", vmsg)
  1246.             return
  1247.         }
  1248.  
  1249.         if uint32(vmsg.ProtocolVersion) < pver {
  1250.             pver = uint32(vmsg.ProtocolVersion)
  1251.         }
  1252.         log.Printf("Version response received from %s\n", addr)
  1253.  
  1254.         if err := WriteMessage(conn, NewMsgVerAck(), pver, btcnet); err != nil {
  1255.             log.Fatal(err)
  1256.         }
  1257.     } else {
  1258.  
  1259.         log.Printf("Ending other cruisers than %s\n", addr)
  1260.         end_other_cruiser_conn(connect)
  1261.         log.Printf("Retaining connection %s\n", addr)
  1262.         conn = *connect
  1263.  
  1264.         nonce, err := RandomUint64()
  1265.         if err != nil {
  1266.             log.Fatal("RandomUint64: Error generating nonce: %v", err)
  1267.         }
  1268.         pingMsg := NewMsgPing(nonce)
  1269.         if err := WriteMessage(conn, pingMsg, pver, btcnet); err != nil {
  1270.             log.Fatal(err)
  1271.         }
  1272.  
  1273.         newHdrs := NewMsgGetHeaders()
  1274.  
  1275.         newHdrs.ProtocolVersion = pver
  1276.         newHdrs.AddBlockLocatorHash(locatorHash)
  1277.  
  1278.         if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1279.             log.Fatal(err)
  1280.         }
  1281.     }
  1282.  
  1283.     SetupCloseHandler(&conn)
  1284.  
  1285.     var commits_db *os.File
  1286.     var commits_db_checksum [32]byte
  1287.     var headerSyncOver bool
  1288.  
  1289.     bar := Bar{Graph: "#", Unit: "headers"}
  1290.  
  1291.     var total_coins uint64
  1292.     var obviously_claimed_coins uint64
  1293.  
  1294.     for {
  1295.         msg, _, err := ReadMessage(conn, pver, btcnet)
  1296.         if err != nil {
  1297.             bar.Hide()
  1298.             log.Printf("Failed to read message: %v", err)
  1299.             bar.Finish()
  1300.             if headerSyncOver {
  1301.                 commits_db.Write(commits_db_checksum[0:32])
  1302.                 commits_db.Close()
  1303.             }
  1304.             break
  1305.         }
  1306.  
  1307.         switch tmsg := msg.(type) {
  1308.         case *MsgInv:
  1309.  
  1310.             var is_new_block = false
  1311.  
  1312.             for _, inv := range tmsg.InvList {
  1313.                 if inv.Type == InvTypeBlock {
  1314.  
  1315.                     if !myHas(&inv.Hash) {
  1316.  
  1317.                         is_new_block = true
  1318.  
  1319.                     }
  1320.  
  1321.                 }
  1322.             }
  1323.  
  1324.             if is_new_block && headerSyncOver {
  1325.  
  1326.                 newHdrs := NewMsgGetHeaders()
  1327.  
  1328.                 newHdrs.ProtocolVersion = pver
  1329.  
  1330.                 myLocator(10, 6, func(id uint64, hash *Hash) {
  1331.                     newHdrs.AddBlockLocatorHash(hash)
  1332.                 })
  1333.  
  1334.                 if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1335.                     log.Fatal(err)
  1336.                 }
  1337.  
  1338.             }
  1339.  
  1340.             continue
  1341.         case *MsgPing:
  1342.             bar.Hide()
  1343.             log.Printf("ping received from %s\n", addr)
  1344.             bar.Replay()
  1345.  
  1346.             if err := WriteMessage(conn, NewMsgPong(tmsg.Nonce), pver, btcnet); err != nil {
  1347.                 log.Fatal(err)
  1348.             }
  1349.         case *MsgHeaders:
  1350.  
  1351.             var oldStatus = myStatus(func(tot uint64, hsh *Hash) {
  1352.                 bar.Hide()
  1353.                 log.Printf("top header %d %s\n", tot, *hsh)
  1354.                 bar.Replay()
  1355.             })
  1356.  
  1357.             for _, hdr := range tmsg.Headers {
  1358.  
  1359.                 myAttach(hdr, func(ra, rb *Hash) {
  1360.                     bar.Hide()
  1361.                     log.Println("Reorg %s %s\n", *ra, *rb)
  1362.                     bar.Replay()
  1363.                 })
  1364.  
  1365.             }
  1366.  
  1367.             if oldStatus != myStatus(func(tot uint64, hsh *Hash) {
  1368.                 bar.Hide()
  1369.                 log.Printf("tip header %d %s\n", tot, *hsh)
  1370.  
  1371.                 if headerSyncOver {
  1372.  
  1373.                     bar.Replay()
  1374.  
  1375.                 } else {
  1376.  
  1377.                     bar.Play(0, int64(tot), myTotalBlocksEstimate())
  1378.  
  1379.                 }
  1380.             }) {
  1381.  
  1382.                 newHdrs := NewMsgGetHeaders()
  1383.  
  1384.                 newHdrs.ProtocolVersion = pver
  1385.  
  1386.                 myLocator(10, 0, func(id uint64, hash *Hash) {
  1387.                     newHdrs.AddBlockLocatorHash(hash)
  1388.                 })
  1389.  
  1390.                 if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1391.                     log.Fatal(err)
  1392.                 }
  1393.             } else {
  1394.  
  1395.                 if !headerSyncOver {
  1396.                     headerSyncOver = true
  1397.                     data_downloader(&conn, pver, btcnet)
  1398.  
  1399.                     bar.Restart("blocks")
  1400.  
  1401.                     var err8 error
  1402.  
  1403.                     commits_db, err = os.Create("commits.db")
  1404.                     if err8 != nil {
  1405.                         log.Fatal(err8)
  1406.                     }
  1407.                 }
  1408.             }
  1409.         case *MsgVerAck:
  1410.             bar.Hide()
  1411.             log.Printf("Version ack received from %s\n", addr)
  1412.             bar.Replay()
  1413.  
  1414.             newHdrs := NewMsgGetHeaders()
  1415.  
  1416.             newHdrs.ProtocolVersion = pver
  1417.             newHdrs.AddBlockLocatorHash(locatorHash)
  1418.  
  1419.             if err := WriteMessage(conn, newHdrs, pver, btcnet); err != nil {
  1420.                 log.Fatal(err)
  1421.             }
  1422.  
  1423.             continue
  1424.  
  1425.         case *MsgAddr:
  1426.  
  1427.             for _, address := range tmsg.AddrList {
  1428.                 bar.Hide()
  1429.                 log.Printf("Node address received: %s %d\n", address.IP, address.Port)
  1430.                 bar.Replay()
  1431.             }
  1432.  
  1433.         case *MsgBlock:
  1434.  
  1435.             var height = downloader_height(&tmsg.Header.PrevBlock)
  1436.  
  1437.             var combbase = true
  1438.  
  1439.             if height >= 0 {
  1440.  
  1441.                 var blkHash = tmsg.Header.BlockHash()
  1442.                 if !myHas(&blkHash) {
  1443.                     bar.Hide()
  1444.                     log.Fatalf("Received block %s on height %d not in chain\n", blkHash, height)
  1445.                 }
  1446.  
  1447.                 var merkle []Hash
  1448.  
  1449.                 var q = 0
  1450.  
  1451.                 for i, tx := range tmsg.Transactions {
  1452.  
  1453.                     var hash = tx.TxHash()
  1454.                     merkle = append(merkle, hash)
  1455.  
  1456.                     for j, txout := range tx.TxOut {
  1457.  
  1458.                         if len(txout.PkScript) == 34 {
  1459.                             if txout.PkScript[0] == 0 && txout.PkScript[1] == 0x20 {
  1460.  
  1461.                                 var buf [32]byte
  1462.                                 var buf2 [8]byte
  1463.                                 copy(buf[0:32], txout.PkScript[2:])
  1464.  
  1465.                                 if is_previously_unseen_make_seen(&buf) {
  1466.  
  1467.                                     if combbase {
  1468.                                         combbase = false
  1469.                                         var log = math.Log2(float64(height))
  1470.                                         log = log * log * log * log * log * log
  1471.                                         var combbase_value = 210000000 - uint64(log)
  1472.                                         total_coins += combbase_value
  1473.  
  1474.                                         if height >= 601002 && (txout.Value == 546 || txout.Value == 330) {
  1475.                                             obviously_claimed_coins += combbase_value
  1476.                                         }
  1477.  
  1478.                                     }
  1479.  
  1480.                                     if height >= 620000 {
  1481.  
  1482.                                         BCDFromUint(uint64(height), buf2[0:4])
  1483.                                         BCDFromUint(uint64(q), buf2[4:8])
  1484.                                         bar.Hide()
  1485.                                         log.Printf("%X %08d %08d %d", buf, height, q, txout.Value)
  1486.                                         bar.Replay()
  1487.                                     } else {
  1488.  
  1489.                                         BCDFromUint(uint64(height), buf2[0:4])
  1490.                                         BCDFromUint(uint64(i), buf2[4:6])
  1491.                                         BCDFromUint(uint64(j), buf2[6:8])
  1492.                                         bar.Hide()
  1493.                                         log.Printf("%X %08d %04d %04d %d", buf, height, i, j, txout.Value)
  1494.                                         bar.Replay()
  1495.                                     }
  1496.  
  1497.                                     commits_db.Write(buf[0:32])
  1498.                                     commits_db.Write(buf2[0:8])
  1499.  
  1500.                                     aes_checksum(&buf, &commits_db_checksum)
  1501.                                 }
  1502.  
  1503.                                 q++
  1504.  
  1505.                             }
  1506.                         }
  1507.  
  1508.                     }
  1509.                 }
  1510.  
  1511.                 if merkleTree(merkle) != tmsg.Header.MerkleRoot {
  1512.  
  1513.                     bar.Hide()
  1514.                     log.Fatalf("Received block %d merkle root is not valid\n", height)
  1515.                 }
  1516.  
  1517.                 bar.Play(downloader_start_height, height, int64(myStatus(nil)))
  1518.  
  1519.                 if headerSyncOver {
  1520.                     if !continue_downloader(&conn, pver, btcnet) {
  1521.  
  1522.                         commits_db.Write(commits_db_checksum[0:32])
  1523.                         commits_db.Close()
  1524.                         bar.Hide()
  1525.                         log.Printf("Success! Total coins: %d.%08d, obviously claimed coins: %d.%08d\n",
  1526.                             total_coins/100000000, total_coins%100000000,
  1527.                             obviously_claimed_coins/100000000, obviously_claimed_coins%100000000)
  1528.                         os.Exit(0)
  1529.                     }
  1530.                 }
  1531.  
  1532.             } else {
  1533.                 bar.Hide()
  1534.                 log.Fatalf("Received block %s not in headers chain", tmsg.Header.BlockHash())
  1535.  
  1536.             }
  1537.  
  1538.         default:
  1539.  
  1540.             continue
  1541.         }
  1542.     }
  1543. }
  1544.  
  1545. func merkleTree(merkle []Hash) Hash {
  1546.  
  1547.     if len(merkle) == 0 {
  1548.         return Hash{}
  1549.     }
  1550.  
  1551.     if len(merkle) == 1 {
  1552.         return merkle[0]
  1553.     }
  1554.  
  1555.     for len(merkle) > 1 {
  1556.  
  1557.         if len(merkle)%2 != 0 {
  1558.             merkle = append(merkle, merkle[len(merkle)-1])
  1559.         }
  1560.  
  1561.         var newMerkle []Hash
  1562.  
  1563.         for i := 0; i < len(merkle)/2; i++ {
  1564.  
  1565.             var buf [64]byte
  1566.  
  1567.             copy(buf[0:32], merkle[2*i][0:])
  1568.             copy(buf[32:64], merkle[2*i+1][0:])
  1569.  
  1570.             newMerkle = append(newMerkle, DoubleHashH(buf[0:64]))
  1571.  
  1572.         }
  1573.  
  1574.         merkle = newMerkle
  1575.  
  1576.     }
  1577.     return merkle[0]
  1578. }
  1579.  
  1580. const MessageHeaderSize = 24
  1581.  
  1582. const CommandSize = 12
  1583.  
  1584. const MaxMessagePayload = (1024 * 1024 * 32)
  1585.  
  1586. const (
  1587.     CmdVersion      = "version"
  1588.     CmdVerAck       = "verack"
  1589.     CmdGetAddr      = "getaddr"
  1590.     CmdAddr         = "addr"
  1591.     CmdGetBlocks    = "getblocks"
  1592.     CmdInv          = "inv"
  1593.     CmdGetData      = "getdata"
  1594.     CmdNotFound     = "notfound"
  1595.     CmdBlock        = "block"
  1596.     CmdTx           = "tx"
  1597.     CmdGetHeaders   = "getheaders"
  1598.     CmdHeaders      = "headers"
  1599.     CmdPing         = "ping"
  1600.     CmdPong         = "pong"
  1601.     CmdAlert        = "alert"
  1602.     CmdMemPool      = "mempool"
  1603.     CmdFilterAdd    = "filteradd"
  1604.     CmdFilterClear  = "filterclear"
  1605.     CmdFilterLoad   = "filterload"
  1606.     CmdMerkleBlock  = "merkleblock"
  1607.     CmdReject       = "reject"
  1608.     CmdSendHeaders  = "sendheaders"
  1609.     CmdFeeFilter    = "feefilter"
  1610.     CmdGetCFilters  = "getcfilters"
  1611.     CmdGetCFHeaders = "getcfheaders"
  1612.     CmdGetCFCheckpt = "getcfcheckpt"
  1613.     CmdCFilter      = "cfilter"
  1614.     CmdCFHeaders    = "cfheaders"
  1615.     CmdCFCheckpt    = "cfcheckpt"
  1616. )
  1617.  
  1618. type MessageEncoding uint32
  1619.  
  1620. const (
  1621.     BaseEncoding MessageEncoding = 1 << iota
  1622.  
  1623.     WitnessEncoding
  1624. )
  1625.  
  1626. var LatestEncoding = WitnessEncoding
  1627.  
  1628. type Message interface {
  1629.     BtcDecode(io.Reader, uint32, MessageEncoding) error
  1630.     BtcEncode(io.Writer, uint32, MessageEncoding) error
  1631.     Command() string
  1632.     MaxPayloadLength(uint32) uint32
  1633. }
  1634.  
  1635. func makeEmptyMessage(command string) (Message, error) {
  1636.     var msg Message
  1637.     switch command {
  1638.     case CmdVersion:
  1639.         msg = &MsgVersion{}
  1640.  
  1641.     case CmdVerAck:
  1642.         msg = &MsgVerAck{}
  1643.  
  1644.     case CmdGetAddr:
  1645.         msg = &MsgGetAddr{}
  1646.  
  1647.     case CmdAddr:
  1648.         msg = &MsgAddr{}
  1649.  
  1650.     case CmdGetBlocks:
  1651.         msg = &MsgGetBlocks{}
  1652.  
  1653.     case CmdBlock:
  1654.         msg = &MsgBlock{}
  1655.  
  1656.     case CmdInv:
  1657.         msg = &MsgInv{}
  1658.  
  1659.     case CmdGetData:
  1660.         msg = &MsgGetData{}
  1661.  
  1662.     case CmdNotFound:
  1663.         msg = &MsgNotFound{}
  1664.  
  1665.     case CmdTx:
  1666.         msg = &MsgTx{}
  1667.  
  1668.     case CmdPing:
  1669.         msg = &MsgPing{}
  1670.  
  1671.     case CmdPong:
  1672.         msg = &MsgPong{}
  1673.  
  1674.     case CmdGetHeaders:
  1675.         msg = &MsgGetHeaders{}
  1676.  
  1677.     case CmdHeaders:
  1678.         msg = &MsgHeaders{}
  1679.  
  1680.     case CmdAlert:
  1681.         msg = &MsgAlert{}
  1682.  
  1683.     case CmdMemPool:
  1684.         msg = &MsgMemPool{}
  1685.  
  1686.     case CmdFilterAdd:
  1687.         msg = &MsgFilterAdd{}
  1688.  
  1689.     case CmdFilterClear:
  1690.         msg = &MsgFilterClear{}
  1691.  
  1692.     case CmdFilterLoad:
  1693.         msg = &MsgFilterLoad{}
  1694.  
  1695.     case CmdMerkleBlock:
  1696.         msg = &MsgMerkleBlock{}
  1697.  
  1698.     case CmdReject:
  1699.         msg = &MsgReject{}
  1700.  
  1701.     case CmdSendHeaders:
  1702.         msg = &MsgSendHeaders{}
  1703.  
  1704.     case CmdFeeFilter:
  1705.         msg = &MsgFeeFilter{}
  1706.  
  1707.     case CmdGetCFilters:
  1708.         msg = &MsgGetCFilters{}
  1709.  
  1710.     case CmdGetCFHeaders:
  1711.         msg = &MsgGetCFHeaders{}
  1712.  
  1713.     case CmdGetCFCheckpt:
  1714.         msg = &MsgGetCFCheckpt{}
  1715.  
  1716.     case CmdCFilter:
  1717.         msg = &MsgCFilter{}
  1718.  
  1719.     case CmdCFHeaders:
  1720.         msg = &MsgCFHeaders{}
  1721.  
  1722.     case CmdCFCheckpt:
  1723.         msg = &MsgCFCheckpt{}
  1724.  
  1725.     default:
  1726.         return nil, fmt.Errorf("unhandled command [%s]", command)
  1727.     }
  1728.     return msg, nil
  1729. }
  1730.  
  1731. type messageHeader struct {
  1732.     magic    BitcoinNet
  1733.     command  string
  1734.     length   uint32
  1735.     checksum [4]byte
  1736. }
  1737.  
  1738. func readMessageHeader(r io.Reader) (int, *messageHeader, error) {
  1739.  
  1740.     var headerBytes [MessageHeaderSize]byte
  1741.     n, err := io.ReadFull(r, headerBytes[:])
  1742.     if err != nil {
  1743.         return n, nil, err
  1744.     }
  1745.     hr := bytes.NewReader(headerBytes[:])
  1746.  
  1747.     hdr := messageHeader{}
  1748.     var command [CommandSize]byte
  1749.     readElements(hr, &hdr.magic, &command, &hdr.length, &hdr.checksum)
  1750.  
  1751.     hdr.command = string(bytes.TrimRight(command[:], "\x00"))
  1752.  
  1753.     return n, &hdr, nil
  1754. }
  1755.  
  1756. func discardInput(r io.Reader, n uint32) {
  1757.     maxSize := uint32(10 * 1024)
  1758.     numReads := n / maxSize
  1759.     bytesRemaining := n % maxSize
  1760.     if n > 0 {
  1761.         buf := make([]byte, maxSize)
  1762.         for i := uint32(0); i < numReads; i++ {
  1763.             io.ReadFull(r, buf)
  1764.         }
  1765.     }
  1766.     if bytesRemaining > 0 {
  1767.         buf := make([]byte, bytesRemaining)
  1768.         io.ReadFull(r, buf)
  1769.     }
  1770. }
  1771.  
  1772. func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
  1773.     return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
  1774. }
  1775.  
  1776. func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
  1777.     _, err := WriteMessageN(w, msg, pver, btcnet)
  1778.     return err
  1779. }
  1780.  
  1781. func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
  1782.     btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
  1783.  
  1784.     totalBytes := 0
  1785.  
  1786.     var command [CommandSize]byte
  1787.     cmd := msg.Command()
  1788.     if len(cmd) > CommandSize {
  1789.         str := fmt.Sprintf("command [%s] is too long [max %v]",
  1790.             cmd, CommandSize)
  1791.         return totalBytes, messageError("WriteMessage", str)
  1792.     }
  1793.     copy(command[:], []byte(cmd))
  1794.  
  1795.     var bw bytes.Buffer
  1796.     err := msg.BtcEncode(&bw, pver, encoding)
  1797.     if err != nil {
  1798.         return totalBytes, err
  1799.     }
  1800.     payload := bw.Bytes()
  1801.     lenp := len(payload)
  1802.  
  1803.     if lenp > MaxMessagePayload {
  1804.         str := fmt.Sprintf("message payload is too large - encoded "+
  1805.             "%d bytes, but maximum message payload is %d bytes",
  1806.             lenp, MaxMessagePayload)
  1807.         return totalBytes, messageError("WriteMessage", str)
  1808.     }
  1809.  
  1810.     mpl := msg.MaxPayloadLength(pver)
  1811.     if uint32(lenp) > mpl {
  1812.         str := fmt.Sprintf("message payload is too large - encoded "+
  1813.             "%d bytes, but maximum message payload size for "+
  1814.             "messages of type [%s] is %d.", lenp, cmd, mpl)
  1815.         return totalBytes, messageError("WriteMessage", str)
  1816.     }
  1817.  
  1818.     hdr := messageHeader{}
  1819.     hdr.magic = btcnet
  1820.     hdr.command = cmd
  1821.     hdr.length = uint32(lenp)
  1822.     copy(hdr.checksum[:], DoubleHashB(payload)[0:4])
  1823.  
  1824.     hw := bytes.NewBuffer(make([]byte, 0, MessageHeaderSize))
  1825.     writeElements(hw, hdr.magic, command, hdr.length, hdr.checksum)
  1826.  
  1827.     n, err := w.Write(hw.Bytes())
  1828.     totalBytes += n
  1829.     if err != nil {
  1830.         return totalBytes, err
  1831.     }
  1832.  
  1833.     if len(payload) > 0 {
  1834.         n, err = w.Write(payload)
  1835.         totalBytes += n
  1836.     }
  1837.  
  1838.     return totalBytes, err
  1839. }
  1840.  
  1841. func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
  1842.     enc MessageEncoding) (int, Message, []byte, error) {
  1843.  
  1844.     totalBytes := 0
  1845.     n, hdr, err := readMessageHeader(r)
  1846.     totalBytes += n
  1847.     if err != nil {
  1848.         return totalBytes, nil, nil, err
  1849.     }
  1850.  
  1851.     if hdr.length > MaxMessagePayload {
  1852.         str := fmt.Sprintf("message payload is too large - header "+
  1853.             "indicates %d bytes, but max message payload is %d "+
  1854.             "bytes.", hdr.length, MaxMessagePayload)
  1855.         return totalBytes, nil, nil, messageError("ReadMessage", str)
  1856.  
  1857.     }
  1858.  
  1859.     if hdr.magic != btcnet {
  1860.         discardInput(r, hdr.length)
  1861.         str := fmt.Sprintf("message from other network [%v]", hdr.magic)
  1862.         return totalBytes, nil, nil, messageError("ReadMessage", str)
  1863.     }
  1864.  
  1865.     command := hdr.command
  1866.     if !utf8.ValidString(command) {
  1867.         discardInput(r, hdr.length)
  1868.         str := fmt.Sprintf("invalid command %v", []byte(command))
  1869.         return totalBytes, nil, nil, messageError("ReadMessage", str)
  1870.     }
  1871.  
  1872.     msg, err := makeEmptyMessage(command)
  1873.     if err != nil {
  1874.         discardInput(r, hdr.length)
  1875.         return totalBytes, nil, nil, messageError("ReadMessage",
  1876.             err.Error())
  1877.     }
  1878.  
  1879.     mpl := msg.MaxPayloadLength(pver)
  1880.     if hdr.length > mpl {
  1881.         discardInput(r, hdr.length)
  1882.         str := fmt.Sprintf("payload exceeds max length - header "+
  1883.             "indicates %v bytes, but max payload size for "+
  1884.             "messages of type [%v] is %v.", hdr.length, command, mpl)
  1885.         return totalBytes, nil, nil, messageError("ReadMessage", str)
  1886.     }
  1887.  
  1888.     payload := make([]byte, hdr.length)
  1889.     n, err = io.ReadFull(r, payload)
  1890.     totalBytes += n
  1891.     if err != nil {
  1892.         return totalBytes, nil, nil, err
  1893.     }
  1894.  
  1895.     checksum := DoubleHashB(payload)[0:4]
  1896.     if !bytes.Equal(checksum[:], hdr.checksum[:]) {
  1897.         str := fmt.Sprintf("payload checksum failed - header "+
  1898.             "indicates %v, but actual checksum is %v.",
  1899.             hdr.checksum, checksum)
  1900.         return totalBytes, nil, nil, messageError("ReadMessage", str)
  1901.     }
  1902.  
  1903.     pr := bytes.NewBuffer(payload)
  1904.     err = msg.BtcDecode(pr, pver, enc)
  1905.     if err != nil {
  1906.         return totalBytes, nil, nil, err
  1907.     }
  1908.  
  1909.     return totalBytes, msg, payload, nil
  1910. }
  1911.  
  1912. func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
  1913.     return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
  1914. }
  1915.  
  1916. func ReadMessage(r io.Reader, pver uint32, btcnet BitcoinNet) (Message, []byte, error) {
  1917.     _, msg, buf, err := ReadMessageN(r, pver, btcnet)
  1918.     return msg, buf, err
  1919. }
  1920.  
  1921. const MaxAddrPerMsg = 1000
  1922.  
  1923. type MsgAddr struct {
  1924.     AddrList []*NetAddress
  1925. }
  1926.  
  1927. func (msg *MsgAddr) AddAddress(na *NetAddress) error {
  1928.     if len(msg.AddrList)+1 > MaxAddrPerMsg {
  1929.         str := fmt.Sprintf("too many addresses in message [max %v]",
  1930.             MaxAddrPerMsg)
  1931.         return messageError("MsgAddr.AddAddress", str)
  1932.     }
  1933.  
  1934.     msg.AddrList = append(msg.AddrList, na)
  1935.     return nil
  1936. }
  1937.  
  1938. func (msg *MsgAddr) AddAddresses(netAddrs ...*NetAddress) error {
  1939.     for _, na := range netAddrs {
  1940.         err := msg.AddAddress(na)
  1941.         if err != nil {
  1942.             return err
  1943.         }
  1944.     }
  1945.     return nil
  1946. }
  1947.  
  1948. func (msg *MsgAddr) ClearAddresses() {
  1949.     msg.AddrList = []*NetAddress{}
  1950. }
  1951.  
  1952. func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  1953.     count, err := ReadVarInt(r, pver)
  1954.     if err != nil {
  1955.         return err
  1956.     }
  1957.  
  1958.     if count > MaxAddrPerMsg {
  1959.         str := fmt.Sprintf("too many addresses for message "+
  1960.             "[count %v, max %v]", count, MaxAddrPerMsg)
  1961.         return messageError("MsgAddr.BtcDecode", str)
  1962.     }
  1963.  
  1964.     addrList := make([]NetAddress, count)
  1965.     msg.AddrList = make([]*NetAddress, 0, count)
  1966.     for i := uint64(0); i < count; i++ {
  1967.         na := &addrList[i]
  1968.         err := readNetAddress(r, pver, na, true)
  1969.         if err != nil {
  1970.             return err
  1971.         }
  1972.         msg.AddAddress(na)
  1973.     }
  1974.     return nil
  1975. }
  1976.  
  1977. func (msg *MsgAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  1978.  
  1979.     count := len(msg.AddrList)
  1980.     if pver < MultipleAddressVersion && count > 1 {
  1981.         str := fmt.Sprintf("too many addresses for message of "+
  1982.             "protocol version %v [count %v, max 1]", pver, count)
  1983.         return messageError("MsgAddr.BtcEncode", str)
  1984.  
  1985.     }
  1986.     if count > MaxAddrPerMsg {
  1987.         str := fmt.Sprintf("too many addresses for message "+
  1988.             "[count %v, max %v]", count, MaxAddrPerMsg)
  1989.         return messageError("MsgAddr.BtcEncode", str)
  1990.     }
  1991.  
  1992.     err := WriteVarInt(w, pver, uint64(count))
  1993.     if err != nil {
  1994.         return err
  1995.     }
  1996.  
  1997.     for _, na := range msg.AddrList {
  1998.         err = writeNetAddress(w, pver, na, true)
  1999.         if err != nil {
  2000.             return err
  2001.         }
  2002.     }
  2003.  
  2004.     return nil
  2005. }
  2006.  
  2007. func (msg *MsgAddr) Command() string {
  2008.     return CmdAddr
  2009. }
  2010.  
  2011. func (msg *MsgAddr) MaxPayloadLength(pver uint32) uint32 {
  2012.     if pver < MultipleAddressVersion {
  2013.  
  2014.         return MaxVarIntPayload + maxNetAddressPayload(pver)
  2015.     }
  2016.  
  2017.     return MaxVarIntPayload + (MaxAddrPerMsg * maxNetAddressPayload(pver))
  2018. }
  2019.  
  2020. func NewMsgAddr() *MsgAddr {
  2021.     return &MsgAddr{
  2022.         AddrList: make([]*NetAddress, 0, MaxAddrPerMsg),
  2023.     }
  2024. }
  2025.  
  2026. const fixedAlertSize = 45
  2027.  
  2028. const maxSignatureSize = 72
  2029.  
  2030. const maxAlertSize = MaxMessagePayload - maxSignatureSize - MaxVarIntPayload - 1
  2031.  
  2032. const maxCountSetCancel = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 4
  2033.  
  2034. const maxCountSetSubVer = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 256
  2035.  
  2036. type Alert struct {
  2037.     Version int32
  2038.  
  2039.     RelayUntil int64
  2040.  
  2041.     Expiration int64
  2042.  
  2043.     ID int32
  2044.  
  2045.     Cancel int32
  2046.  
  2047.     SetCancel []int32
  2048.  
  2049.     MinVer int32
  2050.  
  2051.     MaxVer int32
  2052.  
  2053.     SetSubVer []string
  2054.  
  2055.     Priority int32
  2056.  
  2057.     Comment string
  2058.  
  2059.     StatusBar string
  2060.  
  2061.     Reserved string
  2062. }
  2063.  
  2064. func (alert *Alert) Serialize(w io.Writer, pver uint32) error {
  2065.     err := writeElements(w, alert.Version, alert.RelayUntil,
  2066.         alert.Expiration, alert.ID, alert.Cancel)
  2067.     if err != nil {
  2068.         return err
  2069.     }
  2070.  
  2071.     count := len(alert.SetCancel)
  2072.     if count > maxCountSetCancel {
  2073.         str := fmt.Sprintf("too many cancel alert IDs for alert "+
  2074.             "[count %v, max %v]", count, maxCountSetCancel)
  2075.         return messageError("Alert.Serialize", str)
  2076.     }
  2077.     err = WriteVarInt(w, pver, uint64(count))
  2078.     if err != nil {
  2079.         return err
  2080.     }
  2081.     for i := 0; i < count; i++ {
  2082.         err = writeElement(w, alert.SetCancel[i])
  2083.         if err != nil {
  2084.             return err
  2085.         }
  2086.     }
  2087.  
  2088.     err = writeElements(w, alert.MinVer, alert.MaxVer)
  2089.     if err != nil {
  2090.         return err
  2091.     }
  2092.  
  2093.     count = len(alert.SetSubVer)
  2094.     if count > maxCountSetSubVer {
  2095.         str := fmt.Sprintf("too many sub versions for alert "+
  2096.             "[count %v, max %v]", count, maxCountSetSubVer)
  2097.         return messageError("Alert.Serialize", str)
  2098.     }
  2099.     err = WriteVarInt(w, pver, uint64(count))
  2100.     if err != nil {
  2101.         return err
  2102.     }
  2103.     for i := 0; i < count; i++ {
  2104.         err = WriteVarString(w, pver, alert.SetSubVer[i])
  2105.         if err != nil {
  2106.             return err
  2107.         }
  2108.     }
  2109.  
  2110.     err = writeElement(w, alert.Priority)
  2111.     if err != nil {
  2112.         return err
  2113.     }
  2114.     err = WriteVarString(w, pver, alert.Comment)
  2115.     if err != nil {
  2116.         return err
  2117.     }
  2118.     err = WriteVarString(w, pver, alert.StatusBar)
  2119.     if err != nil {
  2120.         return err
  2121.     }
  2122.     return WriteVarString(w, pver, alert.Reserved)
  2123. }
  2124.  
  2125. func (alert *Alert) Deserialize(r io.Reader, pver uint32) error {
  2126.     err := readElements(r, &alert.Version, &alert.RelayUntil,
  2127.         &alert.Expiration, &alert.ID, &alert.Cancel)
  2128.     if err != nil {
  2129.         return err
  2130.     }
  2131.  
  2132.     count, err := ReadVarInt(r, pver)
  2133.     if err != nil {
  2134.         return err
  2135.     }
  2136.     if count > maxCountSetCancel {
  2137.         str := fmt.Sprintf("too many cancel alert IDs for alert "+
  2138.             "[count %v, max %v]", count, maxCountSetCancel)
  2139.         return messageError("Alert.Deserialize", str)
  2140.     }
  2141.     alert.SetCancel = make([]int32, count)
  2142.     for i := 0; i < int(count); i++ {
  2143.         err := readElement(r, &alert.SetCancel[i])
  2144.         if err != nil {
  2145.             return err
  2146.         }
  2147.     }
  2148.  
  2149.     err = readElements(r, &alert.MinVer, &alert.MaxVer)
  2150.     if err != nil {
  2151.         return err
  2152.     }
  2153.  
  2154.     count, err = ReadVarInt(r, pver)
  2155.     if err != nil {
  2156.         return err
  2157.     }
  2158.     if count > maxCountSetSubVer {
  2159.         str := fmt.Sprintf("too many sub versions for alert "+
  2160.             "[count %v, max %v]", count, maxCountSetSubVer)
  2161.         return messageError("Alert.Deserialize", str)
  2162.     }
  2163.     alert.SetSubVer = make([]string, count)
  2164.     for i := 0; i < int(count); i++ {
  2165.         alert.SetSubVer[i], err = ReadVarString(r, pver)
  2166.         if err != nil {
  2167.             return err
  2168.         }
  2169.     }
  2170.  
  2171.     err = readElement(r, &alert.Priority)
  2172.     if err != nil {
  2173.         return err
  2174.     }
  2175.     alert.Comment, err = ReadVarString(r, pver)
  2176.     if err != nil {
  2177.         return err
  2178.     }
  2179.     alert.StatusBar, err = ReadVarString(r, pver)
  2180.     if err != nil {
  2181.         return err
  2182.     }
  2183.     alert.Reserved, err = ReadVarString(r, pver)
  2184.     return err
  2185. }
  2186.  
  2187. func NewAlert(version int32, relayUntil int64, expiration int64,
  2188.     id int32, cancel int32, setCancel []int32, minVer int32,
  2189.     maxVer int32, setSubVer []string, priority int32, comment string,
  2190.     statusBar string) *Alert {
  2191.     return &Alert{
  2192.         Version:    version,
  2193.         RelayUntil: relayUntil,
  2194.         Expiration: expiration,
  2195.         ID:         id,
  2196.         Cancel:     cancel,
  2197.         SetCancel:  setCancel,
  2198.         MinVer:     minVer,
  2199.         MaxVer:     maxVer,
  2200.         SetSubVer:  setSubVer,
  2201.         Priority:   priority,
  2202.         Comment:    comment,
  2203.         StatusBar:  statusBar,
  2204.         Reserved:   "",
  2205.     }
  2206. }
  2207.  
  2208. func NewAlertFromPayload(serializedPayload []byte, pver uint32) (*Alert, error) {
  2209.     var alert Alert
  2210.     r := bytes.NewReader(serializedPayload)
  2211.     err := alert.Deserialize(r, pver)
  2212.     if err != nil {
  2213.         return nil, err
  2214.     }
  2215.     return &alert, nil
  2216. }
  2217.  
  2218. type MsgAlert struct {
  2219.     SerializedPayload []byte
  2220.  
  2221.     Signature []byte
  2222.  
  2223.     Payload *Alert
  2224. }
  2225.  
  2226. func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2227.     var err error
  2228.  
  2229.     msg.SerializedPayload, err = ReadVarBytes(r, pver, MaxMessagePayload,
  2230.         "alert serialized payload")
  2231.     if err != nil {
  2232.         return err
  2233.     }
  2234.  
  2235.     msg.Payload, err = NewAlertFromPayload(msg.SerializedPayload, pver)
  2236.     if err != nil {
  2237.         msg.Payload = nil
  2238.     }
  2239.  
  2240.     msg.Signature, err = ReadVarBytes(r, pver, MaxMessagePayload,
  2241.         "alert signature")
  2242.     return err
  2243. }
  2244.  
  2245. func (msg *MsgAlert) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2246.     var err error
  2247.     var serializedpayload []byte
  2248.     if msg.Payload != nil {
  2249.  
  2250.         r := new(bytes.Buffer)
  2251.         err = msg.Payload.Serialize(r, pver)
  2252.         if err != nil {
  2253.  
  2254.             serializedpayload = msg.SerializedPayload
  2255.         } else {
  2256.             serializedpayload = r.Bytes()
  2257.         }
  2258.     } else {
  2259.         serializedpayload = msg.SerializedPayload
  2260.     }
  2261.     slen := uint64(len(serializedpayload))
  2262.     if slen == 0 {
  2263.         return messageError("MsgAlert.BtcEncode", "empty serialized payload")
  2264.     }
  2265.     err = WriteVarBytes(w, pver, serializedpayload)
  2266.     if err != nil {
  2267.         return err
  2268.     }
  2269.     return WriteVarBytes(w, pver, msg.Signature)
  2270. }
  2271.  
  2272. func (msg *MsgAlert) Command() string {
  2273.     return CmdAlert
  2274. }
  2275.  
  2276. func (msg *MsgAlert) MaxPayloadLength(pver uint32) uint32 {
  2277.  
  2278.     return MaxMessagePayload
  2279. }
  2280.  
  2281. func NewMsgAlert(serializedPayload []byte, signature []byte) *MsgAlert {
  2282.     return &MsgAlert{
  2283.         SerializedPayload: serializedPayload,
  2284.         Signature:         signature,
  2285.         Payload:           nil,
  2286.     }
  2287. }
  2288.  
  2289. const defaultTransactionAlloc = 2048
  2290.  
  2291. const MaxBlocksPerMsg = 500
  2292.  
  2293. const MaxBlockPayload = 4000000
  2294.  
  2295. const maxTxPerBlock = (MaxBlockPayload / minTxPayload) + 1
  2296.  
  2297. type TxLoc struct {
  2298.     TxStart int
  2299.     TxLen   int
  2300. }
  2301.  
  2302. type MsgBlock struct {
  2303.     Header       BlockHeader
  2304.     Transactions []*MsgTx
  2305. }
  2306.  
  2307. func (msg *MsgBlock) AddTransaction(tx *MsgTx) error {
  2308.     msg.Transactions = append(msg.Transactions, tx)
  2309.     return nil
  2310.  
  2311. }
  2312.  
  2313. func (msg *MsgBlock) ClearTransactions() {
  2314.     msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
  2315. }
  2316.  
  2317. func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2318.     err := readBlockHeader(r, pver, &msg.Header)
  2319.     if err != nil {
  2320.         return err
  2321.     }
  2322.  
  2323.     txCount, err := ReadVarInt(r, pver)
  2324.     if err != nil {
  2325.         return err
  2326.     }
  2327.  
  2328.     if txCount > maxTxPerBlock {
  2329.         str := fmt.Sprintf("too many transactions to fit into a block "+
  2330.             "[count %d, max %d]", txCount, maxTxPerBlock)
  2331.         return messageError("MsgBlock.BtcDecode", str)
  2332.     }
  2333.  
  2334.     msg.Transactions = make([]*MsgTx, 0, txCount)
  2335.     for i := uint64(0); i < txCount; i++ {
  2336.         tx := MsgTx{}
  2337.         err := tx.BtcDecode(r, pver, enc)
  2338.         if err != nil {
  2339.             return err
  2340.         }
  2341.         msg.Transactions = append(msg.Transactions, &tx)
  2342.     }
  2343.  
  2344.     return nil
  2345. }
  2346.  
  2347. func (msg *MsgBlock) Deserialize(r io.Reader) error {
  2348.  
  2349.     return msg.BtcDecode(r, 0, WitnessEncoding)
  2350. }
  2351.  
  2352. func (msg *MsgBlock) DeserializeNoWitness(r io.Reader) error {
  2353.     return msg.BtcDecode(r, 0, BaseEncoding)
  2354. }
  2355.  
  2356. func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
  2357.     fullLen := r.Len()
  2358.  
  2359.     err := readBlockHeader(r, 0, &msg.Header)
  2360.     if err != nil {
  2361.         return nil, err
  2362.     }
  2363.  
  2364.     txCount, err := ReadVarInt(r, 0)
  2365.     if err != nil {
  2366.         return nil, err
  2367.     }
  2368.  
  2369.     if txCount > maxTxPerBlock {
  2370.         str := fmt.Sprintf("too many transactions to fit into a block "+
  2371.             "[count %d, max %d]", txCount, maxTxPerBlock)
  2372.         return nil, messageError("MsgBlock.DeserializeTxLoc", str)
  2373.     }
  2374.  
  2375.     msg.Transactions = make([]*MsgTx, 0, txCount)
  2376.     txLocs := make([]TxLoc, txCount)
  2377.     for i := uint64(0); i < txCount; i++ {
  2378.         txLocs[i].TxStart = fullLen - r.Len()
  2379.         tx := MsgTx{}
  2380.         err := tx.Deserialize(r)
  2381.         if err != nil {
  2382.             return nil, err
  2383.         }
  2384.         msg.Transactions = append(msg.Transactions, &tx)
  2385.         txLocs[i].TxLen = (fullLen - r.Len()) - txLocs[i].TxStart
  2386.     }
  2387.  
  2388.     return txLocs, nil
  2389. }
  2390.  
  2391. func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2392.     err := writeBlockHeader(w, pver, &msg.Header)
  2393.     if err != nil {
  2394.         return err
  2395.     }
  2396.  
  2397.     err = WriteVarInt(w, pver, uint64(len(msg.Transactions)))
  2398.     if err != nil {
  2399.         return err
  2400.     }
  2401.  
  2402.     for _, tx := range msg.Transactions {
  2403.         err = tx.BtcEncode(w, pver, enc)
  2404.         if err != nil {
  2405.             return err
  2406.         }
  2407.     }
  2408.  
  2409.     return nil
  2410. }
  2411.  
  2412. func (msg *MsgBlock) Serialize(w io.Writer) error {
  2413.  
  2414.     return msg.BtcEncode(w, 0, WitnessEncoding)
  2415. }
  2416.  
  2417. func (msg *MsgBlock) SerializeNoWitness(w io.Writer) error {
  2418.     return msg.BtcEncode(w, 0, BaseEncoding)
  2419. }
  2420.  
  2421. func (msg *MsgBlock) SerializeSize() int {
  2422.  
  2423.     n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
  2424.  
  2425.     for _, tx := range msg.Transactions {
  2426.         n += tx.SerializeSize()
  2427.     }
  2428.  
  2429.     return n
  2430. }
  2431.  
  2432. func (msg *MsgBlock) SerializeSizeStripped() int {
  2433.  
  2434.     n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
  2435.  
  2436.     for _, tx := range msg.Transactions {
  2437.         n += tx.SerializeSizeStripped()
  2438.     }
  2439.  
  2440.     return n
  2441. }
  2442.  
  2443. func (msg *MsgBlock) Command() string {
  2444.     return CmdBlock
  2445. }
  2446.  
  2447. func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
  2448.  
  2449.     return MaxBlockPayload
  2450. }
  2451.  
  2452. func (msg *MsgBlock) BlockHash() Hash {
  2453.     return msg.Header.BlockHash()
  2454. }
  2455.  
  2456. func (msg *MsgBlock) TxHashes() ([]Hash, error) {
  2457.     hashList := make([]Hash, 0, len(msg.Transactions))
  2458.     for _, tx := range msg.Transactions {
  2459.         hashList = append(hashList, tx.TxHash())
  2460.     }
  2461.     return hashList, nil
  2462. }
  2463.  
  2464. func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
  2465.     return &MsgBlock{
  2466.         Header:       *blockHeader,
  2467.         Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),
  2468.     }
  2469. }
  2470.  
  2471. const (
  2472.     CFCheckptInterval = 1000
  2473.  
  2474.     maxCFHeadersLen = 100000
  2475. )
  2476.  
  2477. var ErrInsaneCFHeaderCount = errors.New(
  2478.     "refusing to decode unreasonable number of filter headers")
  2479.  
  2480. type MsgCFCheckpt struct {
  2481.     FilterType    FilterType
  2482.     StopHash      Hash
  2483.     FilterHeaders []*Hash
  2484. }
  2485.  
  2486. func (msg *MsgCFCheckpt) AddCFHeader(header *Hash) error {
  2487.     if len(msg.FilterHeaders) == cap(msg.FilterHeaders) {
  2488.         str := fmt.Sprintf("FilterHeaders has insufficient capacity for "+
  2489.             "additional header: len = %d", len(msg.FilterHeaders))
  2490.         return messageError("MsgCFCheckpt.AddCFHeader", str)
  2491.     }
  2492.  
  2493.     msg.FilterHeaders = append(msg.FilterHeaders, header)
  2494.     return nil
  2495. }
  2496.  
  2497. func (msg *MsgCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2498.  
  2499.     err := readElement(r, &msg.FilterType)
  2500.     if err != nil {
  2501.         return err
  2502.     }
  2503.  
  2504.     err = readElement(r, &msg.StopHash)
  2505.     if err != nil {
  2506.         return err
  2507.     }
  2508.  
  2509.     count, err := ReadVarInt(r, pver)
  2510.     if err != nil {
  2511.         return err
  2512.     }
  2513.  
  2514.     if count > maxCFHeadersLen {
  2515.         return ErrInsaneCFHeaderCount
  2516.     }
  2517.  
  2518.     msg.FilterHeaders = make([]*Hash, count)
  2519.     for i := uint64(0); i < count; i++ {
  2520.         var cfh Hash
  2521.         err := readElement(r, &cfh)
  2522.         if err != nil {
  2523.             return err
  2524.         }
  2525.         msg.FilterHeaders[i] = &cfh
  2526.     }
  2527.  
  2528.     return nil
  2529. }
  2530.  
  2531. func (msg *MsgCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2532.  
  2533.     err := writeElement(w, msg.FilterType)
  2534.     if err != nil {
  2535.         return err
  2536.     }
  2537.  
  2538.     err = writeElement(w, msg.StopHash)
  2539.     if err != nil {
  2540.         return err
  2541.     }
  2542.  
  2543.     count := len(msg.FilterHeaders)
  2544.     err = WriteVarInt(w, pver, uint64(count))
  2545.     if err != nil {
  2546.         return err
  2547.     }
  2548.  
  2549.     for _, cfh := range msg.FilterHeaders {
  2550.         err := writeElement(w, cfh)
  2551.         if err != nil {
  2552.             return err
  2553.         }
  2554.     }
  2555.  
  2556.     return nil
  2557. }
  2558.  
  2559. func (msg *MsgCFCheckpt) Deserialize(r io.Reader) error {
  2560.  
  2561.     return msg.BtcDecode(r, 0, BaseEncoding)
  2562. }
  2563.  
  2564. func (msg *MsgCFCheckpt) Command() string {
  2565.     return CmdCFCheckpt
  2566. }
  2567.  
  2568. func (msg *MsgCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
  2569.  
  2570.     return MaxMessagePayload
  2571. }
  2572.  
  2573. func NewMsgCFCheckpt(filterType FilterType, stopHash *Hash,
  2574.     headersCount int) *MsgCFCheckpt {
  2575.     return &MsgCFCheckpt{
  2576.         FilterType:    filterType,
  2577.         StopHash:      *stopHash,
  2578.         FilterHeaders: make([]*Hash, 0, headersCount),
  2579.     }
  2580. }
  2581.  
  2582. const (
  2583.     MaxCFHeaderPayload = HashSize
  2584.  
  2585.     MaxCFHeadersPerMsg = 2000
  2586. )
  2587.  
  2588. type MsgCFHeaders struct {
  2589.     FilterType       FilterType
  2590.     StopHash         Hash
  2591.     PrevFilterHeader Hash
  2592.     FilterHashes     []*Hash
  2593. }
  2594.  
  2595. func (msg *MsgCFHeaders) AddCFHash(hash *Hash) error {
  2596.     if len(msg.FilterHashes)+1 > MaxCFHeadersPerMsg {
  2597.         str := fmt.Sprintf("too many block headers in message [max %v]",
  2598.             MaxBlockHeadersPerMsg)
  2599.         return messageError("MsgCFHeaders.AddCFHash", str)
  2600.     }
  2601.  
  2602.     msg.FilterHashes = append(msg.FilterHashes, hash)
  2603.     return nil
  2604. }
  2605.  
  2606. func (msg *MsgCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2607.  
  2608.     err := readElement(r, &msg.FilterType)
  2609.     if err != nil {
  2610.         return err
  2611.     }
  2612.  
  2613.     err = readElement(r, &msg.StopHash)
  2614.     if err != nil {
  2615.         return err
  2616.     }
  2617.  
  2618.     err = readElement(r, &msg.PrevFilterHeader)
  2619.     if err != nil {
  2620.         return err
  2621.     }
  2622.  
  2623.     count, err := ReadVarInt(r, pver)
  2624.     if err != nil {
  2625.         return err
  2626.     }
  2627.  
  2628.     if count > MaxCFHeadersPerMsg {
  2629.         str := fmt.Sprintf("too many committed filter headers for "+
  2630.             "message [count %v, max %v]", count,
  2631.             MaxBlockHeadersPerMsg)
  2632.         return messageError("MsgCFHeaders.BtcDecode", str)
  2633.     }
  2634.  
  2635.     msg.FilterHashes = make([]*Hash, 0, count)
  2636.     for i := uint64(0); i < count; i++ {
  2637.         var cfh Hash
  2638.         err := readElement(r, &cfh)
  2639.         if err != nil {
  2640.             return err
  2641.         }
  2642.         msg.AddCFHash(&cfh)
  2643.     }
  2644.  
  2645.     return nil
  2646. }
  2647.  
  2648. func (msg *MsgCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2649.  
  2650.     err := writeElement(w, msg.FilterType)
  2651.     if err != nil {
  2652.         return err
  2653.     }
  2654.  
  2655.     err = writeElement(w, msg.StopHash)
  2656.     if err != nil {
  2657.         return err
  2658.     }
  2659.  
  2660.     err = writeElement(w, msg.PrevFilterHeader)
  2661.     if err != nil {
  2662.         return err
  2663.     }
  2664.  
  2665.     count := len(msg.FilterHashes)
  2666.     if count > MaxCFHeadersPerMsg {
  2667.         str := fmt.Sprintf("too many committed filter headers for "+
  2668.             "message [count %v, max %v]", count,
  2669.             MaxBlockHeadersPerMsg)
  2670.         return messageError("MsgCFHeaders.BtcEncode", str)
  2671.     }
  2672.  
  2673.     err = WriteVarInt(w, pver, uint64(count))
  2674.     if err != nil {
  2675.         return err
  2676.     }
  2677.  
  2678.     for _, cfh := range msg.FilterHashes {
  2679.         err := writeElement(w, cfh)
  2680.         if err != nil {
  2681.             return err
  2682.         }
  2683.     }
  2684.  
  2685.     return nil
  2686. }
  2687.  
  2688. func (msg *MsgCFHeaders) Deserialize(r io.Reader) error {
  2689.  
  2690.     return msg.BtcDecode(r, 0, BaseEncoding)
  2691. }
  2692.  
  2693. func (msg *MsgCFHeaders) Command() string {
  2694.     return CmdCFHeaders
  2695. }
  2696.  
  2697. func (msg *MsgCFHeaders) MaxPayloadLength(pver uint32) uint32 {
  2698.  
  2699.     return 1 + HashSize + HashSize + MaxVarIntPayload +
  2700.         (MaxCFHeaderPayload * MaxCFHeadersPerMsg)
  2701. }
  2702.  
  2703. func NewMsgCFHeaders() *MsgCFHeaders {
  2704.     return &MsgCFHeaders{
  2705.         FilterHashes: make([]*Hash, 0, MaxCFHeadersPerMsg),
  2706.     }
  2707. }
  2708.  
  2709. type FilterType uint8
  2710.  
  2711. const (
  2712.     GCSFilterRegular FilterType = iota
  2713. )
  2714.  
  2715. const (
  2716.     MaxCFilterDataSize = 256 * 1024
  2717. )
  2718.  
  2719. type MsgCFilter struct {
  2720.     FilterType FilterType
  2721.     BlockHash  Hash
  2722.     Data       []byte
  2723. }
  2724.  
  2725. func (msg *MsgCFilter) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  2726.  
  2727.     err := readElement(r, &msg.FilterType)
  2728.     if err != nil {
  2729.         return err
  2730.     }
  2731.  
  2732.     err = readElement(r, &msg.BlockHash)
  2733.     if err != nil {
  2734.         return err
  2735.     }
  2736.  
  2737.     msg.Data, err = ReadVarBytes(r, pver, MaxCFilterDataSize,
  2738.         "cfilter data")
  2739.     return err
  2740. }
  2741.  
  2742. func (msg *MsgCFilter) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  2743.     size := len(msg.Data)
  2744.     if size > MaxCFilterDataSize {
  2745.         str := fmt.Sprintf("cfilter size too large for message "+
  2746.             "[size %v, max %v]", size, MaxCFilterDataSize)
  2747.         return messageError("MsgCFilter.BtcEncode", str)
  2748.     }
  2749.  
  2750.     err := writeElement(w, msg.FilterType)
  2751.     if err != nil {
  2752.         return err
  2753.     }
  2754.  
  2755.     err = writeElement(w, msg.BlockHash)
  2756.     if err != nil {
  2757.         return err
  2758.     }
  2759.  
  2760.     return WriteVarBytes(w, pver, msg.Data)
  2761. }
  2762.  
  2763. func (msg *MsgCFilter) Deserialize(r io.Reader) error {
  2764.  
  2765.     return msg.BtcDecode(r, 0, BaseEncoding)
  2766. }
  2767.  
  2768. func (msg *MsgCFilter) Command() string {
  2769.     return CmdCFilter
  2770. }
  2771.  
  2772. func (msg *MsgCFilter) MaxPayloadLength(pver uint32) uint32 {
  2773.     return uint32(VarIntSerializeSize(MaxCFilterDataSize)) +
  2774.         MaxCFilterDataSize + HashSize + 1
  2775. }
  2776.  
  2777. func NewMsgCFilter(filterType FilterType, blockHash *Hash,
  2778.     data []byte) *MsgCFilter {
  2779.     return &MsgCFilter{
  2780.         FilterType: filterType,
  2781.         BlockHash:  *blockHash,
  2782.         Data:       data,
  2783.     }
  2784. }
  2785.  
  2786. type MsgFeeFilter struct {
  2787.     MinFee int64
  2788. }
  2789.  
  2790. func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2791.     if pver < FeeFilterVersion {
  2792.         str := fmt.Sprintf("feefilter message invalid for protocol "+
  2793.             "version %d", pver)
  2794.         return messageError("MsgFeeFilter.BtcDecode", str)
  2795.     }
  2796.  
  2797.     return readElement(r, &msg.MinFee)
  2798. }
  2799.  
  2800. func (msg *MsgFeeFilter) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2801.     if pver < FeeFilterVersion {
  2802.         str := fmt.Sprintf("feefilter message invalid for protocol "+
  2803.             "version %d", pver)
  2804.         return messageError("MsgFeeFilter.BtcEncode", str)
  2805.     }
  2806.  
  2807.     return writeElement(w, msg.MinFee)
  2808. }
  2809.  
  2810. func (msg *MsgFeeFilter) Command() string {
  2811.     return CmdFeeFilter
  2812. }
  2813.  
  2814. func (msg *MsgFeeFilter) MaxPayloadLength(pver uint32) uint32 {
  2815.     return 8
  2816. }
  2817.  
  2818. func NewMsgFeeFilter(minfee int64) *MsgFeeFilter {
  2819.     return &MsgFeeFilter{
  2820.         MinFee: minfee,
  2821.     }
  2822. }
  2823.  
  2824. const (
  2825.     MaxFilterAddDataSize = 520
  2826. )
  2827.  
  2828. type MsgFilterAdd struct {
  2829.     Data []byte
  2830. }
  2831.  
  2832. func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2833.     if pver < BIP0037Version {
  2834.         str := fmt.Sprintf("filteradd message invalid for protocol "+
  2835.             "version %d", pver)
  2836.         return messageError("MsgFilterAdd.BtcDecode", str)
  2837.     }
  2838.  
  2839.     var err error
  2840.     msg.Data, err = ReadVarBytes(r, pver, MaxFilterAddDataSize,
  2841.         "filteradd data")
  2842.     return err
  2843. }
  2844.  
  2845. func (msg *MsgFilterAdd) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2846.     if pver < BIP0037Version {
  2847.         str := fmt.Sprintf("filteradd message invalid for protocol "+
  2848.             "version %d", pver)
  2849.         return messageError("MsgFilterAdd.BtcEncode", str)
  2850.     }
  2851.  
  2852.     size := len(msg.Data)
  2853.     if size > MaxFilterAddDataSize {
  2854.         str := fmt.Sprintf("filteradd size too large for message "+
  2855.             "[size %v, max %v]", size, MaxFilterAddDataSize)
  2856.         return messageError("MsgFilterAdd.BtcEncode", str)
  2857.     }
  2858.  
  2859.     return WriteVarBytes(w, pver, msg.Data)
  2860. }
  2861.  
  2862. func (msg *MsgFilterAdd) Command() string {
  2863.     return CmdFilterAdd
  2864. }
  2865.  
  2866. func (msg *MsgFilterAdd) MaxPayloadLength(pver uint32) uint32 {
  2867.     return uint32(VarIntSerializeSize(MaxFilterAddDataSize)) +
  2868.         MaxFilterAddDataSize
  2869. }
  2870.  
  2871. func NewMsgFilterAdd(data []byte) *MsgFilterAdd {
  2872.     return &MsgFilterAdd{
  2873.         Data: data,
  2874.     }
  2875. }
  2876.  
  2877. type MsgFilterClear struct{}
  2878.  
  2879. func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2880.     if pver < BIP0037Version {
  2881.         str := fmt.Sprintf("filterclear message invalid for protocol "+
  2882.             "version %d", pver)
  2883.         return messageError("MsgFilterClear.BtcDecode", str)
  2884.     }
  2885.  
  2886.     return nil
  2887. }
  2888.  
  2889. func (msg *MsgFilterClear) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2890.     if pver < BIP0037Version {
  2891.         str := fmt.Sprintf("filterclear message invalid for protocol "+
  2892.             "version %d", pver)
  2893.         return messageError("MsgFilterClear.BtcEncode", str)
  2894.     }
  2895.  
  2896.     return nil
  2897. }
  2898.  
  2899. func (msg *MsgFilterClear) Command() string {
  2900.     return CmdFilterClear
  2901. }
  2902.  
  2903. func (msg *MsgFilterClear) MaxPayloadLength(pver uint32) uint32 {
  2904.     return 0
  2905. }
  2906.  
  2907. func NewMsgFilterClear() *MsgFilterClear {
  2908.     return &MsgFilterClear{}
  2909. }
  2910.  
  2911. type BloomUpdateType uint8
  2912.  
  2913. const (
  2914.     BloomUpdateNone BloomUpdateType = 0
  2915.  
  2916.     BloomUpdateAll BloomUpdateType = 1
  2917.  
  2918.     BloomUpdateP2PubkeyOnly BloomUpdateType = 2
  2919. )
  2920.  
  2921. const (
  2922.     MaxFilterLoadHashFuncs = 50
  2923.  
  2924.     MaxFilterLoadFilterSize = 36000
  2925. )
  2926.  
  2927. type MsgFilterLoad struct {
  2928.     Filter    []byte
  2929.     HashFuncs uint32
  2930.     Tweak     uint32
  2931.     Flags     BloomUpdateType
  2932. }
  2933.  
  2934. func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  2935.     if pver < BIP0037Version {
  2936.         str := fmt.Sprintf("filterload message invalid for protocol "+
  2937.             "version %d", pver)
  2938.         return messageError("MsgFilterLoad.BtcDecode", str)
  2939.     }
  2940.  
  2941.     var err error
  2942.     msg.Filter, err = ReadVarBytes(r, pver, MaxFilterLoadFilterSize,
  2943.         "filterload filter size")
  2944.     if err != nil {
  2945.         return err
  2946.     }
  2947.  
  2948.     err = readElements(r, &msg.HashFuncs, &msg.Tweak, &msg.Flags)
  2949.     if err != nil {
  2950.         return err
  2951.     }
  2952.  
  2953.     if msg.HashFuncs > MaxFilterLoadHashFuncs {
  2954.         str := fmt.Sprintf("too many filter hash functions for message "+
  2955.             "[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
  2956.         return messageError("MsgFilterLoad.BtcDecode", str)
  2957.     }
  2958.  
  2959.     return nil
  2960. }
  2961.  
  2962. func (msg *MsgFilterLoad) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  2963.     if pver < BIP0037Version {
  2964.         str := fmt.Sprintf("filterload message invalid for protocol "+
  2965.             "version %d", pver)
  2966.         return messageError("MsgFilterLoad.BtcEncode", str)
  2967.     }
  2968.  
  2969.     size := len(msg.Filter)
  2970.     if size > MaxFilterLoadFilterSize {
  2971.         str := fmt.Sprintf("filterload filter size too large for message "+
  2972.             "[size %v, max %v]", size, MaxFilterLoadFilterSize)
  2973.         return messageError("MsgFilterLoad.BtcEncode", str)
  2974.     }
  2975.  
  2976.     if msg.HashFuncs > MaxFilterLoadHashFuncs {
  2977.         str := fmt.Sprintf("too many filter hash functions for message "+
  2978.             "[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
  2979.         return messageError("MsgFilterLoad.BtcEncode", str)
  2980.     }
  2981.  
  2982.     err := WriteVarBytes(w, pver, msg.Filter)
  2983.     if err != nil {
  2984.         return err
  2985.     }
  2986.  
  2987.     return writeElements(w, msg.HashFuncs, msg.Tweak, msg.Flags)
  2988. }
  2989.  
  2990. func (msg *MsgFilterLoad) Command() string {
  2991.     return CmdFilterLoad
  2992. }
  2993.  
  2994. func (msg *MsgFilterLoad) MaxPayloadLength(pver uint32) uint32 {
  2995.  
  2996.     return uint32(VarIntSerializeSize(MaxFilterLoadFilterSize)) +
  2997.         MaxFilterLoadFilterSize + 9
  2998. }
  2999.  
  3000. func NewMsgFilterLoad(filter []byte, hashFuncs uint32, tweak uint32, flags BloomUpdateType) *MsgFilterLoad {
  3001.     return &MsgFilterLoad{
  3002.         Filter:    filter,
  3003.         HashFuncs: hashFuncs,
  3004.         Tweak:     tweak,
  3005.         Flags:     flags,
  3006.     }
  3007. }
  3008.  
  3009. type MsgGetAddr struct{}
  3010.  
  3011. func (msg *MsgGetAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3012.     return nil
  3013. }
  3014.  
  3015. func (msg *MsgGetAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3016.     return nil
  3017. }
  3018.  
  3019. func (msg *MsgGetAddr) Command() string {
  3020.     return CmdGetAddr
  3021. }
  3022.  
  3023. func (msg *MsgGetAddr) MaxPayloadLength(pver uint32) uint32 {
  3024.     return 0
  3025. }
  3026.  
  3027. func NewMsgGetAddr() *MsgGetAddr {
  3028.     return &MsgGetAddr{}
  3029. }
  3030.  
  3031. const MaxBlockLocatorsPerMsg = 500
  3032.  
  3033. type MsgGetBlocks struct {
  3034.     ProtocolVersion    uint32
  3035.     BlockLocatorHashes []*Hash
  3036.     HashStop           Hash
  3037. }
  3038.  
  3039. func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *Hash) error {
  3040.     if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
  3041.         str := fmt.Sprintf("too many block locator hashes for message [max %v]",
  3042.             MaxBlockLocatorsPerMsg)
  3043.         return messageError("MsgGetBlocks.AddBlockLocatorHash", str)
  3044.     }
  3045.  
  3046.     msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
  3047.     return nil
  3048. }
  3049.  
  3050. func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3051.     err := readElement(r, &msg.ProtocolVersion)
  3052.     if err != nil {
  3053.         return err
  3054.     }
  3055.  
  3056.     count, err := ReadVarInt(r, pver)
  3057.     if err != nil {
  3058.         return err
  3059.     }
  3060.     if count > MaxBlockLocatorsPerMsg {
  3061.         str := fmt.Sprintf("too many block locator hashes for message "+
  3062.             "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3063.         return messageError("MsgGetBlocks.BtcDecode", str)
  3064.     }
  3065.  
  3066.     locatorHashes := make([]Hash, count)
  3067.     msg.BlockLocatorHashes = make([]*Hash, 0, count)
  3068.     for i := uint64(0); i < count; i++ {
  3069.         hash := &locatorHashes[i]
  3070.         err := readElement(r, hash)
  3071.         if err != nil {
  3072.             return err
  3073.         }
  3074.         msg.AddBlockLocatorHash(hash)
  3075.     }
  3076.  
  3077.     return readElement(r, &msg.HashStop)
  3078. }
  3079.  
  3080. func (msg *MsgGetBlocks) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3081.     count := len(msg.BlockLocatorHashes)
  3082.     if count > MaxBlockLocatorsPerMsg {
  3083.         str := fmt.Sprintf("too many block locator hashes for message "+
  3084.             "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3085.         return messageError("MsgGetBlocks.BtcEncode", str)
  3086.     }
  3087.  
  3088.     err := writeElement(w, msg.ProtocolVersion)
  3089.     if err != nil {
  3090.         return err
  3091.     }
  3092.  
  3093.     err = WriteVarInt(w, pver, uint64(count))
  3094.     if err != nil {
  3095.         return err
  3096.     }
  3097.  
  3098.     for _, hash := range msg.BlockLocatorHashes {
  3099.         err = writeElement(w, hash)
  3100.         if err != nil {
  3101.             return err
  3102.         }
  3103.     }
  3104.  
  3105.     return writeElement(w, &msg.HashStop)
  3106. }
  3107.  
  3108. func (msg *MsgGetBlocks) Command() string {
  3109.     return CmdGetBlocks
  3110. }
  3111.  
  3112. func (msg *MsgGetBlocks) MaxPayloadLength(pver uint32) uint32 {
  3113.  
  3114.     return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg * HashSize) + HashSize
  3115. }
  3116.  
  3117. func NewMsgGetBlocks(hashStop *Hash) *MsgGetBlocks {
  3118.     return &MsgGetBlocks{
  3119.         ProtocolVersion:    ProtocolVersion,
  3120.         BlockLocatorHashes: make([]*Hash, 0, MaxBlockLocatorsPerMsg),
  3121.         HashStop:           *hashStop,
  3122.     }
  3123. }
  3124.  
  3125. type MsgGetCFCheckpt struct {
  3126.     FilterType FilterType
  3127.     StopHash   Hash
  3128. }
  3129.  
  3130. func (msg *MsgGetCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3131.     err := readElement(r, &msg.FilterType)
  3132.     if err != nil {
  3133.         return err
  3134.     }
  3135.  
  3136.     return readElement(r, &msg.StopHash)
  3137. }
  3138.  
  3139. func (msg *MsgGetCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3140.     err := writeElement(w, msg.FilterType)
  3141.     if err != nil {
  3142.         return err
  3143.     }
  3144.  
  3145.     return writeElement(w, &msg.StopHash)
  3146. }
  3147.  
  3148. func (msg *MsgGetCFCheckpt) Command() string {
  3149.     return CmdGetCFCheckpt
  3150. }
  3151.  
  3152. func (msg *MsgGetCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
  3153.  
  3154.     return 1 + HashSize
  3155. }
  3156.  
  3157. func NewMsgGetCFCheckpt(filterType FilterType, stopHash *Hash) *MsgGetCFCheckpt {
  3158.     return &MsgGetCFCheckpt{
  3159.         FilterType: filterType,
  3160.         StopHash:   *stopHash,
  3161.     }
  3162. }
  3163.  
  3164. type MsgGetCFHeaders struct {
  3165.     FilterType  FilterType
  3166.     StartHeight uint32
  3167.     StopHash    Hash
  3168. }
  3169.  
  3170. func (msg *MsgGetCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3171.     err := readElement(r, &msg.FilterType)
  3172.     if err != nil {
  3173.         return err
  3174.     }
  3175.  
  3176.     err = readElement(r, &msg.StartHeight)
  3177.     if err != nil {
  3178.         return err
  3179.     }
  3180.  
  3181.     return readElement(r, &msg.StopHash)
  3182. }
  3183.  
  3184. func (msg *MsgGetCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3185.     err := writeElement(w, msg.FilterType)
  3186.     if err != nil {
  3187.         return err
  3188.     }
  3189.  
  3190.     err = writeElement(w, &msg.StartHeight)
  3191.     if err != nil {
  3192.         return err
  3193.     }
  3194.  
  3195.     return writeElement(w, &msg.StopHash)
  3196. }
  3197.  
  3198. func (msg *MsgGetCFHeaders) Command() string {
  3199.     return CmdGetCFHeaders
  3200. }
  3201.  
  3202. func (msg *MsgGetCFHeaders) MaxPayloadLength(pver uint32) uint32 {
  3203.  
  3204.     return 1 + 4 + HashSize
  3205. }
  3206.  
  3207. func NewMsgGetCFHeaders(filterType FilterType, startHeight uint32,
  3208.     stopHash *Hash) *MsgGetCFHeaders {
  3209.     return &MsgGetCFHeaders{
  3210.         FilterType:  filterType,
  3211.         StartHeight: startHeight,
  3212.         StopHash:    *stopHash,
  3213.     }
  3214. }
  3215.  
  3216. const MaxGetCFiltersReqRange = 1000
  3217.  
  3218. type MsgGetCFilters struct {
  3219.     FilterType  FilterType
  3220.     StartHeight uint32
  3221.     StopHash    Hash
  3222. }
  3223.  
  3224. func (msg *MsgGetCFilters) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
  3225.     err := readElement(r, &msg.FilterType)
  3226.     if err != nil {
  3227.         return err
  3228.     }
  3229.  
  3230.     err = readElement(r, &msg.StartHeight)
  3231.     if err != nil {
  3232.         return err
  3233.     }
  3234.  
  3235.     return readElement(r, &msg.StopHash)
  3236. }
  3237.  
  3238. func (msg *MsgGetCFilters) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
  3239.     err := writeElement(w, msg.FilterType)
  3240.     if err != nil {
  3241.         return err
  3242.     }
  3243.  
  3244.     err = writeElement(w, &msg.StartHeight)
  3245.     if err != nil {
  3246.         return err
  3247.     }
  3248.  
  3249.     return writeElement(w, &msg.StopHash)
  3250. }
  3251.  
  3252. func (msg *MsgGetCFilters) Command() string {
  3253.     return CmdGetCFilters
  3254. }
  3255.  
  3256. func (msg *MsgGetCFilters) MaxPayloadLength(pver uint32) uint32 {
  3257.  
  3258.     return 1 + 4 + HashSize
  3259. }
  3260.  
  3261. func NewMsgGetCFilters(filterType FilterType, startHeight uint32,
  3262.     stopHash *Hash) *MsgGetCFilters {
  3263.     return &MsgGetCFilters{
  3264.         FilterType:  filterType,
  3265.         StartHeight: startHeight,
  3266.         StopHash:    *stopHash,
  3267.     }
  3268. }
  3269.  
  3270. type MsgGetData struct {
  3271.     InvList []*InvVect
  3272. }
  3273.  
  3274. func (msg *MsgGetData) AddInvVect(iv *InvVect) error {
  3275.     if len(msg.InvList)+1 > MaxInvPerMsg {
  3276.         str := fmt.Sprintf("too many invvect in message [max %v]",
  3277.             MaxInvPerMsg)
  3278.         return messageError("MsgGetData.AddInvVect", str)
  3279.     }
  3280.  
  3281.     msg.InvList = append(msg.InvList, iv)
  3282.     return nil
  3283. }
  3284.  
  3285. func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3286.     count, err := ReadVarInt(r, pver)
  3287.     if err != nil {
  3288.         return err
  3289.     }
  3290.  
  3291.     if count > MaxInvPerMsg {
  3292.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3293.         return messageError("MsgGetData.BtcDecode", str)
  3294.     }
  3295.  
  3296.     invList := make([]InvVect, count)
  3297.     msg.InvList = make([]*InvVect, 0, count)
  3298.     for i := uint64(0); i < count; i++ {
  3299.         iv := &invList[i]
  3300.         err := readInvVect(r, pver, iv)
  3301.         if err != nil {
  3302.             return err
  3303.         }
  3304.         msg.AddInvVect(iv)
  3305.     }
  3306.  
  3307.     return nil
  3308. }
  3309.  
  3310. func (msg *MsgGetData) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3311.  
  3312.     count := len(msg.InvList)
  3313.     if count > MaxInvPerMsg {
  3314.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3315.         return messageError("MsgGetData.BtcEncode", str)
  3316.     }
  3317.  
  3318.     err := WriteVarInt(w, pver, uint64(count))
  3319.     if err != nil {
  3320.         return err
  3321.     }
  3322.  
  3323.     for _, iv := range msg.InvList {
  3324.         err := writeInvVect(w, pver, iv)
  3325.         if err != nil {
  3326.             return err
  3327.         }
  3328.     }
  3329.  
  3330.     return nil
  3331. }
  3332.  
  3333. func (msg *MsgGetData) Command() string {
  3334.     return CmdGetData
  3335. }
  3336.  
  3337. func (msg *MsgGetData) MaxPayloadLength(pver uint32) uint32 {
  3338.  
  3339.     return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3340. }
  3341.  
  3342. func NewMsgGetData() *MsgGetData {
  3343.     return &MsgGetData{
  3344.         InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3345.     }
  3346. }
  3347.  
  3348. func NewMsgGetDataSizeHint(sizeHint uint) *MsgGetData {
  3349.  
  3350.     if sizeHint > MaxInvPerMsg {
  3351.         sizeHint = MaxInvPerMsg
  3352.     }
  3353.  
  3354.     return &MsgGetData{
  3355.         InvList: make([]*InvVect, 0, sizeHint),
  3356.     }
  3357. }
  3358.  
  3359. type MsgGetHeaders struct {
  3360.     ProtocolVersion    uint32
  3361.     BlockLocatorHashes []*Hash
  3362.     HashStop           Hash
  3363. }
  3364.  
  3365. func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *Hash) error {
  3366.     if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
  3367.         str := fmt.Sprintf("too many block locator hashes for message [max %v]",
  3368.             MaxBlockLocatorsPerMsg)
  3369.         return messageError("MsgGetHeaders.AddBlockLocatorHash", str)
  3370.     }
  3371.  
  3372.     msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
  3373.     return nil
  3374. }
  3375.  
  3376. func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3377.     err := readElement(r, &msg.ProtocolVersion)
  3378.     if err != nil {
  3379.         return err
  3380.     }
  3381.  
  3382.     count, err := ReadVarInt(r, pver)
  3383.     if err != nil {
  3384.         return err
  3385.     }
  3386.     if count > MaxBlockLocatorsPerMsg {
  3387.         str := fmt.Sprintf("too many block locator hashes for message "+
  3388.             "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3389.         return messageError("MsgGetHeaders.BtcDecode", str)
  3390.     }
  3391.  
  3392.     locatorHashes := make([]Hash, count)
  3393.     msg.BlockLocatorHashes = make([]*Hash, 0, count)
  3394.     for i := uint64(0); i < count; i++ {
  3395.         hash := &locatorHashes[i]
  3396.         err := readElement(r, hash)
  3397.         if err != nil {
  3398.             return err
  3399.         }
  3400.         msg.AddBlockLocatorHash(hash)
  3401.     }
  3402.  
  3403.     return readElement(r, &msg.HashStop)
  3404. }
  3405.  
  3406. func (msg *MsgGetHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3407.  
  3408.     count := len(msg.BlockLocatorHashes)
  3409.     if count > MaxBlockLocatorsPerMsg {
  3410.         str := fmt.Sprintf("too many block locator hashes for message "+
  3411.             "[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
  3412.         return messageError("MsgGetHeaders.BtcEncode", str)
  3413.     }
  3414.  
  3415.     err := writeElement(w, msg.ProtocolVersion)
  3416.     if err != nil {
  3417.         return err
  3418.     }
  3419.  
  3420.     err = WriteVarInt(w, pver, uint64(count))
  3421.     if err != nil {
  3422.         return err
  3423.     }
  3424.  
  3425.     for _, hash := range msg.BlockLocatorHashes {
  3426.         err := writeElement(w, hash)
  3427.         if err != nil {
  3428.             return err
  3429.         }
  3430.     }
  3431.  
  3432.     return writeElement(w, &msg.HashStop)
  3433. }
  3434.  
  3435. func (msg *MsgGetHeaders) Command() string {
  3436.     return CmdGetHeaders
  3437. }
  3438.  
  3439. func (msg *MsgGetHeaders) MaxPayloadLength(pver uint32) uint32 {
  3440.  
  3441.     return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg *
  3442.         HashSize) + HashSize
  3443. }
  3444.  
  3445. func NewMsgGetHeaders() *MsgGetHeaders {
  3446.     return &MsgGetHeaders{
  3447.         BlockLocatorHashes: make([]*Hash, 0,
  3448.             MaxBlockLocatorsPerMsg),
  3449.     }
  3450. }
  3451.  
  3452. const MaxBlockHeadersPerMsg = 2000
  3453.  
  3454. type MsgHeaders struct {
  3455.     Headers []*BlockHeader
  3456. }
  3457.  
  3458. func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
  3459.     if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
  3460.         str := fmt.Sprintf("too many block headers in message [max %v]",
  3461.             MaxBlockHeadersPerMsg)
  3462.         return messageError("MsgHeaders.AddBlockHeader", str)
  3463.     }
  3464.  
  3465.     msg.Headers = append(msg.Headers, bh)
  3466.     return nil
  3467. }
  3468.  
  3469. func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3470.     count, err := ReadVarInt(r, pver)
  3471.     if err != nil {
  3472.         return err
  3473.     }
  3474.  
  3475.     if count > MaxBlockHeadersPerMsg {
  3476.         str := fmt.Sprintf("too many block headers for message "+
  3477.             "[count %v, max %v]", count, MaxBlockHeadersPerMsg)
  3478.         return messageError("MsgHeaders.BtcDecode", str)
  3479.     }
  3480.  
  3481.     headers := make([]BlockHeader, count)
  3482.     msg.Headers = make([]*BlockHeader, 0, count)
  3483.     for i := uint64(0); i < count; i++ {
  3484.         bh := &headers[i]
  3485.         err := readBlockHeader(r, pver, bh)
  3486.         if err != nil {
  3487.             return err
  3488.         }
  3489.  
  3490.         txCount, err := ReadVarInt(r, pver)
  3491.         if err != nil {
  3492.             return err
  3493.         }
  3494.  
  3495.         if txCount > 0 {
  3496.             str := fmt.Sprintf("block headers may not contain "+
  3497.                 "transactions [count %v]", txCount)
  3498.             return messageError("MsgHeaders.BtcDecode", str)
  3499.         }
  3500.         msg.AddBlockHeader(bh)
  3501.     }
  3502.  
  3503.     return nil
  3504. }
  3505.  
  3506. func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3507.  
  3508.     count := len(msg.Headers)
  3509.     if count > MaxBlockHeadersPerMsg {
  3510.         str := fmt.Sprintf("too many block headers for message "+
  3511.             "[count %v, max %v]", count, MaxBlockHeadersPerMsg)
  3512.         return messageError("MsgHeaders.BtcEncode", str)
  3513.     }
  3514.  
  3515.     err := WriteVarInt(w, pver, uint64(count))
  3516.     if err != nil {
  3517.         return err
  3518.     }
  3519.  
  3520.     for _, bh := range msg.Headers {
  3521.         err := writeBlockHeader(w, pver, bh)
  3522.         if err != nil {
  3523.             return err
  3524.         }
  3525.  
  3526.         err = WriteVarInt(w, pver, 0)
  3527.         if err != nil {
  3528.             return err
  3529.         }
  3530.     }
  3531.  
  3532.     return nil
  3533. }
  3534.  
  3535. func (msg *MsgHeaders) Command() string {
  3536.     return CmdHeaders
  3537. }
  3538.  
  3539. func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32 {
  3540.  
  3541.     return MaxVarIntPayload + ((MaxBlockHeaderPayload + 1) *
  3542.         MaxBlockHeadersPerMsg)
  3543. }
  3544.  
  3545. func NewMsgHeaders() *MsgHeaders {
  3546.     return &MsgHeaders{
  3547.         Headers: make([]*BlockHeader, 0, MaxBlockHeadersPerMsg),
  3548.     }
  3549. }
  3550.  
  3551. const defaultInvListAlloc = 1000
  3552.  
  3553. type MsgInv struct {
  3554.     InvList []*InvVect
  3555. }
  3556.  
  3557. func (msg *MsgInv) AddInvVect(iv *InvVect) error {
  3558.     if len(msg.InvList)+1 > MaxInvPerMsg {
  3559.         str := fmt.Sprintf("too many invvect in message [max %v]",
  3560.             MaxInvPerMsg)
  3561.         return messageError("MsgInv.AddInvVect", str)
  3562.     }
  3563.  
  3564.     msg.InvList = append(msg.InvList, iv)
  3565.     return nil
  3566. }
  3567.  
  3568. func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3569.     count, err := ReadVarInt(r, pver)
  3570.     if err != nil {
  3571.         return err
  3572.     }
  3573.  
  3574.     if count > MaxInvPerMsg {
  3575.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3576.         return messageError("MsgInv.BtcDecode", str)
  3577.     }
  3578.  
  3579.     invList := make([]InvVect, count)
  3580.     msg.InvList = make([]*InvVect, 0, count)
  3581.     for i := uint64(0); i < count; i++ {
  3582.         iv := &invList[i]
  3583.         err := readInvVect(r, pver, iv)
  3584.         if err != nil {
  3585.             return err
  3586.         }
  3587.         msg.AddInvVect(iv)
  3588.     }
  3589.  
  3590.     return nil
  3591. }
  3592.  
  3593. func (msg *MsgInv) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3594.  
  3595.     count := len(msg.InvList)
  3596.     if count > MaxInvPerMsg {
  3597.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3598.         return messageError("MsgInv.BtcEncode", str)
  3599.     }
  3600.  
  3601.     err := WriteVarInt(w, pver, uint64(count))
  3602.     if err != nil {
  3603.         return err
  3604.     }
  3605.  
  3606.     for _, iv := range msg.InvList {
  3607.         err := writeInvVect(w, pver, iv)
  3608.         if err != nil {
  3609.             return err
  3610.         }
  3611.     }
  3612.  
  3613.     return nil
  3614. }
  3615.  
  3616. func (msg *MsgInv) Command() string {
  3617.     return CmdInv
  3618. }
  3619.  
  3620. func (msg *MsgInv) MaxPayloadLength(pver uint32) uint32 {
  3621.  
  3622.     return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3623. }
  3624.  
  3625. func NewMsgInv() *MsgInv {
  3626.     return &MsgInv{
  3627.         InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3628.     }
  3629. }
  3630.  
  3631. func NewMsgInvSizeHint(sizeHint uint) *MsgInv {
  3632.  
  3633.     if sizeHint > MaxInvPerMsg {
  3634.         sizeHint = MaxInvPerMsg
  3635.     }
  3636.  
  3637.     return &MsgInv{
  3638.         InvList: make([]*InvVect, 0, sizeHint),
  3639.     }
  3640. }
  3641.  
  3642. type MsgMemPool struct{}
  3643.  
  3644. func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3645.     if pver < BIP0035Version {
  3646.         str := fmt.Sprintf("mempool message invalid for protocol "+
  3647.             "version %d", pver)
  3648.         return messageError("MsgMemPool.BtcDecode", str)
  3649.     }
  3650.  
  3651.     return nil
  3652. }
  3653.  
  3654. func (msg *MsgMemPool) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3655.     if pver < BIP0035Version {
  3656.         str := fmt.Sprintf("mempool message invalid for protocol "+
  3657.             "version %d", pver)
  3658.         return messageError("MsgMemPool.BtcEncode", str)
  3659.     }
  3660.  
  3661.     return nil
  3662. }
  3663.  
  3664. func (msg *MsgMemPool) Command() string {
  3665.     return CmdMemPool
  3666. }
  3667.  
  3668. func (msg *MsgMemPool) MaxPayloadLength(pver uint32) uint32 {
  3669.     return 0
  3670. }
  3671.  
  3672. func NewMsgMemPool() *MsgMemPool {
  3673.     return &MsgMemPool{}
  3674. }
  3675.  
  3676. const maxFlagsPerMerkleBlock = maxTxPerBlock / 8
  3677.  
  3678. type MsgMerkleBlock struct {
  3679.     Header       BlockHeader
  3680.     Transactions uint32
  3681.     Hashes       []*Hash
  3682.     Flags        []byte
  3683. }
  3684.  
  3685. func (msg *MsgMerkleBlock) AddTxHash(hash *Hash) error {
  3686.     if len(msg.Hashes)+1 > maxTxPerBlock {
  3687.         str := fmt.Sprintf("too many tx hashes for message [max %v]",
  3688.             maxTxPerBlock)
  3689.         return messageError("MsgMerkleBlock.AddTxHash", str)
  3690.     }
  3691.  
  3692.     msg.Hashes = append(msg.Hashes, hash)
  3693.     return nil
  3694. }
  3695.  
  3696. func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3697.     if pver < BIP0037Version {
  3698.         str := fmt.Sprintf("merkleblock message invalid for protocol "+
  3699.             "version %d", pver)
  3700.         return messageError("MsgMerkleBlock.BtcDecode", str)
  3701.     }
  3702.  
  3703.     err := readBlockHeader(r, pver, &msg.Header)
  3704.     if err != nil {
  3705.         return err
  3706.     }
  3707.  
  3708.     err = readElement(r, &msg.Transactions)
  3709.     if err != nil {
  3710.         return err
  3711.     }
  3712.  
  3713.     count, err := ReadVarInt(r, pver)
  3714.     if err != nil {
  3715.         return err
  3716.     }
  3717.     if count > maxTxPerBlock {
  3718.         str := fmt.Sprintf("too many transaction hashes for message "+
  3719.             "[count %v, max %v]", count, maxTxPerBlock)
  3720.         return messageError("MsgMerkleBlock.BtcDecode", str)
  3721.     }
  3722.  
  3723.     hashes := make([]Hash, count)
  3724.     msg.Hashes = make([]*Hash, 0, count)
  3725.     for i := uint64(0); i < count; i++ {
  3726.         hash := &hashes[i]
  3727.         err := readElement(r, hash)
  3728.         if err != nil {
  3729.             return err
  3730.         }
  3731.         msg.AddTxHash(hash)
  3732.     }
  3733.  
  3734.     msg.Flags, err = ReadVarBytes(r, pver, maxFlagsPerMerkleBlock,
  3735.         "merkle block flags size")
  3736.     return err
  3737. }
  3738.  
  3739. func (msg *MsgMerkleBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3740.     if pver < BIP0037Version {
  3741.         str := fmt.Sprintf("merkleblock message invalid for protocol "+
  3742.             "version %d", pver)
  3743.         return messageError("MsgMerkleBlock.BtcEncode", str)
  3744.     }
  3745.  
  3746.     numHashes := len(msg.Hashes)
  3747.     if numHashes > maxTxPerBlock {
  3748.         str := fmt.Sprintf("too many transaction hashes for message "+
  3749.             "[count %v, max %v]", numHashes, maxTxPerBlock)
  3750.         return messageError("MsgMerkleBlock.BtcDecode", str)
  3751.     }
  3752.     numFlagBytes := len(msg.Flags)
  3753.     if numFlagBytes > maxFlagsPerMerkleBlock {
  3754.         str := fmt.Sprintf("too many flag bytes for message [count %v, "+
  3755.             "max %v]", numFlagBytes, maxFlagsPerMerkleBlock)
  3756.         return messageError("MsgMerkleBlock.BtcDecode", str)
  3757.     }
  3758.  
  3759.     err := writeBlockHeader(w, pver, &msg.Header)
  3760.     if err != nil {
  3761.         return err
  3762.     }
  3763.  
  3764.     err = writeElement(w, msg.Transactions)
  3765.     if err != nil {
  3766.         return err
  3767.     }
  3768.  
  3769.     err = WriteVarInt(w, pver, uint64(numHashes))
  3770.     if err != nil {
  3771.         return err
  3772.     }
  3773.     for _, hash := range msg.Hashes {
  3774.         err = writeElement(w, hash)
  3775.         if err != nil {
  3776.             return err
  3777.         }
  3778.     }
  3779.  
  3780.     return WriteVarBytes(w, pver, msg.Flags)
  3781. }
  3782.  
  3783. func (msg *MsgMerkleBlock) Command() string {
  3784.     return CmdMerkleBlock
  3785. }
  3786.  
  3787. func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32 {
  3788.     return MaxBlockPayload
  3789. }
  3790.  
  3791. func NewMsgMerkleBlock(bh *BlockHeader) *MsgMerkleBlock {
  3792.     return &MsgMerkleBlock{
  3793.         Header:       *bh,
  3794.         Transactions: 0,
  3795.         Hashes:       make([]*Hash, 0),
  3796.         Flags:        make([]byte, 0),
  3797.     }
  3798. }
  3799.  
  3800. type MsgNotFound struct {
  3801.     InvList []*InvVect
  3802. }
  3803.  
  3804. func (msg *MsgNotFound) AddInvVect(iv *InvVect) error {
  3805.     if len(msg.InvList)+1 > MaxInvPerMsg {
  3806.         str := fmt.Sprintf("too many invvect in message [max %v]",
  3807.             MaxInvPerMsg)
  3808.         return messageError("MsgNotFound.AddInvVect", str)
  3809.     }
  3810.  
  3811.     msg.InvList = append(msg.InvList, iv)
  3812.     return nil
  3813. }
  3814.  
  3815. func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3816.     count, err := ReadVarInt(r, pver)
  3817.     if err != nil {
  3818.         return err
  3819.     }
  3820.  
  3821.     if count > MaxInvPerMsg {
  3822.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3823.         return messageError("MsgNotFound.BtcDecode", str)
  3824.     }
  3825.  
  3826.     invList := make([]InvVect, count)
  3827.     msg.InvList = make([]*InvVect, 0, count)
  3828.     for i := uint64(0); i < count; i++ {
  3829.         iv := &invList[i]
  3830.         err := readInvVect(r, pver, iv)
  3831.         if err != nil {
  3832.             return err
  3833.         }
  3834.         msg.AddInvVect(iv)
  3835.     }
  3836.  
  3837.     return nil
  3838. }
  3839.  
  3840. func (msg *MsgNotFound) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3841.  
  3842.     count := len(msg.InvList)
  3843.     if count > MaxInvPerMsg {
  3844.         str := fmt.Sprintf("too many invvect in message [%v]", count)
  3845.         return messageError("MsgNotFound.BtcEncode", str)
  3846.     }
  3847.  
  3848.     err := WriteVarInt(w, pver, uint64(count))
  3849.     if err != nil {
  3850.         return err
  3851.     }
  3852.  
  3853.     for _, iv := range msg.InvList {
  3854.         err := writeInvVect(w, pver, iv)
  3855.         if err != nil {
  3856.             return err
  3857.         }
  3858.     }
  3859.  
  3860.     return nil
  3861. }
  3862.  
  3863. func (msg *MsgNotFound) Command() string {
  3864.     return CmdNotFound
  3865. }
  3866.  
  3867. func (msg *MsgNotFound) MaxPayloadLength(pver uint32) uint32 {
  3868.  
  3869.     return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
  3870. }
  3871.  
  3872. func NewMsgNotFound() *MsgNotFound {
  3873.     return &MsgNotFound{
  3874.         InvList: make([]*InvVect, 0, defaultInvListAlloc),
  3875.     }
  3876. }
  3877.  
  3878. type MsgPing struct {
  3879.     Nonce uint64
  3880. }
  3881.  
  3882. func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3883.  
  3884.     if pver > BIP0031Version {
  3885.         err := readElement(r, &msg.Nonce)
  3886.         if err != nil {
  3887.             return err
  3888.         }
  3889.     }
  3890.  
  3891.     return nil
  3892. }
  3893.  
  3894. func (msg *MsgPing) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3895.  
  3896.     if pver > BIP0031Version {
  3897.         err := writeElement(w, msg.Nonce)
  3898.         if err != nil {
  3899.             return err
  3900.         }
  3901.     }
  3902.  
  3903.     return nil
  3904. }
  3905.  
  3906. func (msg *MsgPing) Command() string {
  3907.     return CmdPing
  3908. }
  3909.  
  3910. func (msg *MsgPing) MaxPayloadLength(pver uint32) uint32 {
  3911.     plen := uint32(0)
  3912.  
  3913.     if pver > BIP0031Version {
  3914.  
  3915.         plen += 8
  3916.     }
  3917.  
  3918.     return plen
  3919. }
  3920.  
  3921. func NewMsgPing(nonce uint64) *MsgPing {
  3922.     return &MsgPing{
  3923.         Nonce: nonce,
  3924.     }
  3925. }
  3926.  
  3927. type MsgPong struct {
  3928.     Nonce uint64
  3929. }
  3930.  
  3931. func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  3932.  
  3933.     if pver <= BIP0031Version {
  3934.         str := fmt.Sprintf("pong message invalid for protocol "+
  3935.             "version %d", pver)
  3936.         return messageError("MsgPong.BtcDecode", str)
  3937.     }
  3938.  
  3939.     return readElement(r, &msg.Nonce)
  3940. }
  3941.  
  3942. func (msg *MsgPong) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  3943.  
  3944.     if pver <= BIP0031Version {
  3945.         str := fmt.Sprintf("pong message invalid for protocol "+
  3946.             "version %d", pver)
  3947.         return messageError("MsgPong.BtcEncode", str)
  3948.     }
  3949.  
  3950.     return writeElement(w, msg.Nonce)
  3951. }
  3952.  
  3953. func (msg *MsgPong) Command() string {
  3954.     return CmdPong
  3955. }
  3956.  
  3957. func (msg *MsgPong) MaxPayloadLength(pver uint32) uint32 {
  3958.     plen := uint32(0)
  3959.  
  3960.     if pver > BIP0031Version {
  3961.  
  3962.         plen += 8
  3963.     }
  3964.  
  3965.     return plen
  3966. }
  3967.  
  3968. func NewMsgPong(nonce uint64) *MsgPong {
  3969.     return &MsgPong{
  3970.         Nonce: nonce,
  3971.     }
  3972. }
  3973.  
  3974. type RejectCode uint8
  3975.  
  3976. const (
  3977.     RejectMalformed       RejectCode = 0x01
  3978.     RejectInvalid         RejectCode = 0x10
  3979.     RejectObsolete        RejectCode = 0x11
  3980.     RejectDuplicate       RejectCode = 0x12
  3981.     RejectNonstandard     RejectCode = 0x40
  3982.     RejectDust            RejectCode = 0x41
  3983.     RejectInsufficientFee RejectCode = 0x42
  3984.     RejectCheckpoint      RejectCode = 0x43
  3985. )
  3986.  
  3987. var rejectCodeStrings = map[RejectCode]string{
  3988.     RejectMalformed:       "REJECT_MALFORMED",
  3989.     RejectInvalid:         "REJECT_INVALID",
  3990.     RejectObsolete:        "REJECT_OBSOLETE",
  3991.     RejectDuplicate:       "REJECT_DUPLICATE",
  3992.     RejectNonstandard:     "REJECT_NONSTANDARD",
  3993.     RejectDust:            "REJECT_DUST",
  3994.     RejectInsufficientFee: "REJECT_INSUFFICIENTFEE",
  3995.     RejectCheckpoint:      "REJECT_CHECKPOINT",
  3996. }
  3997.  
  3998. func (code RejectCode) String() string {
  3999.     if s, ok := rejectCodeStrings[code]; ok {
  4000.         return s
  4001.     }
  4002.  
  4003.     return fmt.Sprintf("Unknown RejectCode (%d)", uint8(code))
  4004. }
  4005.  
  4006. type MsgReject struct {
  4007.     Cmd string
  4008.  
  4009.     Code RejectCode
  4010.  
  4011.     Reason string
  4012.  
  4013.     Hash Hash
  4014. }
  4015.  
  4016. func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4017.     if pver < RejectVersion {
  4018.         str := fmt.Sprintf("reject message invalid for protocol "+
  4019.             "version %d", pver)
  4020.         return messageError("MsgReject.BtcDecode", str)
  4021.     }
  4022.  
  4023.     cmd, err := ReadVarString(r, pver)
  4024.     if err != nil {
  4025.         return err
  4026.     }
  4027.     msg.Cmd = cmd
  4028.  
  4029.     err = readElement(r, &msg.Code)
  4030.     if err != nil {
  4031.         return err
  4032.     }
  4033.  
  4034.     reason, err := ReadVarString(r, pver)
  4035.     if err != nil {
  4036.         return err
  4037.     }
  4038.     msg.Reason = reason
  4039.  
  4040.     if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
  4041.         err := readElement(r, &msg.Hash)
  4042.         if err != nil {
  4043.             return err
  4044.         }
  4045.     }
  4046.  
  4047.     return nil
  4048. }
  4049.  
  4050. func (msg *MsgReject) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4051.     if pver < RejectVersion {
  4052.         str := fmt.Sprintf("reject message invalid for protocol "+
  4053.             "version %d", pver)
  4054.         return messageError("MsgReject.BtcEncode", str)
  4055.     }
  4056.  
  4057.     err := WriteVarString(w, pver, msg.Cmd)
  4058.     if err != nil {
  4059.         return err
  4060.     }
  4061.  
  4062.     err = writeElement(w, msg.Code)
  4063.     if err != nil {
  4064.         return err
  4065.     }
  4066.  
  4067.     err = WriteVarString(w, pver, msg.Reason)
  4068.     if err != nil {
  4069.         return err
  4070.     }
  4071.  
  4072.     if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
  4073.         err := writeElement(w, &msg.Hash)
  4074.         if err != nil {
  4075.             return err
  4076.         }
  4077.     }
  4078.  
  4079.     return nil
  4080. }
  4081.  
  4082. func (msg *MsgReject) Command() string {
  4083.     return CmdReject
  4084. }
  4085.  
  4086. func (msg *MsgReject) MaxPayloadLength(pver uint32) uint32 {
  4087.     plen := uint32(0)
  4088.  
  4089.     if pver >= RejectVersion {
  4090.  
  4091.         plen = MaxMessagePayload
  4092.     }
  4093.  
  4094.     return plen
  4095. }
  4096.  
  4097. func NewMsgReject(command string, code RejectCode, reason string) *MsgReject {
  4098.     return &MsgReject{
  4099.         Cmd:    command,
  4100.         Code:   code,
  4101.         Reason: reason,
  4102.     }
  4103. }
  4104.  
  4105. type MsgSendHeaders struct{}
  4106.  
  4107. func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4108.     if pver < SendHeadersVersion {
  4109.         str := fmt.Sprintf("sendheaders message invalid for protocol "+
  4110.             "version %d", pver)
  4111.         return messageError("MsgSendHeaders.BtcDecode", str)
  4112.     }
  4113.  
  4114.     return nil
  4115. }
  4116.  
  4117. func (msg *MsgSendHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4118.     if pver < SendHeadersVersion {
  4119.         str := fmt.Sprintf("sendheaders message invalid for protocol "+
  4120.             "version %d", pver)
  4121.         return messageError("MsgSendHeaders.BtcEncode", str)
  4122.     }
  4123.  
  4124.     return nil
  4125. }
  4126.  
  4127. func (msg *MsgSendHeaders) Command() string {
  4128.     return CmdSendHeaders
  4129. }
  4130.  
  4131. func (msg *MsgSendHeaders) MaxPayloadLength(pver uint32) uint32 {
  4132.     return 0
  4133. }
  4134.  
  4135. func NewMsgSendHeaders() *MsgSendHeaders {
  4136.     return &MsgSendHeaders{}
  4137. }
  4138.  
  4139. const (
  4140.     TxVersion = 1
  4141.  
  4142.     MaxTxInSequenceNum uint32 = 0xffffffff
  4143.  
  4144.     MaxPrevOutIndex uint32 = 0xffffffff
  4145.  
  4146.     SequenceLockTimeDisabled = 1 << 31
  4147.  
  4148.     SequenceLockTimeIsSeconds = 1 << 22
  4149.  
  4150.     SequenceLockTimeMask = 0x0000ffff
  4151.  
  4152.     SequenceLockTimeGranularity = 9
  4153.  
  4154.     defaultTxInOutAlloc = 15
  4155.  
  4156.     minTxInPayload = 9 + HashSize
  4157.  
  4158.     maxTxInPerMessage = (MaxMessagePayload / minTxInPayload) + 1
  4159.  
  4160.     MinTxOutPayload = 9
  4161.  
  4162.     maxTxOutPerMessage = (MaxMessagePayload / MinTxOutPayload) + 1
  4163.  
  4164.     minTxPayload = 10
  4165.  
  4166.     freeListMaxScriptSize = 512
  4167.  
  4168.     freeListMaxItems = 12500
  4169.  
  4170.     maxWitnessItemsPerInput = 500000
  4171.  
  4172.     maxWitnessItemSize = 11000
  4173. )
  4174.  
  4175. const TxFlagMarker = 0x00
  4176.  
  4177. type TxFlag = byte
  4178.  
  4179. const (
  4180.     WitnessFlag TxFlag = 0x01
  4181. )
  4182.  
  4183. type scriptFreeList chan []byte
  4184.  
  4185. func (c scriptFreeList) Borrow(size uint64) []byte {
  4186.     if size > freeListMaxScriptSize {
  4187.         return make([]byte, size)
  4188.     }
  4189.  
  4190.     var buf []byte
  4191.     select {
  4192.     case buf = <-c:
  4193.     default:
  4194.         buf = make([]byte, freeListMaxScriptSize)
  4195.     }
  4196.     return buf[:size]
  4197. }
  4198.  
  4199. func (c scriptFreeList) Return(buf []byte) {
  4200.  
  4201.     if cap(buf) != freeListMaxScriptSize {
  4202.         return
  4203.     }
  4204.  
  4205.     select {
  4206.     case c <- buf:
  4207.     default:
  4208.  
  4209.     }
  4210. }
  4211.  
  4212. var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)
  4213.  
  4214. type OutPoint struct {
  4215.     Hash  Hash
  4216.     Index uint32
  4217. }
  4218.  
  4219. func NewOutPoint(hash *Hash, index uint32) *OutPoint {
  4220.     return &OutPoint{
  4221.         Hash:  *hash,
  4222.         Index: index,
  4223.     }
  4224. }
  4225.  
  4226. func (o OutPoint) String() string {
  4227.  
  4228.     buf := make([]byte, 2*HashSize+1, 2*HashSize+1+10)
  4229.     copy(buf, o.Hash.String())
  4230.     buf[2*HashSize] = ':'
  4231.     buf = strconv.AppendUint(buf, uint64(o.Index), 10)
  4232.     return string(buf)
  4233. }
  4234.  
  4235. type TxIn struct {
  4236.     PreviousOutPoint OutPoint
  4237.     SignatureScript  []byte
  4238.     Witness          TxWitness
  4239.     Sequence         uint32
  4240. }
  4241.  
  4242. func (t *TxIn) SerializeSize() int {
  4243.  
  4244.     return 40 + VarIntSerializeSize(uint64(len(t.SignatureScript))) +
  4245.         len(t.SignatureScript)
  4246. }
  4247.  
  4248. func NewTxIn(prevOut *OutPoint, signatureScript []byte, witness [][]byte) *TxIn {
  4249.     return &TxIn{
  4250.         PreviousOutPoint: *prevOut,
  4251.         SignatureScript:  signatureScript,
  4252.         Witness:          witness,
  4253.         Sequence:         MaxTxInSequenceNum,
  4254.     }
  4255. }
  4256.  
  4257. type TxWitness [][]byte
  4258.  
  4259. func (t TxWitness) SerializeSize() int {
  4260.  
  4261.     n := VarIntSerializeSize(uint64(len(t)))
  4262.  
  4263.     for _, witItem := range t {
  4264.         n += VarIntSerializeSize(uint64(len(witItem)))
  4265.         n += len(witItem)
  4266.     }
  4267.  
  4268.     return n
  4269. }
  4270.  
  4271. type TxOut struct {
  4272.     Value    int64
  4273.     PkScript []byte
  4274. }
  4275.  
  4276. func (t *TxOut) SerializeSize() int {
  4277.  
  4278.     return 8 + VarIntSerializeSize(uint64(len(t.PkScript))) + len(t.PkScript)
  4279. }
  4280.  
  4281. func NewTxOut(value int64, pkScript []byte) *TxOut {
  4282.     return &TxOut{
  4283.         Value:    value,
  4284.         PkScript: pkScript,
  4285.     }
  4286. }
  4287.  
  4288. type MsgTx struct {
  4289.     Version  int32
  4290.     TxIn     []*TxIn
  4291.     TxOut    []*TxOut
  4292.     LockTime uint32
  4293. }
  4294.  
  4295. func (msg *MsgTx) AddTxIn(ti *TxIn) {
  4296.     msg.TxIn = append(msg.TxIn, ti)
  4297. }
  4298.  
  4299. func (msg *MsgTx) AddTxOut(to *TxOut) {
  4300.     msg.TxOut = append(msg.TxOut, to)
  4301. }
  4302.  
  4303. func (msg *MsgTx) TxHash() Hash {
  4304.  
  4305.     buf := bytes.NewBuffer(make([]byte, 0, msg.SerializeSizeStripped()))
  4306.     _ = msg.SerializeNoWitness(buf)
  4307.     return DoubleHashH(buf.Bytes())
  4308. }
  4309.  
  4310. func (msg *MsgTx) WitnessHash() Hash {
  4311.     if msg.HasWitness() {
  4312.         buf := bytes.NewBuffer(make([]byte, 0, msg.SerializeSize()))
  4313.         _ = msg.Serialize(buf)
  4314.         return DoubleHashH(buf.Bytes())
  4315.     }
  4316.  
  4317.     return msg.TxHash()
  4318. }
  4319.  
  4320. func (msg *MsgTx) Copy() *MsgTx {
  4321.  
  4322.     newTx := MsgTx{
  4323.         Version:  msg.Version,
  4324.         TxIn:     make([]*TxIn, 0, len(msg.TxIn)),
  4325.         TxOut:    make([]*TxOut, 0, len(msg.TxOut)),
  4326.         LockTime: msg.LockTime,
  4327.     }
  4328.  
  4329.     for _, oldTxIn := range msg.TxIn {
  4330.  
  4331.         oldOutPoint := oldTxIn.PreviousOutPoint
  4332.         newOutPoint := OutPoint{}
  4333.         newOutPoint.Hash.SetBytes(oldOutPoint.Hash[:])
  4334.         newOutPoint.Index = oldOutPoint.Index
  4335.  
  4336.         var newScript []byte
  4337.         oldScript := oldTxIn.SignatureScript
  4338.         oldScriptLen := len(oldScript)
  4339.         if oldScriptLen > 0 {
  4340.             newScript = make([]byte, oldScriptLen)
  4341.             copy(newScript, oldScript[:oldScriptLen])
  4342.         }
  4343.  
  4344.         newTxIn := TxIn{
  4345.             PreviousOutPoint: newOutPoint,
  4346.             SignatureScript:  newScript,
  4347.             Sequence:         oldTxIn.Sequence,
  4348.         }
  4349.  
  4350.         if len(oldTxIn.Witness) != 0 {
  4351.  
  4352.             newTxIn.Witness = make([][]byte, len(oldTxIn.Witness))
  4353.             for i, oldItem := range oldTxIn.Witness {
  4354.                 newItem := make([]byte, len(oldItem))
  4355.                 copy(newItem, oldItem)
  4356.                 newTxIn.Witness[i] = newItem
  4357.             }
  4358.         }
  4359.  
  4360.         newTx.TxIn = append(newTx.TxIn, &newTxIn)
  4361.     }
  4362.  
  4363.     for _, oldTxOut := range msg.TxOut {
  4364.  
  4365.         var newScript []byte
  4366.         oldScript := oldTxOut.PkScript
  4367.         oldScriptLen := len(oldScript)
  4368.         if oldScriptLen > 0 {
  4369.             newScript = make([]byte, oldScriptLen)
  4370.             copy(newScript, oldScript[:oldScriptLen])
  4371.         }
  4372.  
  4373.         newTxOut := TxOut{
  4374.             Value:    oldTxOut.Value,
  4375.             PkScript: newScript,
  4376.         }
  4377.         newTx.TxOut = append(newTx.TxOut, &newTxOut)
  4378.     }
  4379.  
  4380.     return &newTx
  4381. }
  4382.  
  4383. func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4384.     version, err := binarySerializer.Uint32(r, littleEndian)
  4385.     if err != nil {
  4386.         return err
  4387.     }
  4388.     msg.Version = int32(version)
  4389.  
  4390.     count, err := ReadVarInt(r, pver)
  4391.     if err != nil {
  4392.         return err
  4393.     }
  4394.  
  4395.     var flag [1]TxFlag
  4396.     if count == TxFlagMarker && enc == WitnessEncoding {
  4397.  
  4398.         if _, err = io.ReadFull(r, flag[:]); err != nil {
  4399.             return err
  4400.         }
  4401.  
  4402.         if flag[0] != WitnessFlag {
  4403.             str := fmt.Sprintf("witness tx but flag byte is %x", flag)
  4404.             return messageError("MsgTx.BtcDecode", str)
  4405.         }
  4406.  
  4407.         count, err = ReadVarInt(r, pver)
  4408.         if err != nil {
  4409.             return err
  4410.         }
  4411.     }
  4412.  
  4413.     if count > uint64(maxTxInPerMessage) {
  4414.         str := fmt.Sprintf("too many input transactions to fit into "+
  4415.             "max message size [count %d, max %d]", count,
  4416.             maxTxInPerMessage)
  4417.         return messageError("MsgTx.BtcDecode", str)
  4418.     }
  4419.  
  4420.     returnScriptBuffers := func() {
  4421.         for _, txIn := range msg.TxIn {
  4422.             if txIn == nil {
  4423.                 continue
  4424.             }
  4425.  
  4426.             if txIn.SignatureScript != nil {
  4427.                 scriptPool.Return(txIn.SignatureScript)
  4428.             }
  4429.  
  4430.             for _, witnessElem := range txIn.Witness {
  4431.                 if witnessElem != nil {
  4432.                     scriptPool.Return(witnessElem)
  4433.                 }
  4434.             }
  4435.         }
  4436.         for _, txOut := range msg.TxOut {
  4437.             if txOut == nil || txOut.PkScript == nil {
  4438.                 continue
  4439.             }
  4440.             scriptPool.Return(txOut.PkScript)
  4441.         }
  4442.     }
  4443.  
  4444.     var totalScriptSize uint64
  4445.     txIns := make([]TxIn, count)
  4446.     msg.TxIn = make([]*TxIn, count)
  4447.     for i := uint64(0); i < count; i++ {
  4448.  
  4449.         ti := &txIns[i]
  4450.         msg.TxIn[i] = ti
  4451.         err = readTxIn(r, pver, msg.Version, ti)
  4452.         if err != nil {
  4453.             returnScriptBuffers()
  4454.             return err
  4455.         }
  4456.         totalScriptSize += uint64(len(ti.SignatureScript))
  4457.     }
  4458.  
  4459.     count, err = ReadVarInt(r, pver)
  4460.     if err != nil {
  4461.         returnScriptBuffers()
  4462.         return err
  4463.     }
  4464.  
  4465.     if count > uint64(maxTxOutPerMessage) {
  4466.         returnScriptBuffers()
  4467.         str := fmt.Sprintf("too many output transactions to fit into "+
  4468.             "max message size [count %d, max %d]", count,
  4469.             maxTxOutPerMessage)
  4470.         return messageError("MsgTx.BtcDecode", str)
  4471.     }
  4472.  
  4473.     txOuts := make([]TxOut, count)
  4474.     msg.TxOut = make([]*TxOut, count)
  4475.     for i := uint64(0); i < count; i++ {
  4476.  
  4477.         to := &txOuts[i]
  4478.         msg.TxOut[i] = to
  4479.         err = readTxOut(r, pver, msg.Version, to)
  4480.         if err != nil {
  4481.             returnScriptBuffers()
  4482.             return err
  4483.         }
  4484.         totalScriptSize += uint64(len(to.PkScript))
  4485.     }
  4486.  
  4487.     if flag[0] != 0 && enc == WitnessEncoding {
  4488.         for _, txin := range msg.TxIn {
  4489.  
  4490.             witCount, err := ReadVarInt(r, pver)
  4491.             if err != nil {
  4492.                 returnScriptBuffers()
  4493.                 return err
  4494.             }
  4495.  
  4496.             if witCount > maxWitnessItemsPerInput {
  4497.                 returnScriptBuffers()
  4498.                 str := fmt.Sprintf("too many witness items to fit "+
  4499.                     "into max message size [count %d, max %d]",
  4500.                     witCount, maxWitnessItemsPerInput)
  4501.                 return messageError("MsgTx.BtcDecode", str)
  4502.             }
  4503.  
  4504.             txin.Witness = make([][]byte, witCount)
  4505.             for j := uint64(0); j < witCount; j++ {
  4506.                 txin.Witness[j], err = readScript(r, pver,
  4507.                     maxWitnessItemSize, "script witness item")
  4508.                 if err != nil {
  4509.                     returnScriptBuffers()
  4510.                     return err
  4511.                 }
  4512.                 totalScriptSize += uint64(len(txin.Witness[j]))
  4513.             }
  4514.         }
  4515.     }
  4516.  
  4517.     msg.LockTime, err = binarySerializer.Uint32(r, littleEndian)
  4518.     if err != nil {
  4519.         returnScriptBuffers()
  4520.         return err
  4521.     }
  4522.  
  4523.     var offset uint64
  4524.     scripts := make([]byte, totalScriptSize)
  4525.     for i := 0; i < len(msg.TxIn); i++ {
  4526.  
  4527.         signatureScript := msg.TxIn[i].SignatureScript
  4528.         copy(scripts[offset:], signatureScript)
  4529.  
  4530.         scriptSize := uint64(len(signatureScript))
  4531.         end := offset + scriptSize
  4532.         msg.TxIn[i].SignatureScript = scripts[offset:end:end]
  4533.         offset += scriptSize
  4534.  
  4535.         scriptPool.Return(signatureScript)
  4536.  
  4537.         for j := 0; j < len(msg.TxIn[i].Witness); j++ {
  4538.  
  4539.             witnessElem := msg.TxIn[i].Witness[j]
  4540.             copy(scripts[offset:], witnessElem)
  4541.  
  4542.             witnessElemSize := uint64(len(witnessElem))
  4543.             end := offset + witnessElemSize
  4544.             msg.TxIn[i].Witness[j] = scripts[offset:end:end]
  4545.             offset += witnessElemSize
  4546.  
  4547.             scriptPool.Return(witnessElem)
  4548.         }
  4549.     }
  4550.     for i := 0; i < len(msg.TxOut); i++ {
  4551.  
  4552.         pkScript := msg.TxOut[i].PkScript
  4553.         copy(scripts[offset:], pkScript)
  4554.  
  4555.         scriptSize := uint64(len(pkScript))
  4556.         end := offset + scriptSize
  4557.         msg.TxOut[i].PkScript = scripts[offset:end:end]
  4558.         offset += scriptSize
  4559.  
  4560.         scriptPool.Return(pkScript)
  4561.     }
  4562.  
  4563.     return nil
  4564. }
  4565.  
  4566. func (msg *MsgTx) Deserialize(r io.Reader) error {
  4567.  
  4568.     return msg.BtcDecode(r, 0, WitnessEncoding)
  4569. }
  4570.  
  4571. func (msg *MsgTx) DeserializeNoWitness(r io.Reader) error {
  4572.     return msg.BtcDecode(r, 0, BaseEncoding)
  4573. }
  4574.  
  4575. func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4576.     err := binarySerializer.PutUint32(w, littleEndian, uint32(msg.Version))
  4577.     if err != nil {
  4578.         return err
  4579.     }
  4580.  
  4581.     doWitness := enc == WitnessEncoding && msg.HasWitness()
  4582.     if doWitness {
  4583.  
  4584.         if _, err := w.Write([]byte{TxFlagMarker, WitnessFlag}); err != nil {
  4585.             return err
  4586.         }
  4587.     }
  4588.  
  4589.     count := uint64(len(msg.TxIn))
  4590.     err = WriteVarInt(w, pver, count)
  4591.     if err != nil {
  4592.         return err
  4593.     }
  4594.  
  4595.     for _, ti := range msg.TxIn {
  4596.         err = writeTxIn(w, pver, msg.Version, ti)
  4597.         if err != nil {
  4598.             return err
  4599.         }
  4600.     }
  4601.  
  4602.     count = uint64(len(msg.TxOut))
  4603.     err = WriteVarInt(w, pver, count)
  4604.     if err != nil {
  4605.         return err
  4606.     }
  4607.  
  4608.     for _, to := range msg.TxOut {
  4609.         err = WriteTxOut(w, pver, msg.Version, to)
  4610.         if err != nil {
  4611.             return err
  4612.         }
  4613.     }
  4614.  
  4615.     if doWitness {
  4616.         for _, ti := range msg.TxIn {
  4617.             err = writeTxWitness(w, pver, msg.Version, ti.Witness)
  4618.             if err != nil {
  4619.                 return err
  4620.             }
  4621.         }
  4622.     }
  4623.  
  4624.     return binarySerializer.PutUint32(w, littleEndian, msg.LockTime)
  4625. }
  4626.  
  4627. func (msg *MsgTx) HasWitness() bool {
  4628.     for _, txIn := range msg.TxIn {
  4629.         if len(txIn.Witness) != 0 {
  4630.             return true
  4631.         }
  4632.     }
  4633.  
  4634.     return false
  4635. }
  4636.  
  4637. func (msg *MsgTx) Serialize(w io.Writer) error {
  4638.  
  4639.     return msg.BtcEncode(w, 0, WitnessEncoding)
  4640. }
  4641.  
  4642. func (msg *MsgTx) SerializeNoWitness(w io.Writer) error {
  4643.     return msg.BtcEncode(w, 0, BaseEncoding)
  4644. }
  4645.  
  4646. func (msg *MsgTx) baseSize() int {
  4647.  
  4648.     n := 8 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
  4649.         VarIntSerializeSize(uint64(len(msg.TxOut)))
  4650.  
  4651.     for _, txIn := range msg.TxIn {
  4652.         n += txIn.SerializeSize()
  4653.     }
  4654.  
  4655.     for _, txOut := range msg.TxOut {
  4656.         n += txOut.SerializeSize()
  4657.     }
  4658.  
  4659.     return n
  4660. }
  4661.  
  4662. func (msg *MsgTx) SerializeSize() int {
  4663.     n := msg.baseSize()
  4664.  
  4665.     if msg.HasWitness() {
  4666.  
  4667.         n += 2
  4668.  
  4669.         for _, txin := range msg.TxIn {
  4670.             n += txin.Witness.SerializeSize()
  4671.         }
  4672.     }
  4673.  
  4674.     return n
  4675. }
  4676.  
  4677. func (msg *MsgTx) SerializeSizeStripped() int {
  4678.     return msg.baseSize()
  4679. }
  4680.  
  4681. func (msg *MsgTx) Command() string {
  4682.     return CmdTx
  4683. }
  4684.  
  4685. func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
  4686.     return MaxBlockPayload
  4687. }
  4688.  
  4689. func (msg *MsgTx) PkScriptLocs() []int {
  4690.     numTxOut := len(msg.TxOut)
  4691.     if numTxOut == 0 {
  4692.         return nil
  4693.     }
  4694.  
  4695.     n := 4 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
  4696.         VarIntSerializeSize(uint64(numTxOut))
  4697.  
  4698.     if len(msg.TxIn) > 0 && msg.TxIn[0].Witness != nil {
  4699.         n += 2
  4700.     }
  4701.  
  4702.     for _, txIn := range msg.TxIn {
  4703.         n += txIn.SerializeSize()
  4704.     }
  4705.  
  4706.     pkScriptLocs := make([]int, numTxOut)
  4707.     for i, txOut := range msg.TxOut {
  4708.  
  4709.         n += 8 + VarIntSerializeSize(uint64(len(txOut.PkScript)))
  4710.         pkScriptLocs[i] = n
  4711.         n += len(txOut.PkScript)
  4712.     }
  4713.  
  4714.     return pkScriptLocs
  4715. }
  4716.  
  4717. func NewMsgTx(version int32) *MsgTx {
  4718.     return &MsgTx{
  4719.         Version: version,
  4720.         TxIn:    make([]*TxIn, 0, defaultTxInOutAlloc),
  4721.         TxOut:   make([]*TxOut, 0, defaultTxInOutAlloc),
  4722.     }
  4723. }
  4724.  
  4725. func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
  4726.     _, err := io.ReadFull(r, op.Hash[:])
  4727.     if err != nil {
  4728.         return err
  4729.     }
  4730.  
  4731.     op.Index, err = binarySerializer.Uint32(r, littleEndian)
  4732.     return err
  4733. }
  4734.  
  4735. func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
  4736.     _, err := w.Write(op.Hash[:])
  4737.     if err != nil {
  4738.         return err
  4739.     }
  4740.  
  4741.     return binarySerializer.PutUint32(w, littleEndian, op.Index)
  4742. }
  4743.  
  4744. func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) ([]byte, error) {
  4745.     count, err := ReadVarInt(r, pver)
  4746.     if err != nil {
  4747.         return nil, err
  4748.     }
  4749.  
  4750.     if count > uint64(maxAllowed) {
  4751.         str := fmt.Sprintf("%s is larger than the max allowed size "+
  4752.             "[count %d, max %d]", fieldName, count, maxAllowed)
  4753.         return nil, messageError("readScript", str)
  4754.     }
  4755.  
  4756.     b := scriptPool.Borrow(count)
  4757.     _, err = io.ReadFull(r, b)
  4758.     if err != nil {
  4759.         scriptPool.Return(b)
  4760.         return nil, err
  4761.     }
  4762.     return b, nil
  4763. }
  4764.  
  4765. func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
  4766.     err := readOutPoint(r, pver, version, &ti.PreviousOutPoint)
  4767.     if err != nil {
  4768.         return err
  4769.     }
  4770.  
  4771.     ti.SignatureScript, err = readScript(r, pver, MaxMessagePayload,
  4772.         "transaction input signature script")
  4773.     if err != nil {
  4774.         return err
  4775.     }
  4776.  
  4777.     return readElement(r, &ti.Sequence)
  4778. }
  4779.  
  4780. func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn) error {
  4781.     err := writeOutPoint(w, pver, version, &ti.PreviousOutPoint)
  4782.     if err != nil {
  4783.         return err
  4784.     }
  4785.  
  4786.     err = WriteVarBytes(w, pver, ti.SignatureScript)
  4787.     if err != nil {
  4788.         return err
  4789.     }
  4790.  
  4791.     return binarySerializer.PutUint32(w, littleEndian, ti.Sequence)
  4792. }
  4793.  
  4794. func readTxOut(r io.Reader, pver uint32, version int32, to *TxOut) error {
  4795.     err := readElement(r, &to.Value)
  4796.     if err != nil {
  4797.         return err
  4798.     }
  4799.  
  4800.     to.PkScript, err = readScript(r, pver, MaxMessagePayload,
  4801.         "transaction output public key script")
  4802.     return err
  4803. }
  4804.  
  4805. func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error {
  4806.     err := binarySerializer.PutUint64(w, littleEndian, uint64(to.Value))
  4807.     if err != nil {
  4808.         return err
  4809.     }
  4810.  
  4811.     return WriteVarBytes(w, pver, to.PkScript)
  4812. }
  4813.  
  4814. func writeTxWitness(w io.Writer, pver uint32, version int32, wit [][]byte) error {
  4815.     err := WriteVarInt(w, pver, uint64(len(wit)))
  4816.     if err != nil {
  4817.         return err
  4818.     }
  4819.     for _, item := range wit {
  4820.         err = WriteVarBytes(w, pver, item)
  4821.         if err != nil {
  4822.             return err
  4823.         }
  4824.     }
  4825.     return nil
  4826. }
  4827.  
  4828. type MsgVerAck struct{}
  4829.  
  4830. func (msg *MsgVerAck) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4831.     return nil
  4832. }
  4833.  
  4834. func (msg *MsgVerAck) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4835.     return nil
  4836. }
  4837.  
  4838. func (msg *MsgVerAck) Command() string {
  4839.     return CmdVerAck
  4840. }
  4841.  
  4842. func (msg *MsgVerAck) MaxPayloadLength(pver uint32) uint32 {
  4843.     return 0
  4844. }
  4845.  
  4846. func NewMsgVerAck() *MsgVerAck {
  4847.     return &MsgVerAck{}
  4848. }
  4849.  
  4850. const MaxUserAgentLen = 256
  4851.  
  4852. const DefaultUserAgent = "/btc0.5.0/"
  4853.  
  4854. type MsgVersion struct {
  4855.     ProtocolVersion int32
  4856.  
  4857.     Services ServiceFlag
  4858.  
  4859.     Timestamp time.Time
  4860.  
  4861.     AddrYou NetAddress
  4862.  
  4863.     AddrMe NetAddress
  4864.  
  4865.     Nonce uint64
  4866.  
  4867.     UserAgent string
  4868.  
  4869.     LastBlock int32
  4870.  
  4871.     DisableRelayTx bool
  4872. }
  4873.  
  4874. func (msg *MsgVersion) HasService(service ServiceFlag) bool {
  4875.     return msg.Services&service == service
  4876. }
  4877.  
  4878. func (msg *MsgVersion) AddService(service ServiceFlag) {
  4879.     msg.Services |= service
  4880. }
  4881.  
  4882. func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
  4883.     buf, ok := r.(*bytes.Buffer)
  4884.     if !ok {
  4885.         return fmt.Errorf("MsgVersion.BtcDecode reader is not a " +
  4886.             "*bytes.Buffer")
  4887.     }
  4888.  
  4889.     err := readElements(buf, &msg.ProtocolVersion, &msg.Services,
  4890.         (*int64Time)(&msg.Timestamp))
  4891.     if err != nil {
  4892.         return err
  4893.     }
  4894.  
  4895.     err = readNetAddress(buf, pver, &msg.AddrYou, false)
  4896.     if err != nil {
  4897.         return err
  4898.     }
  4899.  
  4900.     if buf.Len() > 0 {
  4901.         err = readNetAddress(buf, pver, &msg.AddrMe, false)
  4902.         if err != nil {
  4903.             return err
  4904.         }
  4905.     }
  4906.     if buf.Len() > 0 {
  4907.         err = readElement(buf, &msg.Nonce)
  4908.         if err != nil {
  4909.             return err
  4910.         }
  4911.     }
  4912.     if buf.Len() > 0 {
  4913.         userAgent, err := ReadVarString(buf, pver)
  4914.         if err != nil {
  4915.             return err
  4916.         }
  4917.         err = validateUserAgent(userAgent)
  4918.         if err != nil {
  4919.             return err
  4920.         }
  4921.         msg.UserAgent = userAgent
  4922.     }
  4923.  
  4924.     if buf.Len() > 0 {
  4925.         err = readElement(buf, &msg.LastBlock)
  4926.         if err != nil {
  4927.             return err
  4928.         }
  4929.     }
  4930.  
  4931.     if buf.Len() > 0 {
  4932.  
  4933.         var relayTx bool
  4934.         readElement(r, &relayTx)
  4935.         msg.DisableRelayTx = !relayTx
  4936.     }
  4937.  
  4938.     return nil
  4939. }
  4940.  
  4941. func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
  4942.     err := validateUserAgent(msg.UserAgent)
  4943.     if err != nil {
  4944.         return err
  4945.     }
  4946.  
  4947.     err = writeElements(w, msg.ProtocolVersion, msg.Services,
  4948.         msg.Timestamp.Unix())
  4949.     if err != nil {
  4950.         return err
  4951.     }
  4952.  
  4953.     err = writeNetAddress(w, pver, &msg.AddrYou, false)
  4954.     if err != nil {
  4955.         return err
  4956.     }
  4957.  
  4958.     err = writeNetAddress(w, pver, &msg.AddrMe, false)
  4959.     if err != nil {
  4960.         return err
  4961.     }
  4962.  
  4963.     err = writeElement(w, msg.Nonce)
  4964.     if err != nil {
  4965.         return err
  4966.     }
  4967.  
  4968.     err = WriteVarString(w, pver, msg.UserAgent)
  4969.     if err != nil {
  4970.         return err
  4971.     }
  4972.  
  4973.     err = writeElement(w, msg.LastBlock)
  4974.     if err != nil {
  4975.         return err
  4976.     }
  4977.  
  4978.     if pver >= BIP0037Version {
  4979.         err = writeElement(w, !msg.DisableRelayTx)
  4980.         if err != nil {
  4981.             return err
  4982.         }
  4983.     }
  4984.     return nil
  4985. }
  4986.  
  4987. func (msg *MsgVersion) Command() string {
  4988.     return CmdVersion
  4989. }
  4990.  
  4991. func (msg *MsgVersion) MaxPayloadLength(pver uint32) uint32 {
  4992.  
  4993.     return 33 + (maxNetAddressPayload(pver) * 2) + MaxVarIntPayload +
  4994.         MaxUserAgentLen
  4995. }
  4996.  
  4997. func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
  4998.     lastBlock int32) *MsgVersion {
  4999.  
  5000.     return &MsgVersion{
  5001.         ProtocolVersion: int32(ProtocolVersion),
  5002.         Services:        0,
  5003.         Timestamp:       time.Unix(time.Now().Unix(), 0),
  5004.         AddrYou:         *you,
  5005.         AddrMe:          *me,
  5006.         Nonce:           nonce,
  5007.         UserAgent:       DefaultUserAgent,
  5008.         LastBlock:       lastBlock,
  5009.         DisableRelayTx:  false,
  5010.     }
  5011. }
  5012.  
  5013. func validateUserAgent(userAgent string) error {
  5014.     if len(userAgent) > MaxUserAgentLen {
  5015.         str := fmt.Sprintf("user agent too long [len %v, max %v]",
  5016.             len(userAgent), MaxUserAgentLen)
  5017.         return messageError("MsgVersion", str)
  5018.     }
  5019.     return nil
  5020. }
  5021.  
  5022. func (msg *MsgVersion) AddUserAgent(name string, version string,
  5023.     comments ...string) error {
  5024.  
  5025.     newUserAgent := fmt.Sprintf("%s:%s", name, version)
  5026.     if len(comments) != 0 {
  5027.         newUserAgent = fmt.Sprintf("%s(%s)", newUserAgent,
  5028.             strings.Join(comments, "; "))
  5029.     }
  5030.     newUserAgent = fmt.Sprintf("%s%s/", msg.UserAgent, newUserAgent)
  5031.     err := validateUserAgent(newUserAgent)
  5032.     if err != nil {
  5033.         return err
  5034.     }
  5035.     msg.UserAgent = newUserAgent
  5036.     return nil
  5037. }
  5038.  
  5039. var myMutex sync.RWMutex
  5040. var myChain map[uint64]*Hash
  5041. var myHeaders map[Hash]*BlockHeader
  5042. var myTotal uint64
  5043.  
  5044. func init() {
  5045.     myChain = make(map[uint64]*Hash)
  5046.     myHeaders = make(map[Hash]*BlockHeader)
  5047. }
  5048.  
  5049. func myPut(bh *Hash, height uint64) {
  5050.     myMutex.Lock()
  5051.     if height == myTotal {
  5052.         myChain[height] = bh
  5053.     }
  5054.     myMutex.Unlock()
  5055. }
  5056.  
  5057. func myGet(height uint64) (bh *Hash) {
  5058.     myMutex.RLock()
  5059.     bh = myChain[height]
  5060.     myMutex.RUnlock()
  5061.     return bh
  5062. }
  5063.  
  5064. func myHas(bh *Hash) (has bool) {
  5065.     myMutex.RLock()
  5066.     has = myHeaders[*bh] != nil
  5067.     myMutex.RUnlock()
  5068.     return has
  5069. }
  5070.  
  5071. func myGoodReorg(h uint64, depth uint64, bh *BlockHeader) bool {
  5072.     return h >= depth && bh != nil
  5073. }
  5074.  
  5075. func myAttach(bh *BlockHeader, reorg func(a, b *Hash)) {
  5076.     hash := bh.BlockHash()
  5077.     myMutex.Lock()
  5078.     myHeaders[hash] = bh
  5079.  
  5080.     if current, ok := myChain[myTotal]; ok && *current == bh.PrevBlock {
  5081.         myTotal++
  5082.         myChain[myTotal] = &hash
  5083.     }
  5084.  
  5085.     var reorg1 = myHeaders[bh.PrevBlock]
  5086.  
  5087.     if myGoodReorg(myTotal, 1, reorg1) {
  5088.         if current, ok := myChain[myTotal-1]; ok && *current == reorg1.PrevBlock {
  5089.  
  5090.             delete(myChain, myTotal)
  5091.             myTotal--
  5092.             myChain[myTotal] = &bh.PrevBlock
  5093.  
  5094.             reorg(&bh.PrevBlock, &hash)
  5095.  
  5096.             myTotal++
  5097.             myChain[myTotal] = &hash
  5098.         }
  5099.     }
  5100.  
  5101.     myMutex.Unlock()
  5102. }
  5103.  
  5104. func myTotalBlocksEstimate() int64 {
  5105.     myMutex.RLock()
  5106.     var tot = myTotal
  5107.     myMutex.RUnlock()
  5108.     const NOW_TIME = 1602787294
  5109.     const NOW_BLOCKS = 652888
  5110.     if tot < NOW_BLOCKS {
  5111.         return NOW_BLOCKS + ((time.Now().Unix() - NOW_TIME) / 600)
  5112.     } else {
  5113.         myMutex.RLock()
  5114.         var blk = myHeaders[*myChain[tot]]
  5115.         var blktime = blk.Timestamp
  5116.         myMutex.RUnlock()
  5117.         return int64(tot + ((uint64(time.Now().Unix()) - uint64(blktime.Unix())) / 600))
  5118.     }
  5119. }
  5120.  
  5121. func myStatus(fun func(tot uint64, hsh *Hash)) uint64 {
  5122.     myMutex.RLock()
  5123.  
  5124.     var tot = myTotal
  5125.     var hsh = myChain[myTotal]
  5126.  
  5127.     if fun != nil {
  5128.         fun(tot, hsh)
  5129.     }
  5130.  
  5131.     myMutex.RUnlock()
  5132.     return tot
  5133. }
  5134.  
  5135. func myLocator(burst, depth byte, fun func(uint64, *Hash)) {
  5136.     myMutex.RLock()
  5137.     var i = int64(myTotal) - int64(depth)
  5138.     if i < 0 {
  5139.         i = 0
  5140.     }
  5141.     myMutex.RUnlock()
  5142.  
  5143.     myLocatorHeight(i, burst, fun)
  5144. }
  5145.  
  5146. func myLocatorHeight(i int64, burst byte, fun func(uint64, *Hash)) {
  5147.  
  5148.     for j := i; j > i-int64(burst) && j >= 0; j-- {
  5149.         myMutex.RLock()
  5150.         hash := myChain[uint64(j)]
  5151.         myMutex.RUnlock()
  5152.         fun(uint64(j), hash)
  5153.     }
  5154.     var k int64 = 2
  5155.     for j := i - int64(burst) - 1; j >= 0; j -= k {
  5156.         k *= 2
  5157.         myMutex.RLock()
  5158.         hash := myChain[uint64(j)]
  5159.         myMutex.RUnlock()
  5160.         fun(uint64(j), hash)
  5161.     }
  5162.  
  5163. }
  5164.  
  5165. func maxNetAddressPayload(pver uint32) uint32 {
  5166.  
  5167.     plen := uint32(26)
  5168.  
  5169.     if pver >= NetAddressTimeVersion {
  5170.  
  5171.         plen += 4
  5172.     }
  5173.  
  5174.     return plen
  5175. }
  5176.  
  5177. type NetAddress struct {
  5178.     Timestamp time.Time
  5179.  
  5180.     Services ServiceFlag
  5181.  
  5182.     IP net.IP
  5183.  
  5184.     Port uint16
  5185. }
  5186.  
  5187. func (na *NetAddress) HasService(service ServiceFlag) bool {
  5188.     return na.Services&service == service
  5189. }
  5190.  
  5191. func (na *NetAddress) AddService(service ServiceFlag) {
  5192.     na.Services |= service
  5193. }
  5194.  
  5195. func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
  5196.     return NewNetAddressTimestamp(time.Now(), services, ip, port)
  5197. }
  5198.  
  5199. func NewNetAddressTimestamp(
  5200.     timestamp time.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
  5201.  
  5202.     na := NetAddress{
  5203.         Timestamp: time.Unix(timestamp.Unix(), 0),
  5204.         Services:  services,
  5205.         IP:        ip,
  5206.         Port:      port,
  5207.     }
  5208.     return &na
  5209. }
  5210.  
  5211. func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
  5212.     return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
  5213. }
  5214.  
  5215. func readNetAddress(r io.Reader, pver uint32, na *NetAddress, ts bool) error {
  5216.     var ip [16]byte
  5217.  
  5218.     if ts && pver >= NetAddressTimeVersion {
  5219.         err := readElement(r, (*uint32Time)(&na.Timestamp))
  5220.         if err != nil {
  5221.             return err
  5222.         }
  5223.     }
  5224.  
  5225.     err := readElements(r, &na.Services, &ip)
  5226.     if err != nil {
  5227.         return err
  5228.     }
  5229.  
  5230.     port, err := binarySerializer.Uint16(r, bigEndian)
  5231.     if err != nil {
  5232.         return err
  5233.     }
  5234.  
  5235.     *na = NetAddress{
  5236.         Timestamp: na.Timestamp,
  5237.         Services:  na.Services,
  5238.         IP:        net.IP(ip[:]),
  5239.         Port:      port,
  5240.     }
  5241.     return nil
  5242. }
  5243.  
  5244. func writeNetAddress(w io.Writer, pver uint32, na *NetAddress, ts bool) error {
  5245.  
  5246.     if ts && pver >= NetAddressTimeVersion {
  5247.         err := writeElement(w, uint32(na.Timestamp.Unix()))
  5248.         if err != nil {
  5249.             return err
  5250.         }
  5251.     }
  5252.  
  5253.     var ip [16]byte
  5254.     if na.IP != nil {
  5255.         copy(ip[:], na.IP.To16())
  5256.     }
  5257.     err := writeElements(w, na.Services, ip)
  5258.     if err != nil {
  5259.         return err
  5260.     }
  5261.  
  5262.     return binary.Write(w, bigEndian, na.Port)
  5263. }
  5264.  
  5265. var previously_seen_mutex sync.Mutex
  5266. var previously_seen map[[32]byte]struct{}
  5267.  
  5268. func init() {
  5269.     previously_seen_mutex.Lock()
  5270.     previously_seen = make(map[[32]byte]struct{})
  5271.     previously_seen_mutex.Unlock()
  5272. }
  5273.  
  5274. func is_previously_unseen_make_seen(hash *[32]byte) bool {
  5275.     previously_seen_mutex.Lock()
  5276.     if _, ok := previously_seen[*hash]; ok {
  5277.         previously_seen_mutex.Unlock()
  5278.  
  5279.         return false
  5280.     } else {
  5281.  
  5282.         previously_seen[*hash] = struct{}{}
  5283.  
  5284.         previously_seen_mutex.Unlock()
  5285.         return true
  5286.     }
  5287.  
  5288. }
  5289.  
  5290. type Bar struct {
  5291.     percent int64
  5292.     beg     int64
  5293.     cur     int64
  5294.     total   int64
  5295.     rate    string
  5296.     Graph   string
  5297.     Unit    string
  5298. }
  5299.  
  5300. func (bar *Bar) getPercent() int64 {
  5301.     if bar.total == bar.beg {
  5302.         return 0
  5303.     }
  5304.  
  5305.     return 100 * (bar.cur - bar.beg) / (bar.total - bar.beg)
  5306. }
  5307. func (bar *Bar) Replay() {
  5308.  
  5309.     bar.Play(bar.beg, bar.cur, bar.total)
  5310. }
  5311. func (bar *Bar) Play(beg, cur, total int64) {
  5312.     fmt.Print("\r")
  5313.     bar.play(beg, cur, total)
  5314. }
  5315. func (bar *Bar) play(beg, cur, total int64) {
  5316.     bar.beg = beg
  5317.     bar.cur = cur
  5318.     bar.total = total
  5319.     last := bar.percent
  5320.     bar.percent = bar.getPercent()
  5321.     if bar.percent != last && bar.percent%2 == 0 {
  5322.         bar.rate += bar.Graph
  5323.     }
  5324.     fmt.Printf("[%-50s]%3d%% %8d/%d %s", bar.rate, bar.percent, bar.cur, bar.total, bar.Unit)
  5325. }
  5326. func (bar *Bar) Hide() {
  5327.     fmt.Print("\r\x1B[K\r")
  5328. }
  5329.  
  5330. func (bar *Bar) Finish() {
  5331.     fmt.Println("")
  5332. }
  5333.  
  5334. func (bar *Bar) Restart(unit string) {
  5335.     bar.rate = ""
  5336.     bar.Unit = unit
  5337. }
  5338.  
  5339. const (
  5340.     ProtocolVersion uint32 = 70013
  5341.  
  5342.     MultipleAddressVersion uint32 = 209
  5343.  
  5344.     NetAddressTimeVersion uint32 = 31402
  5345.  
  5346.     BIP0031Version uint32 = 60000
  5347.  
  5348.     BIP0035Version uint32 = 60002
  5349.  
  5350.     BIP0037Version uint32 = 70001
  5351.  
  5352.     RejectVersion uint32 = 70002
  5353.  
  5354.     BIP0111Version uint32 = 70011
  5355.  
  5356.     SendHeadersVersion uint32 = 70012
  5357.  
  5358.     FeeFilterVersion uint32 = 70013
  5359. )
  5360.  
  5361. type ServiceFlag uint64
  5362.  
  5363. const (
  5364.     SFNodeNetwork ServiceFlag = 1 << iota
  5365.  
  5366.     SFNodeGetUTXO
  5367.  
  5368.     SFNodeBloom
  5369.  
  5370.     SFNodeWitness
  5371.  
  5372.     SFNodeXthin
  5373.  
  5374.     SFNodeBit5
  5375.  
  5376.     SFNodeCF
  5377.  
  5378.     SFNode2X
  5379. )
  5380.  
  5381. var sfStrings = map[ServiceFlag]string{
  5382.     SFNodeNetwork: "SFNodeNetwork",
  5383.     SFNodeGetUTXO: "SFNodeGetUTXO",
  5384.     SFNodeBloom:   "SFNodeBloom",
  5385.     SFNodeWitness: "SFNodeWitness",
  5386.     SFNodeXthin:   "SFNodeXthin",
  5387.     SFNodeBit5:    "SFNodeBit5",
  5388.     SFNodeCF:      "SFNodeCF",
  5389.     SFNode2X:      "SFNode2X",
  5390. }
  5391.  
  5392. var orderedSFStrings = []ServiceFlag{
  5393.     SFNodeNetwork,
  5394.     SFNodeGetUTXO,
  5395.     SFNodeBloom,
  5396.     SFNodeWitness,
  5397.     SFNodeXthin,
  5398.     SFNodeBit5,
  5399.     SFNodeCF,
  5400.     SFNode2X,
  5401. }
  5402.  
  5403. func (f ServiceFlag) String() string {
  5404.  
  5405.     if f == 0 {
  5406.         return "0x0"
  5407.     }
  5408.  
  5409.     s := ""
  5410.     for _, flag := range orderedSFStrings {
  5411.         if f&flag == flag {
  5412.             s += sfStrings[flag] + "|"
  5413.             f -= flag
  5414.         }
  5415.     }
  5416.  
  5417.     s = strings.TrimRight(s, "|")
  5418.     if f != 0 {
  5419.         s += "|0x" + strconv.FormatUint(uint64(f), 16)
  5420.     }
  5421.     s = strings.TrimLeft(s, "|")
  5422.     return s
  5423. }
  5424.  
  5425. type BitcoinNet uint32
  5426.  
  5427. const (
  5428.     MainNet BitcoinNet = 0xd9b4bef9
  5429.  
  5430.     TestNet BitcoinNet = 0xdab5bffa
  5431.  
  5432.     TestNet3 BitcoinNet = 0x0709110b
  5433.  
  5434.     SimNet BitcoinNet = 0x12141c16
  5435. )
  5436.  
  5437. var bnStrings = map[BitcoinNet]string{
  5438.     MainNet:  "MainNet",
  5439.     TestNet:  "TestNet",
  5440.     TestNet3: "TestNet3",
  5441.     SimNet:   "SimNet",
  5442. }
  5443.  
  5444. func (n BitcoinNet) String() string {
  5445.     if s, ok := bnStrings[n]; ok {
  5446.         return s
  5447.     }
  5448.  
  5449.     return fmt.Sprintf("Unknown BitcoinNet (%d)", uint32(n))
  5450. }
  5451.  
  5452. var shutdown_mutex sync.Mutex
  5453. var shutdown bool
  5454. var shutdown_conn *net.Conn
  5455.  
  5456. func SetupCloseHandler(conn *net.Conn) {
  5457.     shutdown_mutex.Lock()
  5458.     shutdown_conn = conn
  5459.     shutdown_mutex.Unlock()
  5460.  
  5461.     c := make(chan os.Signal)
  5462.     signal.Notify(c, os.Interrupt, syscall.SIGTERM)
  5463.     go func() {
  5464.         <-c
  5465.         shutdown_mutex.Lock()
  5466.         shutdown = true
  5467.         if shutdown_conn != nil {
  5468.             (*shutdown_conn).Close()
  5469.             shutdown_conn = nil
  5470.         }
  5471.         shutdown_mutex.Unlock()
  5472.     }()
  5473. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!