You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
210 lines
4.4 KiB
210 lines
4.4 KiB
package blocks
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
|
|
. "github.com/tendermint/tendermint/binary"
|
|
. "github.com/tendermint/tendermint/common"
|
|
)
|
|
|
|
/*
|
|
Account Txs:
|
|
1. Send Send coins to account
|
|
2. Name Associate account with a name
|
|
|
|
Validation Txs:
|
|
3. Bond New validator posts a bond
|
|
4. Unbond Validator leaves
|
|
5. Dupeout Validator dupes out (signs twice)
|
|
*/
|
|
|
|
type Tx interface {
|
|
Signable
|
|
GetSequence() uint
|
|
GetFee() uint64
|
|
String() string
|
|
}
|
|
|
|
const (
|
|
// Account transactions
|
|
TxTypeSend = byte(0x01)
|
|
TxTypeName = byte(0x02)
|
|
|
|
// Validation transactions
|
|
TxTypeBond = byte(0x11)
|
|
TxTypeUnbond = byte(0x12)
|
|
TxTypeDupeout = byte(0x13)
|
|
)
|
|
|
|
func ReadTx(r io.Reader, n *int64, err *error) Tx {
|
|
switch t := ReadByte(r, n, err); t {
|
|
case TxTypeSend:
|
|
return &SendTx{
|
|
BaseTx: ReadBaseTx(r, n, err),
|
|
To: ReadUInt64(r, n, err),
|
|
Amount: ReadUInt64(r, n, err),
|
|
}
|
|
case TxTypeName:
|
|
return &NameTx{
|
|
BaseTx: ReadBaseTx(r, n, err),
|
|
Name: ReadString(r, n, err),
|
|
PubKey: ReadByteSlice(r, n, err),
|
|
}
|
|
case TxTypeBond:
|
|
return &BondTx{
|
|
BaseTx: ReadBaseTx(r, n, err),
|
|
//UnbondTo: ReadUInt64(r, n, err),
|
|
}
|
|
case TxTypeUnbond:
|
|
return &UnbondTx{
|
|
BaseTx: ReadBaseTx(r, n, err),
|
|
}
|
|
case TxTypeDupeout:
|
|
return &DupeoutTx{
|
|
BaseTx: ReadBaseTx(r, n, err),
|
|
VoteA: *ReadVote(r, n, err),
|
|
VoteB: *ReadVote(r, n, err),
|
|
}
|
|
default:
|
|
*err = Errorf("Unknown Tx type %X", t)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type BaseTx struct {
|
|
Sequence uint
|
|
Fee uint64
|
|
Signature
|
|
}
|
|
|
|
func ReadBaseTx(r io.Reader, n *int64, err *error) BaseTx {
|
|
return BaseTx{
|
|
Sequence: ReadUVarInt(r, n, err),
|
|
Fee: ReadUInt64(r, n, err),
|
|
Signature: ReadSignature(r, n, err),
|
|
}
|
|
}
|
|
|
|
func (tx BaseTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteUVarInt(w, tx.Sequence, &n, &err)
|
|
WriteUInt64(w, tx.Fee, &n, &err)
|
|
WriteBinary(w, tx.Signature, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *BaseTx) GetSequence() uint {
|
|
return tx.Sequence
|
|
}
|
|
|
|
func (tx *BaseTx) GetSignature() Signature {
|
|
return tx.Signature
|
|
}
|
|
|
|
func (tx *BaseTx) GetFee() uint64 {
|
|
return tx.Fee
|
|
}
|
|
|
|
func (tx *BaseTx) SetSignature(sig Signature) {
|
|
tx.Signature = sig
|
|
}
|
|
|
|
func (tx *BaseTx) String() string {
|
|
return fmt.Sprintf("{S:%v F:%v Sig:%X}", tx.Sequence, tx.Fee, tx.Signature)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type SendTx struct {
|
|
BaseTx
|
|
To uint64
|
|
Amount uint64
|
|
}
|
|
|
|
func (tx *SendTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteByte(w, TxTypeSend, &n, &err)
|
|
WriteBinary(w, tx.BaseTx, &n, &err)
|
|
WriteUInt64(w, tx.To, &n, &err)
|
|
WriteUInt64(w, tx.Amount, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *SendTx) String() string {
|
|
return fmt.Sprintf("SendTx{%v To:%v Amount:%v}", tx.BaseTx, tx.To, tx.Amount)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type NameTx struct {
|
|
BaseTx
|
|
Name string
|
|
PubKey []byte
|
|
}
|
|
|
|
func (tx *NameTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteByte(w, TxTypeName, &n, &err)
|
|
WriteBinary(w, tx.BaseTx, &n, &err)
|
|
WriteString(w, tx.Name, &n, &err)
|
|
WriteByteSlice(w, tx.PubKey, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *NameTx) String() string {
|
|
return fmt.Sprintf("NameTx{%v Name:%v PubKey:%X}", tx.BaseTx, tx.Name, tx.PubKey)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type BondTx struct {
|
|
BaseTx
|
|
//UnbondTo uint64
|
|
}
|
|
|
|
func (tx *BondTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteByte(w, TxTypeBond, &n, &err)
|
|
WriteBinary(w, tx.BaseTx, &n, &err)
|
|
//WriteUInt64(w, tx.UnbondTo, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *BondTx) String() string {
|
|
return fmt.Sprintf("BondTx{%v}", tx.BaseTx)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type UnbondTx struct {
|
|
BaseTx
|
|
}
|
|
|
|
func (tx *UnbondTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteByte(w, TxTypeUnbond, &n, &err)
|
|
WriteBinary(w, tx.BaseTx, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *UnbondTx) String() string {
|
|
return fmt.Sprintf("UnbondTx{%v}", tx.BaseTx)
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type DupeoutTx struct {
|
|
BaseTx
|
|
VoteA Vote
|
|
VoteB Vote
|
|
}
|
|
|
|
func (tx *DupeoutTx) WriteTo(w io.Writer) (n int64, err error) {
|
|
WriteByte(w, TxTypeDupeout, &n, &err)
|
|
WriteBinary(w, tx.BaseTx, &n, &err)
|
|
WriteBinary(w, &tx.VoteA, &n, &err)
|
|
WriteBinary(w, &tx.VoteB, &n, &err)
|
|
return
|
|
}
|
|
|
|
func (tx *DupeoutTx) String() string {
|
|
return fmt.Sprintf("DupeoutTx{%v VoteA:%v VoteB:%v}", tx.BaseTx, tx.VoteA, tx.VoteB)
|
|
}
|