certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

catch up with amino changes in 

https://github.com/tendermint/go-amino/pull/222
This commit is contained in:
Ismail Khoffi 2018-09-08 17:59:36 +01:00
parent 0bec20a1e3
commit ea5f3b329f
17 changed files with 56 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
blockchain/store.go
View File

@ -63,7 +63,7 @@ func (bs *BlockStore) LoadBlock(height int64) *types.Block {
part := bs.LoadBlockPart(height, i) part := bs.LoadBlockPart(height, i)
buf = append(buf, part.Bytes...) buf = append(buf, part.Bytes...)
} }
err := cdc.UnmarshalBinary(buf, block) err := cdc.UnmarshalBinaryLengthPrefixedBinary(buf, block)
if err != nil { if err != nil {
// NOTE: The existence of meta should imply the existence of the // NOTE: The existence of meta should imply the existence of the
// block. So, make sure meta is only saved after blocks are saved. // block. So, make sure meta is only saved after blocks are saved.

4
consensus/replay_test.go
View File

@ -524,7 +524,7 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
// if its not the first one, we have a full block // if its not the first one, we have a full block
if thisBlockParts != nil { if thisBlockParts != nil {
var block = new(types.Block) var block = new(types.Block)
_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(thisBlockParts.GetReader(), block, 0)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -557,7 +557,7 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
} }
// grab the last block too // grab the last block too
var block = new(types.Block) var block = new(types.Block)
_, err = cdc.UnmarshalBinaryReader(thisBlockParts.GetReader(), block, 0) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(thisBlockParts.GetReader(), block, 0)
if err != nil { if err != nil {
panic(err) panic(err)
} }

2
consensus/state.go
View File

@ -1451,7 +1451,7 @@ func (cs *ConsensusState) addProposalBlockPart(msg *BlockPartMessage, peerID p2p
} }
if added && cs.ProposalBlockParts.IsComplete() { if added && cs.ProposalBlockParts.IsComplete() {
// Added and completed! // Added and completed!
_, err = cdc.UnmarshalBinaryReader( _, err = cdc.UnmarshalBinaryLengthPrefixedReader(
cs.ProposalBlockParts.GetReader(), cs.ProposalBlockParts.GetReader(),
&cs.ProposalBlock, &cs.ProposalBlock,
int64(cs.state.ConsensusParams.BlockSize.MaxBytes), int64(cs.state.ConsensusParams.BlockSize.MaxBytes),

10
lite/dbprovider.go
View File

@ -56,7 +56,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
// We might be overwriting what we already have, but // We might be overwriting what we already have, but
// it makes the logic easier for now. // it makes the logic easier for now.
vsKey := validatorSetKey(fc.ChainID(), fc.Height()) vsKey := validatorSetKey(fc.ChainID(), fc.Height())
vsBz, err := dbp.cdc.MarshalBinary(fc.Validators) vsBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.Validators)
if err != nil { if err != nil {
return err return err
} }
@ -64,7 +64,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
// Save the fc.NextValidators. // Save the fc.NextValidators.
nvsKey := validatorSetKey(fc.ChainID(), fc.Height()+1) nvsKey := validatorSetKey(fc.ChainID(), fc.Height()+1)
nvsBz, err := dbp.cdc.MarshalBinary(fc.NextValidators) nvsBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.NextValidators)
if err != nil { if err != nil {
return err return err
} }
@ -72,7 +72,7 @@ func (dbp *DBProvider) SaveFullCommit(fc FullCommit) error {
// Save the fc.SignedHeader // Save the fc.SignedHeader
shKey := signedHeaderKey(fc.ChainID(), fc.Height()) shKey := signedHeaderKey(fc.ChainID(), fc.Height())
shBz, err := dbp.cdc.MarshalBinary(fc.SignedHeader) shBz, err := dbp.cdc.MarshalBinaryLengthPrefixed(fc.SignedHeader)
if err != nil { if err != nil {
return err return err
} }
@ -121,7 +121,7 @@ func (dbp *DBProvider) LatestFullCommit(chainID string, minHeight, maxHeight int
// Found the latest full commit signed header. // Found the latest full commit signed header.
shBz := itr.Value() shBz := itr.Value()
sh := types.SignedHeader{} sh := types.SignedHeader{}
err := dbp.cdc.UnmarshalBinary(shBz, &sh) err := dbp.cdc.UnmarshalBinaryLengthPrefixedBinary(shBz, &sh)
if err != nil { if err != nil {
return FullCommit{}, err return FullCommit{}, err
} else { } else {
@ -150,7 +150,7 @@ func (dbp *DBProvider) getValidatorSet(chainID string, height int64) (valset *ty
err = lerr.ErrUnknownValidators(chainID, height) err = lerr.ErrUnknownValidators(chainID, height)
return return
} }
err = dbp.cdc.UnmarshalBinary(vsBz, &valset) err = dbp.cdc.UnmarshalBinaryLengthPrefixedBinary(vsBz, &valset)
if err != nil { if err != nil {
return return
} }

10
p2p/conn/connection.go
View File

@ -337,7 +337,7 @@ FOR_LOOP:
} }
case <-c.pingTimer.Chan(): case <-c.pingTimer.Chan():
c.Logger.Debug("Send Ping") c.Logger.Debug("Send Ping")
_n, err = cdc.MarshalBinaryWriter(c.bufConnWriter, PacketPing{}) _n, err = cdc.MarshalBinaryLengthPrefixedWriter(c.bufConnWriter, PacketPing{})
if err != nil { if err != nil {
break SELECTION break SELECTION
} }
@ -359,7 +359,7 @@ FOR_LOOP:
} }
case <-c.pong: case <-c.pong:
c.Logger.Debug("Send Pong") c.Logger.Debug("Send Pong")
_n, err = cdc.MarshalBinaryWriter(c.bufConnWriter, PacketPong{}) _n, err = cdc.MarshalBinaryLengthPrefixedWriter(c.bufConnWriter, PacketPong{})
if err != nil { if err != nil {
break SELECTION break SELECTION
} }
@ -477,7 +477,7 @@ FOR_LOOP:
var packet Packet var packet Packet
var _n int64 var _n int64
var err error var err error
_n, err = cdc.UnmarshalBinaryReader(c.bufConnReader, &packet, int64(c._maxPacketMsgSize)) _n, err = cdc.UnmarshalBinaryLengthPrefixedReader(c.bufConnReader, &packet, int64(c._maxPacketMsgSize))
c.recvMonitor.Update(int(_n)) c.recvMonitor.Update(int(_n))
if err != nil { if err != nil {
if c.IsRunning() { if c.IsRunning() {
@ -553,7 +553,7 @@ func (c *MConnection) stopPongTimer() {
// maxPacketMsgSize returns a maximum size of PacketMsg, including the overhead // maxPacketMsgSize returns a maximum size of PacketMsg, including the overhead
// of amino encoding. // of amino encoding.
func (c *MConnection) maxPacketMsgSize() int { func (c *MConnection) maxPacketMsgSize() int {
return len(cdc.MustMarshalBinary(PacketMsg{ return len(cdc.MustMarshalBinaryLengthPrefixed(PacketMsg{
ChannelID: 0x01, ChannelID: 0x01,
EOF: 1, EOF: 1,
Bytes: make([]byte, c.config.MaxPacketMsgPayloadSize), Bytes: make([]byte, c.config.MaxPacketMsgPayloadSize),
@ -723,7 +723,7 @@ func (ch *Channel) nextPacketMsg() PacketMsg {
// Not goroutine-safe // Not goroutine-safe
func (ch *Channel) writePacketMsgTo(w io.Writer) (n int64, err error) { func (ch *Channel) writePacketMsgTo(w io.Writer) (n int64, err error) {
var packet = ch.nextPacketMsg() var packet = ch.nextPacketMsg()
n, err = cdc.MarshalBinaryWriter(w, packet) n, err = cdc.MarshalBinaryLengthPrefixedWriter(w, packet)
ch.recentlySent += n ch.recentlySent += n
return return
} }

38
p2p/conn/connection_test.go
View File

@ -140,7 +140,7 @@ func TestMConnectionPongTimeoutResultsInError(t *testing.T) {
go func() { go func() {
// read ping // read ping
var pkt PacketPing var pkt PacketPing
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
assert.Nil(t, err) assert.Nil(t, err)
serverGotPing <- struct{}{} serverGotPing <- struct{}{}
}() }()
@ -176,22 +176,22 @@ func TestMConnectionMultiplePongsInTheBeginning(t *testing.T) {
defer mconn.Stop() defer mconn.Stop()
// sending 3 pongs in a row (abuse) // sending 3 pongs in a row (abuse)
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
serverGotPing := make(chan struct{}) serverGotPing := make(chan struct{})
go func() { go func() {
// read ping (one byte) // read ping (one byte)
var packet, err = Packet(nil), error(nil) var packet, err = Packet(nil), error(nil)
_, err = cdc.UnmarshalBinaryReader(server, &packet, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &packet, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
serverGotPing <- struct{}{} serverGotPing <- struct{}{}
// respond with pong // respond with pong
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
}() }()
<-serverGotPing <-serverGotPing
@ -227,18 +227,18 @@ func TestMConnectionMultiplePings(t *testing.T) {
// sending 3 pings in a row (abuse) // sending 3 pings in a row (abuse)
// see https://github.com/tendermint/tendermint/issues/1190 // see https://github.com/tendermint/tendermint/issues/1190
_, err = server.Write(cdc.MustMarshalBinary(PacketPing{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
require.Nil(t, err) require.Nil(t, err)
var pkt PacketPong var pkt PacketPong
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
_, err = server.Write(cdc.MustMarshalBinary(PacketPing{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
require.Nil(t, err) require.Nil(t, err)
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
_, err = server.Write(cdc.MustMarshalBinary(PacketPing{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPing{}))
require.Nil(t, err) require.Nil(t, err)
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
assert.True(t, mconn.IsRunning()) assert.True(t, mconn.IsRunning())
@ -270,20 +270,20 @@ func TestMConnectionPingPongs(t *testing.T) {
go func() { go func() {
// read ping // read ping
var pkt PacketPing var pkt PacketPing
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
serverGotPing <- struct{}{} serverGotPing <- struct{}{}
// respond with pong // respond with pong
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
time.Sleep(mconn.config.PingInterval) time.Sleep(mconn.config.PingInterval)
// read ping // read ping
_, err = cdc.UnmarshalBinaryReader(server, &pkt, maxPingPongPacketSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(server, &pkt, maxPingPongPacketSize)
require.Nil(t, err) require.Nil(t, err)
// respond with pong // respond with pong
_, err = server.Write(cdc.MustMarshalBinary(PacketPong{})) _, err = server.Write(cdc.MustMarshalBinaryLengthPrefixed(PacketPong{}))
require.Nil(t, err) require.Nil(t, err)
}() }()
<-serverGotPing <-serverGotPing
@ -380,7 +380,7 @@ func TestMConnectionReadErrorBadEncoding(t *testing.T) {
client := mconnClient.conn client := mconnClient.conn
// send badly encoded msgPacket // send badly encoded msgPacket
bz := cdc.MustMarshalBinary(PacketMsg{}) bz := cdc.MustMarshalBinaryLengthPrefixed(PacketMsg{})
bz[4] += 0x01 // Invalid prefix bytes. bz[4] += 0x01 // Invalid prefix bytes.
// Write it. // Write it.
@ -428,7 +428,7 @@ func TestMConnectionReadErrorLongMessage(t *testing.T) {
EOF: 1, EOF: 1,
Bytes: make([]byte, mconnClient.config.MaxPacketMsgPayloadSize), Bytes: make([]byte, mconnClient.config.MaxPacketMsgPayloadSize),
} }
_, err = cdc.MarshalBinaryWriter(buf, packet) _, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, packet)
assert.Nil(t, err) assert.Nil(t, err)
_, err = client.Write(buf.Bytes()) _, err = client.Write(buf.Bytes())
assert.Nil(t, err) assert.Nil(t, err)
@ -441,7 +441,7 @@ func TestMConnectionReadErrorLongMessage(t *testing.T) {
EOF: 1, EOF: 1,
Bytes: make([]byte, mconnClient.config.MaxPacketMsgPayloadSize+100), Bytes: make([]byte, mconnClient.config.MaxPacketMsgPayloadSize+100),
} }
_, err = cdc.MarshalBinaryWriter(buf, packet) _, err = cdc.MarshalBinaryLengthPrefixedWriter(buf, packet)
assert.Nil(t, err) assert.Nil(t, err)
_, err = client.Write(buf.Bytes()) _, err = client.Write(buf.Bytes())
assert.NotNil(t, err) assert.NotNil(t, err)

8
p2p/conn/secret_connection.go
View File

@ -210,7 +210,7 @@ func shareEphPubKey(conn io.ReadWriteCloser, locEphPub *[32]byte) (remEphPub *[3
// Send our pubkey and receive theirs in tandem. // Send our pubkey and receive theirs in tandem.
var trs, _ = cmn.Parallel( var trs, _ = cmn.Parallel(
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
var _, err1 = cdc.MarshalBinaryWriter(conn, locEphPub) var _, err1 = cdc.MarshalBinaryLengthPrefixedWriter(conn, locEphPub)
if err1 != nil { if err1 != nil {
return nil, err1, true // abort return nil, err1, true // abort
} }
@ -218,7 +218,7 @@ func shareEphPubKey(conn io.ReadWriteCloser, locEphPub *[32]byte) (remEphPub *[3
}, },
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
var _remEphPub [32]byte var _remEphPub [32]byte
var _, err2 = cdc.UnmarshalBinaryReader(conn, &_remEphPub, 1024*1024) // TODO var _, err2 = cdc.UnmarshalBinaryLengthPrefixedReader(conn, &_remEphPub, 1024*1024) // TODO
if err2 != nil { if err2 != nil {
return nil, err2, true // abort return nil, err2, true // abort
} }
@ -304,7 +304,7 @@ func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKey, signature []
// Send our info and receive theirs in tandem. // Send our info and receive theirs in tandem.
var trs, _ = cmn.Parallel( var trs, _ = cmn.Parallel(
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
var _, err1 = cdc.MarshalBinaryWriter(sc, authSigMessage{pubKey, signature}) var _, err1 = cdc.MarshalBinaryLengthPrefixedWriter(sc, authSigMessage{pubKey, signature})
if err1 != nil { if err1 != nil {
return nil, err1, true // abort return nil, err1, true // abort
} }
@ -312,7 +312,7 @@ func shareAuthSignature(sc *SecretConnection, pubKey crypto.PubKey, signature []
}, },
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
var _recvMsg authSigMessage var _recvMsg authSigMessage
var _, err2 = cdc.UnmarshalBinaryReader(sc, &_recvMsg, 1024*1024) // TODO var _, err2 = cdc.UnmarshalBinaryLengthPrefixedReader(sc, &_recvMsg, 1024*1024) // TODO
if err2 != nil { if err2 != nil {
return nil, err2, true // abort return nil, err2, true // abort
} }

4
p2p/peer.go
View File

@ -350,11 +350,11 @@ func (pc *peerConn) HandshakeTimeout(
var trs, _ = cmn.Parallel( var trs, _ = cmn.Parallel(
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
_, err = cdc.MarshalBinaryWriter(pc.conn, ourNodeInfo) _, err = cdc.MarshalBinaryLengthPrefixedWriter(pc.conn, ourNodeInfo)
return return
}, },
func(_ int) (val interface{}, err error, abort bool) { func(_ int) (val interface{}, err error, abort bool) {
_, err = cdc.UnmarshalBinaryReader( _, err = cdc.UnmarshalBinaryLengthPrefixedReader(
pc.conn, pc.conn,
&peerNodeInfo, &peerNodeInfo,
int64(MaxNodeInfoSize()), int64(MaxNodeInfoSize()),

4
privval/socket.go
View File

@ -523,7 +523,7 @@ type SignHeartbeatMsg struct {
func readMsg(r io.Reader) (msg SocketPVMsg, err error) { func readMsg(r io.Reader) (msg SocketPVMsg, err error) {
const maxSocketPVMsgSize = 1024 * 10 const maxSocketPVMsgSize = 1024 * 10
_, err = cdc.UnmarshalBinaryReader(r, &msg, maxSocketPVMsgSize) _, err = cdc.UnmarshalBinaryLengthPrefixedReader(r, &msg, maxSocketPVMsgSize)
if _, ok := err.(timeoutError); ok { if _, ok := err.(timeoutError); ok {
err = cmn.ErrorWrap(ErrConnTimeout, err.Error()) err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
} }
@ -531,7 +531,7 @@ func readMsg(r io.Reader) (msg SocketPVMsg, err error) {
} }
func writeMsg(w io.Writer, msg interface{}) (err error) { func writeMsg(w io.Writer, msg interface{}) (err error) {
_, err = cdc.MarshalBinaryWriter(w, msg) _, err = cdc.MarshalBinaryLengthPrefixedWriter(w, msg)
if _, ok := err.(timeoutError); ok { if _, ok := err.(timeoutError); ok {
err = cmn.ErrorWrap(ErrConnTimeout, err.Error()) err = cmn.ErrorWrap(ErrConnTimeout, err.Error())
} }

2
types/block.go
View File

@ -143,7 +143,7 @@ func (b *Block) MakePartSet(partSize int) *PartSet {
// We prefix the byte length, so that unmarshaling // We prefix the byte length, so that unmarshaling
// can easily happen via a reader. // can easily happen via a reader.
bz, err := cdc.MarshalBinary(b) bz, err := cdc.MarshalBinaryLengthPrefixed(b)
if err != nil { if err != nil {
panic(err) panic(err)
} }

2
types/block_test.go
View File

@ -263,7 +263,7 @@ func TestMaxHeaderBytes(t *testing.T) {
ProposerAddress: tmhash.Sum([]byte("proposer_address")), ProposerAddress: tmhash.Sum([]byte("proposer_address")),
} }
bz, err := cdc.MarshalBinary(h) bz, err := cdc.MarshalBinaryLengthPrefixed(h)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, MaxHeaderBytes, len(bz)) assert.Equal(t, MaxHeaderBytes, len(bz))

2
types/evidence_test.go
View File

@ -105,7 +105,7 @@ func TestMaxEvidenceBytes(t *testing.T) {
VoteB: makeVote(val, chainID, math.MaxInt64, math.MaxInt64, math.MaxInt64, math.MaxInt64, blockID2), VoteB: makeVote(val, chainID, math.MaxInt64, math.MaxInt64, math.MaxInt64, math.MaxInt64, blockID2),
} }
bz, err := cdc.MarshalBinary(ev) bz, err := cdc.MarshalBinaryLengthPrefixed(ev)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, MaxEvidenceBytes, len(bz)) assert.Equal(t, MaxEvidenceBytes, len(bz))

4
types/proposal_test.go
View File

@ -62,9 +62,9 @@ func TestProposalVerifySignature(t *testing.T) {
// serialize, deserialize and verify again.... // serialize, deserialize and verify again....
newProp := new(Proposal) newProp := new(Proposal)
bs, err := cdc.MarshalBinary(prop) bs, err := cdc.MarshalBinaryLengthPrefixed(prop)
require.NoError(t, err) require.NoError(t, err)
err = cdc.UnmarshalBinary(bs, &newProp) err = cdc.UnmarshalBinaryLengthPrefixedBinary(bs, &newProp)
require.NoError(t, err) require.NoError(t, err)
// verify the transmitted proposal // verify the transmitted proposal

2
types/results.go
View File

@ -43,7 +43,7 @@ func NewResultFromResponse(response *abci.ResponseDeliverTx) ABCIResult {
// Bytes serializes the ABCIResponse using wire // Bytes serializes the ABCIResponse using wire
func (a ABCIResults) Bytes() []byte { func (a ABCIResults) Bytes() []byte {
bz, err := cdc.MarshalBinary(a) bz, err := cdc.MarshalBinaryLengthPrefixed(a)
if err != nil { if err != nil {
panic(err) panic(err)
} }

8
types/tx_test.go
View File

@ -79,9 +79,9 @@ func TestValidTxProof(t *testing.T) {
// read-write must also work // read-write must also work
var p2 TxProof var p2 TxProof
bin, err := cdc.MarshalBinary(proof) bin, err := cdc.MarshalBinaryLengthPrefixed(proof)
assert.Nil(t, err) assert.Nil(t, err)
err = cdc.UnmarshalBinary(bin, &p2) err = cdc.UnmarshalBinaryLengthPrefixedBinary(bin, &p2)
if assert.Nil(t, err, "%d: %d: %+v", h, i, err) { if assert.Nil(t, err, "%d: %d: %+v", h, i, err) {
assert.Nil(t, p2.Validate(root), "%d: %d", h, i) assert.Nil(t, p2.Validate(root), "%d: %d", h, i)
} }
@ -105,7 +105,7 @@ func testTxProofUnchangable(t *testing.T) {
// make sure it is valid to start with // make sure it is valid to start with
assert.Nil(t, proof.Validate(root)) assert.Nil(t, proof.Validate(root))
bin, err := cdc.MarshalBinary(proof) bin, err := cdc.MarshalBinaryLengthPrefixed(proof)
assert.Nil(t, err) assert.Nil(t, err)
// try mutating the data and make sure nothing breaks // try mutating the data and make sure nothing breaks
@ -120,7 +120,7 @@ func testTxProofUnchangable(t *testing.T) {
// This makes sure that the proof doesn't deserialize into something valid. // This makes sure that the proof doesn't deserialize into something valid.
func assertBadProof(t *testing.T, root []byte, bad []byte, good TxProof) { func assertBadProof(t *testing.T, root []byte, bad []byte, good TxProof) {
var proof TxProof var proof TxProof
err := cdc.UnmarshalBinary(bad, &proof) err := cdc.UnmarshalBinaryLengthPrefixedBinary(bad, &proof)
if err == nil { if err == nil {
err = proof.Validate(root) err = proof.Validate(root)
if err == nil { if err == nil {

4
types/validator_set_test.go
View File

@ -272,7 +272,7 @@ func randValidatorSet(numValidators int) *ValidatorSet {
} }
func (valSet *ValidatorSet) toBytes() []byte { func (valSet *ValidatorSet) toBytes() []byte {
bz, err := cdc.MarshalBinary(valSet) bz, err := cdc.MarshalBinaryLengthPrefixed(valSet)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -280,7 +280,7 @@ func (valSet *ValidatorSet) toBytes() []byte {
} }
func (valSet *ValidatorSet) fromBytes(b []byte) { func (valSet *ValidatorSet) fromBytes(b []byte) {
err := cdc.UnmarshalBinary(b, &valSet) err := cdc.UnmarshalBinaryLengthPrefixedBinary(b, &valSet)
if err != nil { if err != nil {
// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
panic(err) panic(err)

6
types/vote_test.go
View File

@ -72,9 +72,9 @@ func TestVoteVerifySignature(t *testing.T) {
// serialize, deserialize and verify again.... // serialize, deserialize and verify again....
precommit := new(Vote) precommit := new(Vote)
bs, err := cdc.MarshalBinary(vote) bs, err := cdc.MarshalBinaryLengthPrefixed(vote)
require.NoError(t, err) require.NoError(t, err)
err = cdc.UnmarshalBinary(bs, &precommit) err = cdc.UnmarshalBinaryLengthPrefixedBinary(bs, &precommit)
require.NoError(t, err) require.NoError(t, err)
// verify the transmitted vote // verify the transmitted vote
@ -144,7 +144,7 @@ func TestMaxVoteBytes(t *testing.T) {
err := privVal.SignVote("test_chain_id", vote) err := privVal.SignVote("test_chain_id", vote)
require.NoError(t, err) require.NoError(t, err)
bz, err := cdc.MarshalBinary(vote) bz, err := cdc.MarshalBinaryLengthPrefixed(vote)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, MaxVoteBytes, len(bz)) assert.Equal(t, MaxVoteBytes, len(bz))