package account import ( "bytes" "fmt" "io" "github.com/tendermint/tendermint/binary" "github.com/tendermint/tendermint/merkle" ) // Signable is an interface for all signable things. // It typically removes signatures before serializing. type Signable interface { WriteSignBytes(chainID string, w io.Writer, n *int64, err *error) } // SignBytes is a convenience method for getting the bytes to sign of a Signable. func SignBytes(chainID string, o Signable) []byte { buf, n, err := new(bytes.Buffer), new(int64), new(error) o.WriteSignBytes(chainID, buf, n, err) if *err != nil { panic(err) } return buf.Bytes() } // HashSignBytes is a convenience method for getting the hash of the bytes of a signable func HashSignBytes(chainID string, o Signable) []byte { return merkle.SimpleHashFromBinary(SignBytes(chainID, o)) } //----------------------------------------------------------------------------- // Account resides in the application state, and is mutated by transactions // on the blockchain. // Serialized by binary.[read|write]Reflect type Account struct { Address []byte `json:"address"` PubKey PubKey `json:"pub_key"` Sequence uint `json:"sequence"` Balance uint64 `json:"balance"` Code []byte `json:"code"` // VM code StorageRoot []byte `json:"storage_root"` // VM storage merkle root. } func (acc *Account) Copy() *Account { accCopy := *acc return &accCopy } func (acc *Account) String() string { return fmt.Sprintf("Account{%X:%v C:%v S:%X}", acc.Address, acc.PubKey, len(acc.Code), acc.StorageRoot) } func AccountEncoder(o interface{}, w io.Writer, n *int64, err *error) { binary.WriteBinary(o.(*Account), w, n, err) } func AccountDecoder(r io.Reader, n *int64, err *error) interface{} { return binary.ReadBinary(&Account{}, r, n, err) } var AccountCodec = binary.Codec{ Encode: AccountEncoder, Decode: AccountDecoder, }