package state import ( "fmt" "io" . "github.com/tendermint/tendermint/binary" . "github.com/tendermint/tendermint/blocks" . "github.com/tendermint/tendermint/common" "github.com/tendermint/tendermint/crypto" ) const ( AccountStatusNominal = byte(0x00) AccountStatusBonded = byte(0x01) AccountStatusUnbonding = byte(0x02) AccountStatusDupedOut = byte(0x03) ) type Account struct { Id uint64 // Numeric id of account, incrementing. PubKey []byte } func ReadAccount(r io.Reader, n *int64, err *error) Account { return Account{ Id: ReadUInt64(r, n, err), PubKey: ReadByteSlice(r, n, err), } } func (account Account) WriteTo(w io.Writer) (n int64, err error) { WriteUInt64(w, account.Id, &n, &err) WriteByteSlice(w, account.PubKey, &n, &err) return } func (account Account) VerifyBytes(msg []byte, sig Signature) bool { if sig.SignerId != account.Id { panic("account.id doesn't match sig.signerid") } if len(sig.Bytes) == 0 { panic("signature is empty") } v1 := &crypto.Verify{ Message: msg, PubKey: account.PubKey, Signature: sig.Bytes, } ok := crypto.VerifyBatch([]*crypto.Verify{v1}) return ok } func (account Account) Verify(o Signable) bool { sig := o.GetSignature() o.SetSignature(Signature{}) // clear msg := BinaryBytes(o) o.SetSignature(sig) // restore return account.VerifyBytes(msg, sig) } func (account Account) String() string { return fmt.Sprintf("Account{%v:%X}", account.Id, account.PubKey[:6]) } //----------------------------------------------------------------------------- type AccountDetail struct { Account Sequence uint Balance uint64 Status byte } func ReadAccountDetail(r io.Reader, n *int64, err *error) *AccountDetail { return &AccountDetail{ Account: ReadAccount(r, n, err), Sequence: ReadUVarInt(r, n, err), Balance: ReadUInt64(r, n, err), Status: ReadByte(r, n, err), } } func (accDet *AccountDetail) WriteTo(w io.Writer) (n int64, err error) { WriteBinary(w, accDet.Account, &n, &err) WriteUVarInt(w, accDet.Sequence, &n, &err) WriteUInt64(w, accDet.Balance, &n, &err) WriteByte(w, accDet.Status, &n, &err) return } func (accDet *AccountDetail) String() string { return fmt.Sprintf("AccountDetail{%v:%X Sequence:%v Balance:%v Status:%X}", accDet.Id, accDet.PubKey, accDet.Sequence, accDet.Balance, accDet.Status) } func (accDet *AccountDetail) Copy() *AccountDetail { accDetCopy := *accDet return &accDetCopy } //------------------------------------- var AccountDetailCodec = accountDetailCodec{} type accountDetailCodec struct{} func (abc accountDetailCodec) Encode(accDet interface{}, w io.Writer, n *int64, err *error) { WriteBinary(w, accDet.(*AccountDetail), n, err) } func (abc accountDetailCodec) Decode(r io.Reader, n *int64, err *error) interface{} { return ReadAccountDetail(r, n, err) } func (abc accountDetailCodec) Compare(o1 interface{}, o2 interface{}) int { panic("AccountDetailCodec.Compare not implemented") } //----------------------------------------------------------------------------- type PrivAccount struct { Account PrivKey []byte } // Generates a new account with private key. // The Account.Id is empty since it isn't in the blockchain. func GenPrivAccount() *PrivAccount { privKey := CRandBytes(32) pubKey := crypto.MakePubKey(privKey) return &PrivAccount{ Account: Account{ Id: uint64(0), PubKey: pubKey, }, PrivKey: privKey, } } func (pa *PrivAccount) SignBytes(msg []byte) Signature { signature := crypto.SignMessage(msg, pa.PrivKey, pa.PubKey) sig := Signature{ SignerId: pa.Id, Bytes: signature, } return sig } func (pa *PrivAccount) Sign(o Signable) { o.SetSignature(Signature{}) // clear msg := BinaryBytes(o) sig := pa.SignBytes(msg) o.SetSignature(sig) }