tendermint/blocks/adjustment.go

package blocks

import (
    . "github.com/tendermint/tendermint/binary"
    "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) Adjustment {
    switch t := ReadByte(r); t {
    case ADJ_TYPE_BOND:
        return &Bond{
            Fee:        ReadUInt64(r),
            UnbondTo:   ReadAccountId(r),
            Amount:     ReadUInt64(r),
            Signature:  ReadSignature(r),
        }
    case ADJ_TYPE_UNBOND:
        return &Unbond{
            Fee:        ReadUInt64(r),
            Amount:     ReadUInt64(r),
            Signature:  ReadSignature(r),
        }
    case ADJ_TYPE_TIMEOUT:
        return &Timeout{
            Account:    ReadAccountId(r),
            Penalty:    ReadUInt64(r),
        }
    case ADJ_TYPE_DUPEOUT:
        return &Dupeout{
            VoteA:      ReadVote(r),
            VoteB:      ReadVote(r),
        }
    default:
        panicf("Unknown Adjustment type %x", t)
        return nil
    }
}


/* Bond < Adjustment */

type Bond struct {
    Fee             UInt64
    UnbondTo        AccountId
    Amount          UInt64
    Signature
}

func (self *Bond) Type() Byte {
    return ADJ_TYPE_BOND
}

func (self *Bond) WriteTo(w io.Writer) (n int64, err error) {
    var n_ int64
    n_, err = self.Type().WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Fee.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.UnbondTo.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Amount.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Signature.WriteTo(w)
    n += n_; 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) {
    var n_ int64
    n_, err = self.Type().WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Fee.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Amount.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Signature.WriteTo(w)
    n += n_; return
}


/* Timeout < Adjustment */

type Timeout struct {
    Account         AccountId
    Penalty         UInt64
}

func (self *Timeout) Type() Byte {
    return ADJ_TYPE_TIMEOUT
}

func (self *Timeout) WriteTo(w io.Writer) (n int64, err error) {
    var n_ int64
    n_, err = self.Type().WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Account.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.Penalty.WriteTo(w)
    n += n_; return
}


/* Dupeout < Adjustment */

type Dupeout struct {
    VoteA           Vote
    VoteB           Vote
}

func (self *Dupeout) Type() Byte {
    return ADJ_TYPE_DUPEOUT
}

func (self *Dupeout) WriteTo(w io.Writer) (n int64, err error) {
    var n_ int64
    n_, err = self.VoteA.WriteTo(w)
    n += n_; if err != nil { return n, err }
    n_, err = self.VoteB.WriteTo(w)
    n += n_; return
}