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 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()
}
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 TestTransactionsSize(t *testing.T) {
txns := makeTransactions(t, 10)
size := 0
for _, tx := range txns {
size += len(encoder.Serialize(&tx))
}
assert.NotEqual(t, size, 0)
assert.Equal(t, txns.Size(), size)
}
// Add transaction to the db.
func (txs *transactions) Add(t *Transaction) error {
txs.lastTxs = append(txs.lastTxs, t.Hash())
if len(txs.lastTxs) > lastTxNum {
txs.lastTxs = txs.lastTxs[1:]
}
key := t.Hash()
v := encoder.Serialize(t)
return txs.bkt.Put(key[:], v)
}
func TestBlockBodySize(t *testing.T) {
b := makeNewBlock()
addTransactionToBlock(t, &b)
assert.Equal(t, b.Size(), b.Body.Size())
assert.Equal(t, b.Body.Size(), b.Body.Transactions.Size())
size := 0
for _, x := range b.Body.Transactions {
size += len(encoder.Serialize(&x))
}
assert.NotEqual(t, size, 0)
assert.Equal(t, b.Size(), size)
}
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()
}
func (au *addressUx) Add(address cipher.Address, uxHash cipher.SHA256) error {
hashes, err := au.Get(address)
if err != nil {
return err
}
if hashes == nil {
bin := encoder.Serialize([]cipher.SHA256{uxHash})
return au.bkt.Put(address.Bytes(), bin)
}
// check dup
for _, u := range hashes {
if u == uxHash {
return nil
}
}
hashes = append(hashes, uxHash)
bin := encoder.Serialize(hashes)
return au.bkt.Put(address.Bytes(), bin)
}
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)
}
func (self *Dispatcher) EncodeMessage(msg Message) []byte {
t := reflect.ValueOf(msg).Elem().Type()
msgId, succ := self.MessageIdMap[t]
if !succ {
txt := "Attempted to serialize message struct not in MessageIdMap: %v"
log.Panicf(txt, msg)
}
bMsg := encoder.Serialize(msg)
m := make([]byte, 0, 4+len(bMsg))
m = append(m, msgId[:]...) // message id
m = append(m, bMsg...) // message bytes
return m
}
func (self *BlockSigs) Save(filename string) error {
// Convert the Sigs map to an array of element
sigs := make([]BlockSigSerialized, len(self.Sigs))
i := 0
for k, v := range self.Sigs {
sigs[i] = BlockSigSerialized{
BkSeq: k,
Sig: v,
}
i++
}
bss := BlockSigsSerialized{sigs}
data := encoder.Serialize(bss)
return util.SaveBinary(filename, data, 0644)
}
//encode block to bytes
func Enc_block(sb SignedBlock) []byte {
var prefix []byte = make([]byte, 16)
b := encoder.Serialize(sb)
var dln uint64 = uint64(len(b) + 24) //length include prefix
var seq uint64 = uint64(sb.Block.Head.BkSeq)
var chk uint64 = FnvsHash(b)
le_PutUint64(prefix[0:8], dln)
le_PutUint64(prefix[8:16], seq)
le_PutUint64(prefix[16:24], chk)
b = append(prefix[:], b...)
return b
}
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 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 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)
}
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 setHashPairInDepth(bkt *bolt.Bucket, dep uint64, hps []coin.HashPair) error {
hpsBin := encoder.Serialize(hps)
key := itob(dep)
return bkt.Put(key, hpsBin)
}
// Add stores the signed block into db.
func (bs *BlockSigs) Add(sb *coin.SignedBlock) error {
hash := sb.Block.HashHeader()
return bs.Sigs.Put(hash[:], encoder.Serialize(sb.Sig))
}
// Hashes only the Transaction Inputs & Outputs
// This is what is signed
// Client hashes the inner hash with hash of output being spent and signs it with private key
func (self *Transaction) HashInner() cipher.SHA256 {
b1 := encoder.Serialize(self.In)
b2 := encoder.Serialize(self.Out)
b3 := append(b1, b2...)
return cipher.SumSHA256(b3)
}
func (self *Transaction) Serialize() []byte {
return encoder.Serialize(*self)
}
// Returns hash of UxBody + UxHead
func (self *UxOut) SnapshotHash() cipher.SHA256 {
b1 := encoder.Serialize(self.Body) //body
b2 := encoder.Serialize(self.Head) //time, bkseq
b3 := append(b1, b2...)
return cipher.SumSHA256(b3)
}
func (self *UxBody) Hash() cipher.SHA256 {
return cipher.SumSHA256(encoder.Serialize(self))
}
// Hash return hash of block header
func (bh BlockHeader) Hash() cipher.SHA256 {
b1 := encoder.Serialize(bh)
return cipher.SumSHA256(b1)
}
// Bytes serialize the blockheader and return the byte value.
func (bh BlockHeader) Bytes() []byte {
return encoder.Serialize(bh)
}
func (self *BlockHeader) Hash() cipher.SHA256 {
b1 := encoder.Serialize(*self)
return cipher.DoubleSHA256(b1)
}
// Bytes serialize block body, and return the byte value.
func (bb BlockBody) Bytes() []byte {
return encoder.Serialize(bb)
}
func (self *SerializedBlockchain) Save(filename string) error {
data := encoder.Serialize(self)
return util.SaveBinary(filename, data, 0644)
}
//encode block as bytes
func (self *Block) Bytes() []byte {
return encoder.Serialize(*self)
}
func setBlock(bkt *bolt.Bucket, b *coin.Block) error {
bin := encoder.Serialize(b)
key := b.HashHeader()
return bkt.Put(key[:], bin)
}