func TestGivePeersMessage(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) addrs := []string{addr, addrb, "7"} peers := make([]*pex.Peer, 3) for i, addr := range addrs { peers[i] = &pex.Peer{Addr: addr} } m := NewGivePeersMessage(peers) assert.Equal(t, len(m.GetPeers()), 2) testSimpleMessageHandler(t, d, m) assert.Equal(t, m.GetPeers()[0], addrs[0]) assert.Equal(t, m.GetPeers()[1], addrs[1]) // Test disabled d.Peers.Config.Disabled = true m.Process(d) assert.Equal(t, len(d.Peers.Peers.Peerlist), 0) // Test serialization m = NewGivePeersMessage(peers) b := encoder.Serialize(m) m2 := GivePeersMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) // Peers should be added to the pex when processed d.Peers.Config.Disabled = false m.Process(d) assert.Equal(t, len(d.Peers.Peers.Peerlist), 2) gnet.EraseMessages() }
func TransactionDeserialize(b []byte) Transaction { t := Transaction{} if err := encoder.DeserializeRaw(b, &t); err != nil { log.Panic("Failed to deserialize transaction") } return t }
func TestPingMessage(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) p := d.Pool.Pool m := &PingMessage{} testSimpleMessageHandler(t, d, m) m.c = messageContext(addr) go p.ConnectionWriteLoop(m.c.Conn) defer m.c.Conn.Close() assert.NotPanics(t, func() { m.Process(d) }) // A pong message should have been sent wait() assert.Equal(t, len(p.SendResults), 1) if len(p.SendResults) == 0 { t.Fatalf("SendResults empty, would block") } sr := <-p.SendResults assert.Equal(t, sr.Connection, m.c.Conn) assert.Nil(t, sr.Error) _, ok := sr.Message.(*PongMessage) assert.True(t, ok) assert.False(t, m.c.Conn.LastSent.IsZero()) // Test serialization mm := PingMessage{} b := encoder.Serialize(mm) m2 := PingMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, mm, m2) gnet.EraseMessages() }
//decode block to bytes func Dec_block(b []byte) (SignedBlock, error) { if len(b) < 16 { log.Panic() } var dln uint64 = le_Uint64(b[0:8]) var seq uint64 = le_Uint64(b[8:16]) var chk uint64 = le_Uint64(b[16:24]) if dln != uint64(len(b)) { log.Panic("Dec_block, length check failed") } b = b[24:] //cleave off header if chk != FnvsHash(b) { log.Panic("Dec_block, checksum failed") } var sb SignedBlock err := encoder.DeserializeRaw(b, &sb) if err != nil { log.Panic("Dec_block, deserialization failed") } if seq != sb.Block.Head.BkSeq { log.Panic("Dec_block, seq mismatch") } return sb, nil }
func TestGetPeersMessage(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) p := d.Pool m := NewGetPeersMessage() testSimpleMessageHandler(t, d, m) d.Peers.Peers.AddPeer(addr) q, err := d.Peers.Peers.AddPeer(addrb) assert.Nil(t, err) q.Private = true d.Peers.Config.ReplyCount = 100 m.c = messageContext(addr) // Peers disabled d.Peers.Config.Disabled = true assert.NotPanics(t, func() { m.Process(d) }) wait() assert.Equal(t, len(p.Pool.SendResults), 0) assert.True(t, m.c.Conn.LastSent.IsZero()) // Peers enabled d.Peers.Config.Disabled = false m.c = messageContext(addr) defer m.c.Conn.Close() go p.Pool.ConnectionWriteLoop(m.c.Conn) assert.NotPanics(t, func() { m.Process(d) }) wait() assert.Equal(t, len(p.Pool.SendResults), 1) if len(p.Pool.SendResults) == 0 { t.Fatal("SendResults empty, would block") } sr := <-p.Pool.SendResults assert.Nil(t, sr.Error) assert.Equal(t, sr.Connection, m.c.Conn) msg, ok := sr.Message.(*GivePeersMessage) assert.True(t, ok) // Private peer should not be included ipAddr, err := NewIPAddr(addr) assert.Nil(t, err) assert.Equal(t, msg.Peers, []IPAddr{ipAddr}) assert.False(t, m.c.Conn.LastSent.IsZero()) // If no peers, nothing should happen m.c.Conn.LastSent = util.ZeroTime() delete(d.Peers.Peers.Peerlist, addr) assert.NotPanics(t, func() { m.Process(d) }) wait() assert.Equal(t, len(p.Pool.SendResults), 0) assert.True(t, m.c.Conn.LastSent.IsZero()) // Test serialization m = NewGetPeersMessage() b := encoder.Serialize(m) m2 := GetPeersMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) gnet.EraseMessages() }
func (bt *BlockTree) getBlock(hash cipher.SHA256) *coin.Block { bin := bt.blocks.Get(hash[:]) if bin == nil { return nil } block := coin.Block{} if err := encoder.DeserializeRaw(bin, &block); err != nil { return nil } return &block }
func getBucketValue(db *bolt.DB, name []byte, key []byte, value interface{}) error { return db.View(func(tx *bolt.Tx) error { b := tx.Bucket(name) bin := b.Get(key) if bin == nil { value = nil return nil } return encoder.DeserializeRaw(bin, value) }) }
// Get returns signature of specific block func (bs BlockSigs) Get(hash cipher.SHA256) (cipher.Sig, error) { bin := bs.Sigs.Get(hash[:]) if bin == nil { return cipher.Sig{}, fmt.Errorf("no sig for %v", hash.Hex()) } var sig cipher.Sig if err := encoder.DeserializeRaw(bin, &sig); err != nil { return cipher.Sig{}, err } return sig, nil }
// Get return nil on not found. func (au *addressUx) Get(address cipher.Address) ([]cipher.SHA256, error) { uxHashes := []cipher.SHA256{} bin := au.bkt.Get(address.Bytes()) if bin == nil { return nil, nil } if err := encoder.DeserializeRaw(bin, &uxHashes); err != nil { return nil, err } return uxHashes, nil }
func (bt *BlockTree) getHashInDepth(depth uint64, filter func(ps []coin.HashPair) cipher.SHA256) (cipher.SHA256, error) { key := itob(depth) pairsBin := bt.tree.Get(key) pairs := []coin.HashPair{} if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil { return cipher.SHA256{}, err } hash := filter(pairs) return hash, nil }
func LoadSerializedBlockchain(filename string) (*SerializedBlockchain, error) { sbc := &SerializedBlockchain{} data, err := ioutil.ReadFile(filename) if err != nil { return nil, err } err = encoder.DeserializeRaw(data, sbc) if err != nil { return nil, err } return sbc, nil }
func TestIntroductionMessageHandle(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) mc := messageContext(addr) m := NewIntroductionMessage(d.Messages.Mirror, d.Config.Version, d.Pool.Pool.Config.Port) // Test valid handling m.Mirror = d.Messages.Mirror + 1 err := m.Handle(mc, d) assert.Nil(t, err) if len(d.messageEvents) == 0 { t.Fatalf("messageEvent is empty") } <-d.messageEvents assert.True(t, m.valid) m.valid = false // Test matching mirror m.Mirror = d.Messages.Mirror err = m.Handle(mc, d) assert.Equal(t, err, DisconnectSelf) m.Mirror = d.Messages.Mirror + 1 assert.False(t, m.valid) // Test mismatched d.Config.Version m.Version = d.Config.Version + 1 err = m.Handle(mc, d) assert.Equal(t, err, DisconnectInvalidVersion) assert.False(t, m.valid) // Test serialization m = NewIntroductionMessage(d.Messages.Mirror, d.Config.Version, d.Pool.Pool.Config.Port) b := encoder.Serialize(m) m2 := IntroductionMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) // Test already connected d.mirrorConnections[m.Mirror] = make(map[string]uint16) d.mirrorConnections[m.Mirror][addrIP] = addrPort + 1 err = m.Handle(mc, d) assert.Equal(t, err, DisconnectConnectedTwice) delete(d.mirrorConnections, m.Mirror) assert.False(t, m.valid) for len(d.messageEvents) > 0 { <-d.messageEvents } gnet.EraseMessages() }
// GetAllBlockHashInDepth returns all block hash of N depth in the tree. func (bt *BlockTree) GetAllBlockHashInDepth(depth uint64) ([]cipher.SHA256, error) { key := itob(depth) pairsBin := bt.tree.Get(key) pairs := []coin.HashPair{} if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil { return []cipher.SHA256{}, err } hashes := make([]cipher.SHA256, len(pairs)) for i, hp := range pairs { hashes[i] = hp.Hash } return hashes, nil }
func TestGetBlocksMessageHandle(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) m := NewGetBlocksMessage(uint64(1)) assert.Equal(t, m.LastBlock, uint64(1)) testSimpleMessageHandler(t, d, m) // Test serialization m = NewGetBlocksMessage(uint64(106)) b := encoder.Serialize(m) m2 := GetBlocksMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) }
// Get get transaction by tx hash, return nil on not found. func (txs transactions) Get(hash cipher.SHA256) (*Transaction, error) { bin := txs.bkt.Get(hash[:]) if bin == nil { return nil, nil } // deserialize tx var tx Transaction if err := encoder.DeserializeRaw(bin, &tx); err != nil { return nil, err } return &tx, nil }
func TestPongMessage(t *testing.T) { cmsgs := NewMessagesConfig() cmsgs.Register() m := &PongMessage{} // Pongs dont do anything assert.Nil(t, m.Handle(messageContext(addr), nil)) gnet.EraseMessages() // Test serialization mm := PongMessage{} b := encoder.Serialize(mm) m2 := PongMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, mm, m2) }
func getHashPairInDepth(tree *bolt.Bucket, dep uint64, fn func(hp coin.HashPair) bool) ([]coin.HashPair, error) { v := tree.Get(itob(dep)) if v == nil { return []coin.HashPair{}, nil } hps := []coin.HashPair{} if err := encoder.DeserializeRaw(v, &hps); err != nil { return nil, err } pairs := []coin.HashPair{} for _, ps := range hps { if fn(ps) { pairs = append(pairs, ps) } } return pairs, nil }
func TestGiveBlocksMessageHandle(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) _, mv := setupVisor() blocks := []visor.SignedBlock{mv.GetGenesisBlock()} m := NewGiveBlocksMessage(blocks) assert.Equal(t, m.Blocks, blocks) testSimpleMessageHandler(t, d, m) // Test serialization bks, err := makeBlocks(mv, 4) assert.Nil(t, err) blocks = append(blocks, bks...) m = NewGiveBlocksMessage(blocks) b := encoder.Serialize(m) m2 := GiveBlocksMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) }
func LoadBlockSigs(filename string) (BlockSigs, error) { bs := NewBlockSigs() data, err := ioutil.ReadFile(filename) if err != nil { return bs, err } sigs := BlockSigsSerialized{make([]BlockSigSerialized, 0)} err = encoder.DeserializeRaw(data, &sigs) if err != nil { return bs, err } bs.Sigs = make(map[uint64]cipher.Sig, len(sigs.Sigs)) for _, s := range sigs.Sigs { bs.Sigs[s.BkSeq] = s.Sig if s.BkSeq > bs.MaxSeq { bs.MaxSeq = s.BkSeq } } return bs, nil }
func TestAnnounceTxnsMessageHandle(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) tx := createUnconfirmedTxn() txns := []cipher.SHA256{tx.Txn.Hash()} m := NewAnnounceTxnsMessage(txns) assert.Equal(t, m.Txns, txns) testSimpleMessageHandler(t, d, m) // Test serialization tx = createUnconfirmedTxn() txns = append(txns, tx.Txn.Hash()) tx = createUnconfirmedTxn() txns = append(txns, tx.Txn.Hash()) m = NewAnnounceTxnsMessage(txns) assert.Equal(t, len(m.Txns), 3) b := encoder.Serialize(m) m2 := AnnounceTxnsMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) }
func TestGiveTxnsMessageHandle(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) tx := createUnconfirmedTxn() txns := coin.Transactions{tx.Txn} m := NewGiveTxnsMessage(txns) assert.Equal(t, m.Txns, txns) testSimpleMessageHandler(t, d, m) // Test serialization tx = createUnconfirmedTxn() txns = append(txns, tx.Txn) tx = createUnconfirmedTxn() txns = append(txns, tx.Txn) m = NewGiveTxnsMessage(txns) assert.Equal(t, len(m.Txns), 3) b := encoder.Serialize(m) m2 := GiveTxnsMessage{} assert.Nil(t, encoder.DeserializeRaw(b, &m2)) assert.Equal(t, *m, m2) }
//creates block from byte array func BlockFromBytes(data []byte) (Block, error) { var b Block return b, encoder.DeserializeRaw(data, &b) }