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.
244 lines
5.6 KiB
244 lines
5.6 KiB
package blocks
|
|
|
|
import (
|
|
. "github.com/tendermint/tendermint/binary"
|
|
"github.com/tendermint/tendermint/merkle"
|
|
"io"
|
|
)
|
|
|
|
/* BlockData */
|
|
|
|
type BlockData struct {
|
|
Txs []Tx
|
|
}
|
|
|
|
func (self *BlockData) WriteTo(w io.Writer) (n int64, err error) {
|
|
var n_ int64
|
|
for _, tx := range self.Txs {
|
|
n_, err = tx.WriteTo(w)
|
|
n += n_
|
|
if err != nil { return }
|
|
}
|
|
return
|
|
}
|
|
|
|
func (self *BlockData) Hash() ByteSlice {
|
|
bs := make([]Binary, 0, len(self.Txs))
|
|
for i, tx := range self.Txs {
|
|
bs[i] = Binary(tx)
|
|
}
|
|
return merkle.HashFromBinarySlice(bs)
|
|
}
|
|
|
|
func (self *BlockData) AddTx(tx Tx) {
|
|
self.Txs = append(self.Txs, tx)
|
|
}
|
|
|
|
func NewBlockData() *BlockData {
|
|
return &BlockData{}
|
|
}
|
|
|
|
/*
|
|
|
|
Tx wire format:
|
|
|
|
|T|L...|MMM...|A...|SSS...|
|
|
|
|
T type of the tx (1 byte)
|
|
L length of M, varint encoded (1+ bytes)
|
|
M Tx bytes (L bytes)
|
|
A account number, varint encoded (1+ bytes)
|
|
S signature of all prior bytes (32 bytes)
|
|
|
|
*/
|
|
|
|
type Tx interface {
|
|
Binary
|
|
Type() Byte
|
|
}
|
|
|
|
const (
|
|
TX_TYPE_SEND = Byte(0x00)
|
|
TX_TYPE_BOND = Byte(0x11)
|
|
TX_TYPE_UNBOND = Byte(0x12)
|
|
TX_TYPE_NAME = Byte(0x20)
|
|
)
|
|
|
|
/* SendTx < Tx */
|
|
|
|
type SendTx struct {
|
|
Signature
|
|
Fee UInt64
|
|
To AccountId
|
|
Amount UInt64
|
|
}
|
|
|
|
func (self *SendTx) Type() Byte {
|
|
return TX_TYPE_SEND
|
|
}
|
|
|
|
func (self *SendTx) ByteSize() int {
|
|
return 1 +
|
|
self.Signature.ByteSize() +
|
|
self.Fee.ByteSize() +
|
|
self.To.ByteSize() +
|
|
self.Amount.ByteSize()
|
|
}
|
|
|
|
func (self *SendTx) Equals(other Binary) bool {
|
|
if o, ok := other.(*SendTx); ok {
|
|
return self.Signature.Equals(&o.Signature) &&
|
|
self.Fee.Equals(o.Fee) &&
|
|
self.To.Equals(o.To) &&
|
|
self.Amount.Equals(o.Amount)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (self *SendTx) 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.Signature.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.To.WriteTo(w)
|
|
n += n_; if err != nil { return n, err }
|
|
n_, err = self.Amount.WriteTo(w)
|
|
n += n_; return
|
|
}
|
|
|
|
/* BondTx < Tx */
|
|
|
|
type BondTx struct {
|
|
Signature
|
|
Fee UInt64
|
|
UnbondTo AccountId
|
|
Amount UInt64
|
|
}
|
|
|
|
func (self *BondTx) Type() Byte {
|
|
return TX_TYPE_BOND
|
|
}
|
|
|
|
func (self *BondTx) ByteSize() int {
|
|
return 1 +
|
|
self.Signature.ByteSize() +
|
|
self.Fee.ByteSize() +
|
|
self.UnbondTo.ByteSize() +
|
|
self.Amount.ByteSize()
|
|
}
|
|
|
|
func (self *BondTx) Equals(other Binary) bool {
|
|
if o, ok := other.(*BondTx); ok {
|
|
return self.Signature.Equals(&o.Signature) &&
|
|
self.Fee.Equals(o.Fee) &&
|
|
self.UnbondTo.Equals(o.UnbondTo) &&
|
|
self.Amount.Equals(o.Amount)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (self *BondTx) 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.Signature.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_; return
|
|
}
|
|
|
|
/* UnbondTx < Tx */
|
|
|
|
type UnbondTx struct {
|
|
Signature
|
|
Fee UInt64
|
|
Amount UInt64
|
|
}
|
|
|
|
func (self *UnbondTx) Type() Byte {
|
|
return TX_TYPE_UNBOND
|
|
}
|
|
|
|
func (self *UnbondTx) ByteSize() int {
|
|
return 1 +
|
|
self.Signature.ByteSize() +
|
|
self.Fee.ByteSize() +
|
|
self.Amount.ByteSize()
|
|
}
|
|
|
|
func (self *UnbondTx) Equals(other Binary) bool {
|
|
if o, ok := other.(*UnbondTx); ok {
|
|
return self.Signature.Equals(&o.Signature) &&
|
|
self.Fee.Equals(o.Fee) &&
|
|
self.Amount.Equals(o.Amount)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (self *UnbondTx) 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.Signature.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_; return
|
|
}
|
|
|
|
/* NameTx < Tx */
|
|
|
|
type NameTx struct {
|
|
Signature
|
|
Fee UInt64
|
|
Name String
|
|
PubKey ByteSlice
|
|
}
|
|
|
|
func (self *NameTx) Type() Byte {
|
|
return TX_TYPE_NAME
|
|
}
|
|
|
|
func (self *NameTx) ByteSize() int {
|
|
return 1 +
|
|
self.Signature.ByteSize() +
|
|
self.Fee.ByteSize() +
|
|
self.Name.ByteSize() +
|
|
self.PubKey.ByteSize()
|
|
}
|
|
|
|
func (self *NameTx) Equals(other Binary) bool {
|
|
if o, ok := other.(*NameTx); ok {
|
|
return self.Signature.Equals(&o.Signature) &&
|
|
self.Fee.Equals(o.Fee) &&
|
|
self.Name.Equals(o.Name) &&
|
|
self.PubKey.Equals(o.PubKey)
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (self *NameTx) 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.Signature.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.Name.WriteTo(w)
|
|
n += n_; if err != nil { return n, err }
|
|
n_, err = self.PubKey.WriteTo(w)
|
|
n += n_; return
|
|
}
|