mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-09-27 10:24:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated readme, implementing mempool.

Browse Source
This commit is contained in:
Jae Kwon
2014-09-10 02:43:16 -07:00
parent 6c3579e753
commit 4c961bd565
7 changed files with 229 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files
blocks/adjustment.go
-166
View File
@@ -1,166 +0,0 @@
package blocks
import (
. "github.com/tendermint/tendermint/binary"
. "github.com/tendermint/tendermint/common"
"io"
)
/* Adjustment
1. Bond New validator posts a bond
2. Unbond Validator leaves
3. Timeout Validator times out
4. Dupeout Validator dupes out (signs twice)
TODO: signing a bad checkpoint (block)
*/
type Adjustment interface {
Type() byte
Binary
}
const (
ADJ_TYPE_BOND = byte(0x01)
ADJ_TYPE_UNBOND = byte(0x02)
ADJ_TYPE_TIMEOUT = byte(0x03)
ADJ_TYPE_DUPEOUT = byte(0x04)
)
func ReadAdjustment(r io.Reader, n *int64, err *error) Adjustment {
switch t := ReadByte(r, n, err); t {
case ADJ_TYPE_BOND:
return &Bond{
Fee: ReadUInt64(r, n, err),
UnbondTo: ReadUInt64(r, n, err),
Amount: ReadUInt64(r, n, err),
Signature: ReadSignature(r, n, err),
}
case ADJ_TYPE_UNBOND:
return &Unbond{
Fee: ReadUInt64(r, n, err),
Amount: ReadUInt64(r, n, err),
Signature: ReadSignature(r, n, err),
}
case ADJ_TYPE_TIMEOUT:
return &Timeout{
AccountId: ReadUInt64(r, n, err),
Penalty: ReadUInt64(r, n, err),
}
case ADJ_TYPE_DUPEOUT:
return &Dupeout{
VoteA: ReadBlockVote(r, n, err),
VoteB: ReadBlockVote(r, n, err),
}
default:
Panicf("Unknown Adjustment type %x", t)
return nil
}
}
//-----------------------------------------------------------------------------
/* Bond < Adjustment */
type Bond struct {
Fee uint64
UnbondTo uint64
Amount uint64
Signature
}
func (self *Bond) Type() byte {
return ADJ_TYPE_BOND
}
func (self *Bond) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.Fee, &n, &err)
WriteUInt64(w, self.UnbondTo, &n, &err)
WriteUInt64(w, self.Amount, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
/* Unbond < Adjustment */
type Unbond struct {
Fee uint64
Amount uint64
Signature
}
func (self *Unbond) Type() byte {
return ADJ_TYPE_UNBOND
}
func (self *Unbond) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.Fee, &n, &err)
WriteUInt64(w, self.Amount, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
/* Timeout < Adjustment */
type Timeout struct {
AccountId uint64
Penalty uint64
}
func (self *Timeout) Type() byte {
return ADJ_TYPE_TIMEOUT
}
func (self *Timeout) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.AccountId, &n, &err)
WriteUInt64(w, self.Penalty, &n, &err)
return
}
//-----------------------------------------------------------------------------
/*
The full vote structure is only needed when presented as evidence.
Typically only the signature is passed around, as the hash & height are implied.
*/
type BlockVote struct {
Height uint64
BlockHash []byte
Signature
}
func ReadBlockVote(r io.Reader, n *int64, err *error) BlockVote {
return BlockVote{
Height: ReadUInt64(r, n, err),
BlockHash: ReadByteSlice(r, n, err),
Signature: ReadSignature(r, n, err),
}
}
func (self BlockVote) WriteTo(w io.Writer) (n int64, err error) {
WriteUInt64(w, self.Height, &n, &err)
WriteByteSlice(w, self.BlockHash, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
/* Dupeout < Adjustment */
type Dupeout struct {
VoteA BlockVote
VoteB BlockVote
}
func (self *Dupeout) Type() byte {
return ADJ_TYPE_DUPEOUT
}
func (self *Dupeout) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteBinary(w, self.VoteA, &n, &err)
WriteBinary(w, self.VoteB, &n, &err)
return
}
blocks/block.go
+9 -9
View File
@@ -189,8 +189,8 @@ func (h *Header) Hash() []byte {
/* Validation is part of a block */
type Validation struct {
Signatures []Signature
Adjustments []Adjustment
Signatures []Signature
Txs []Tx
// Volatile
hash []byte
@@ -203,24 +203,24 @@ func ReadValidation(r io.Reader, n *int64, err *error) Validation {
for i := uint32(0); i < numSigs; i++ {
sigs = append(sigs, ReadSignature(r, n, err))
}
adjs := make([]Adjustment, 0, numAdjs)
tx := make([]Tx, 0, numAdjs)
for i := uint32(0); i < numAdjs; i++ {
adjs = append(adjs, ReadAdjustment(r, n, err))
tx = append(tx, ReadTx(r, n, err))
}
return Validation{
Signatures: sigs,
Adjustments: adjs,
Signatures: sigs,
Txs: tx,
}
}
func (v *Validation) WriteTo(w io.Writer) (n int64, err error) {
WriteUInt32(w, uint32(len(v.Signatures)), &n, &err)
WriteUInt32(w, uint32(len(v.Adjustments)), &n, &err)
WriteUInt32(w, uint32(len(v.Txs)), &n, &err)
for _, sig := range v.Signatures {
WriteBinary(w, sig, &n, &err)
}
for _, adj := range v.Adjustments {
WriteBinary(w, adj, &n, &err)
for _, tx := range v.Txs {
WriteBinary(w, tx, &n, &err)
}
return
}
blocks/block_test.go
+4 -4
View File
@@ -47,7 +47,7 @@ func randSig() Signature {
func TestBlock(t *testing.T) {
// Txs
// Account Txs
sendTx := &SendTx{
Signature: randSig(),
@@ -63,7 +63,7 @@ func TestBlock(t *testing.T) {
PubKey: randBytes(32),
}
// Adjs
// Consensus Txs
bond := &Bond{
Signature: randSig(),
@@ -109,8 +109,8 @@ func TestBlock(t *testing.T) {
TxsHash: randBytes(32),
},
Validation: Validation{
Signatures: []Signature{randSig(), randSig()},
Adjustments: []Adjustment{bond, unbond, timeout, dupeout},
Signatures: []Signature{randSig(), randSig()},
Txs: []Txs{bond, unbond, timeout, dupeout},
},
Txs: Txs{
Txs: []Tx{sendTx, nameTx},
blocks/tx.go
+149 -2
View File
@@ -18,16 +18,35 @@ Tx wire format:
A account number, varint encoded (1+ bytes)
S signature of all prior bytes (32 bytes)
Account Txs:
1. Send Send coins to account
2. Name Associate account with a name
Consensus Txs:
3. Bond New validator posts a bond
4. Unbond Validator leaves
5. Timeout Validator times out
6. Dupeout Validator dupes out (signs twice)
*/
type Tx interface {
Type() byte
IsConsensus() bool
Binary
}
const (
// Account transactions
TX_TYPE_SEND = byte(0x01)
TX_TYPE_NAME = byte(0x02)
// Consensus transactions
TX_TYPE_BOND = byte(0x11)
TX_TYPE_UNBOND = byte(0x12)
TX_TYPE_TIMEOUT = byte(0x13)
TX_TYPE_DUPEOUT = byte(0x14)
)
func ReadTx(r io.Reader, n *int64, err *error) Tx {
@@ -46,13 +65,36 @@ func ReadTx(r io.Reader, n *int64, err *error) Tx {
PubKey: ReadByteSlice(r, n, err),
Signature: ReadSignature(r, n, err),
}
case TX_TYPE_BOND:
return &BondTx{
Fee: ReadUInt64(r, n, err),
UnbondTo: ReadUInt64(r, n, err),
Amount: ReadUInt64(r, n, err),
Signature: ReadSignature(r, n, err),
}
case TX_TYPE_UNBOND:
return &UnbondTx{
Fee: ReadUInt64(r, n, err),
Amount: ReadUInt64(r, n, err),
Signature: ReadSignature(r, n, err),
}
case TX_TYPE_TIMEOUT:
return &TimeoutTx{
AccountId: ReadUInt64(r, n, err),
Penalty: ReadUInt64(r, n, err),
}
case TX_TYPE_DUPEOUT:
return &DupeoutTx{
VoteA: ReadBlockVote(r, n, err),
VoteB: ReadBlockVote(r, n, err),
}
default:
Panicf("Unknown Tx type %x", t)
return nil
}
}
/* SendTx < Tx */
//-----------------------------------------------------------------------------
type SendTx struct {
Fee uint64
@@ -74,7 +116,7 @@ func (self *SendTx) WriteTo(w io.Writer) (n int64, err error) {
return
}
/* NameTx < Tx */
//-----------------------------------------------------------------------------
type NameTx struct {
Fee uint64
@@ -95,3 +137,108 @@ func (self *NameTx) WriteTo(w io.Writer) (n int64, err error) {
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
type BondTx struct {
Fee uint64
UnbondTo uint64
Amount uint64
Signature
}
func (self *BondTx) Type() byte {
return TX_TYPE_BOND
}
func (self *BondTx) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.Fee, &n, &err)
WriteUInt64(w, self.UnbondTo, &n, &err)
WriteUInt64(w, self.Amount, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
type UnbondTx struct {
Fee uint64
Amount uint64
Signature
}
func (self *UnbondTx) Type() byte {
return TX_TYPE_UNBOND
}
func (self *UnbondTx) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.Fee, &n, &err)
WriteUInt64(w, self.Amount, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
type TimeoutTx struct {
AccountId uint64
Penalty uint64
}
func (self *TimeoutTx) Type() byte {
return TX_TYPE_TIMEOUT
}
func (self *TimeoutTx) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteUInt64(w, self.AccountId, &n, &err)
WriteUInt64(w, self.Penalty, &n, &err)
return
}
//-----------------------------------------------------------------------------
/*
The full vote structure is only needed when presented as evidence.
Typically only the signature is passed around, as the hash & height are implied.
*/
type BlockVote struct {
Height uint64
BlockHash []byte
Signature
}
func ReadBlockVote(r io.Reader, n *int64, err *error) BlockVote {
return BlockVote{
Height: ReadUInt64(r, n, err),
BlockHash: ReadByteSlice(r, n, err),
Signature: ReadSignature(r, n, err),
}
}
func (self BlockVote) WriteTo(w io.Writer) (n int64, err error) {
WriteUInt64(w, self.Height, &n, &err)
WriteByteSlice(w, self.BlockHash, &n, &err)
WriteBinary(w, self.Signature, &n, &err)
return
}
//-----------------------------------------------------------------------------
type DupeoutTx struct {
VoteA BlockVote
VoteB BlockVote
}
func (self *DupeoutTx) Type() byte {
return TX_TYPE_DUPEOUT
}
func (self *DupeoutTx) WriteTo(w io.Writer) (n int64, err error) {
WriteByte(w, self.Type(), &n, &err)
WriteBinary(w, self.VoteA, &n, &err)
WriteBinary(w, self.VoteB, &n, &err)
return
}