func LoadState(db dbm.DB) *State { s := &State{DB: db} buf := db.Get(stateKey) if len(buf) == 0 { return nil } else { r, n, err := bytes.NewReader(buf), new(int64), new(error) s.ChainID = wire.ReadString(r, n, err) s.LastBlockHeight = wire.ReadVarint(r, n, err) s.LastBlockHash = wire.ReadByteSlice(r, n, err) s.LastBlockParts = wire.ReadBinary(types.PartSetHeader{}, r, n, err).(types.PartSetHeader) s.LastBlockTime = wire.ReadTime(r, n, err) s.BondedValidators = wire.ReadBinary(&types.ValidatorSet{}, r, n, err).(*types.ValidatorSet) s.LastBondedValidators = wire.ReadBinary(&types.ValidatorSet{}, r, n, err).(*types.ValidatorSet) s.UnbondingValidators = wire.ReadBinary(&types.ValidatorSet{}, r, n, err).(*types.ValidatorSet) accountsHash := wire.ReadByteSlice(r, n, err) s.accounts = merkle.NewIAVLTree(wire.BasicCodec, acm.AccountCodec, defaultAccountsCacheCapacity, db) s.accounts.Load(accountsHash) validatorInfosHash := wire.ReadByteSlice(r, n, err) s.validatorInfos = merkle.NewIAVLTree(wire.BasicCodec, types.ValidatorInfoCodec, 0, db) s.validatorInfos.Load(validatorInfosHash) nameRegHash := wire.ReadByteSlice(r, n, err) s.nameReg = merkle.NewIAVLTree(wire.BasicCodec, NameRegCodec, 0, db) s.nameReg.Load(nameRegHash) if *err != nil { // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED Exit(Fmt("Data has been corrupted or its spec has changed: %v\n", *err)) } // TODO: ensure that buf is completely read. } return s }
func testProof(t *testing.T, proof *IAVLProof, keyBytes, valueBytes, rootHash []byte) { // Proof must verify. if !proof.Verify(keyBytes, valueBytes, rootHash) { t.Errorf("Invalid proof. Verification failed.") return } // Write/Read then verify. proofBytes := wire.BinaryBytes(proof) n, err := int64(0), error(nil) proof2 := wire.ReadBinary(&IAVLProof{}, bytes.NewBuffer(proofBytes), &n, &err).(*IAVLProof) if err != nil { t.Errorf("Failed to read IAVLProof from bytes: %v", err) return } if !proof2.Verify(keyBytes, valueBytes, rootHash) { // t.Log(Fmt("%X\n%X\n", proofBytes, wire.BinaryBytes(proof2))) t.Errorf("Invalid proof after write/read. Verification failed.") return } // Random mutations must not verify for i := 0; i < 5; i++ { badProofBytes := MutateByteSlice(proofBytes) n, err := int64(0), error(nil) badProof := wire.ReadBinary(&IAVLProof{}, bytes.NewBuffer(badProofBytes), &n, &err).(*IAVLProof) if err != nil { continue // This is fine. } if badProof.Verify(keyBytes, valueBytes, rootHash) { t.Errorf("Proof was still valid after a random mutation:\n%X\n%X", proofBytes, badProofBytes) } } }
func TestBinaryDecode(t *testing.T) { privAccount := GenPrivAccount() pubKey := privAccount.PubKey privKey := privAccount.PrivKey msg := CRandBytes(128) sig := privKey.Sign(msg) t.Logf("msg: %X, sig: %X", msg, sig) buf, n, err := new(bytes.Buffer), new(int64), new(error) wire.WriteBinary(sig, buf, n, err) if *err != nil { t.Fatalf("Failed to write Signature: %v", err) } if len(buf.Bytes()) != ed25519.SignatureSize+1 { // 1 byte TypeByte, 64 bytes signature bytes t.Fatalf("Unexpected signature write size: %v", len(buf.Bytes())) } if buf.Bytes()[0] != SignatureTypeEd25519 { t.Fatalf("Unexpected signature type byte") } sig2, ok := wire.ReadBinary(SignatureEd25519{}, buf, n, err).(SignatureEd25519) if !ok || *err != nil { t.Fatalf("Failed to read Signature: %v", err) } // Test the signature if !pubKey.VerifyBytes(msg, sig2) { t.Errorf("Account message signature verification failed") } }
func cliBroadcast(cmd *cobra.Command, args []string) { if len(args) < 1 { exit(fmt.Errorf("must specify transaction bytes to broadcast")) } txS := args[0] // TODO: we should switch over a hex vs. json flag txBytes, err := hex.DecodeString(txS) ifExit(err) var tx types.Tx n := new(int64) buf := bytes.NewBuffer(txBytes) wire.ReadBinary(tx, buf, n, &err) ifExit(err) r, err := client.BroadcastTx(tx) ifExit(err) r2 := r.Receipt s, err := formatOutput(args, 1, r2) ifExit(err) fmt.Println(s) }
func AccountDecoder(r io.Reader, n *int64, err *error) interface{} { return wire.ReadBinary(&Account{}, r, n, err) }
func NameRegDecoder(r io.Reader, n *int64, err *error) interface{} { return wire.ReadBinary(&types.NameRegEntry{}, r, n, err) }
func ValidatorInfoDecoder(r io.Reader, n *int64, err *error) interface{} { return wire.ReadBinary(&ValidatorInfo{}, r, n, err) }
func (vc validatorCodec) Decode(r io.Reader, n *int64, err *error) interface{} { return wire.ReadBinary(&Validator{}, r, n, err) }