func (b *DirectoryBlock) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
b.Sort()
b.BuildBodyMR()
count := uint32(len(b.GetDBEntries()))
b.GetHeader().SetBlockCount(count)
data, err = b.GetHeader().MarshalBinary()
if err != nil {
return
}
buf.Write(data)
for i := uint32(0); i < count; i++ {
data, err = b.GetDBEntries()[i].MarshalBinary()
if err != nil {
return
}
buf.Write(data)
}
return buf.DeepCopyBytes(), err
}
func (m *MissingMsg) MarshalBinary() ([]byte, error) {
var buf primitives.Buffer
binary.Write(&buf, binary.BigEndian, m.Type())
t := m.GetTimestamp()
data, err := t.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
if m.Asking == nil {
m.Asking = primitives.NewHash(constants.ZERO_HASH)
}
data, err = m.Asking.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
buf.WriteByte(uint8(m.VMIndex))
binary.Write(&buf, binary.BigEndian, m.DBHeight)
binary.Write(&buf, binary.BigEndian, m.SystemHeight)
binary.Write(&buf, binary.BigEndian, uint32(len(m.ProcessListHeight)))
for _, h := range m.ProcessListHeight {
binary.Write(&buf, binary.BigEndian, h)
}
bb := buf.DeepCopyBytes()
return bb, nil
}
func (s FactoidSignature) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
out.Write(s.Signature[:])
return out.DeepCopyBytes(), nil
}
func (m *ServerFault) MarshalCore() (data []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Error marshalling Server Fault Core: %v", r)
}
}()
var buf primitives.Buffer
if d, err := m.ServerID.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
if d, err := m.AuditServerID.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
buf.WriteByte(m.VMIndex)
binary.Write(&buf, binary.BigEndian, uint32(m.DBHeight))
binary.Write(&buf, binary.BigEndian, uint32(m.Height))
return buf.DeepCopyBytes(), nil
}
func (a RCD_1) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
out.WriteByte(byte(1)) // The First Authorization method
out.Write(a.PublicKey[:])
return out.DeepCopyBytes(), nil
}
func (e *EndOfMinuteEntry) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{e.Type()})
buf.Write([]byte{e.MinuteNumber})
return buf.DeepCopyBytes(), nil
}
func (e *IncreaseServerCount) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{e.Type()})
buf.Write([]byte{e.Amount})
return buf.DeepCopyBytes(), nil
}
// marshalBodyBinary returns a serialized binary Entry Block Body
func (e *EBlock) marshalBodyBinary() ([]byte, error) {
buf := new(primitives.Buffer)
for _, v := range e.Body.EBEntries {
buf.Write(v.Bytes())
}
return buf.DeepCopyBytes(), nil
}
// Marshal to text. Largely a debugging thing.
func (b FBlock) CustomMarshalText() (text []byte, err error) {
var out primitives.Buffer
out.WriteString("Transaction Block\n")
out.WriteString(" ChainID: ")
out.WriteString(hex.EncodeToString(constants.FACTOID_CHAINID))
keyMR := b.GetKeyMR()
out.WriteString("\n KeyMR (NM): ")
out.WriteString(keyMR.String())
if b.BodyMR == nil {
b.BodyMR = new(primitives.Hash)
}
out.WriteString("\n BodyMR: ")
out.WriteString(b.BodyMR.String())
if b.PrevKeyMR == nil {
b.PrevKeyMR = new(primitives.Hash)
}
out.WriteString("\n PrevKeyMR: ")
out.WriteString(b.PrevKeyMR.String())
if b.PrevLedgerKeyMR == nil {
b.PrevLedgerKeyMR = new(primitives.Hash)
}
out.WriteString("\n PrevLedgerKeyMR: ")
out.WriteString(b.PrevLedgerKeyMR.String())
out.WriteString("\n ExchRate: ")
out.WriteString(fmt.Sprintf("%d.%08d fct, %d factoshis", b.ExchRate/100000000, b.ExchRate%100000000, b.ExchRate))
out.WriteString(fmt.Sprintf("\n DBHeight: %v", b.DBHeight))
out.WriteString("\n Period Marks: ")
for _, mark := range b.endOfPeriod {
out.WriteString(fmt.Sprintf("%d ", mark))
}
out.WriteString("\n #Transactions: ")
primitives.WriteNumber32(&out, uint32(len(b.Transactions)))
transdata, err := b.MarshalTrans()
if err != nil {
return nil, err
}
out.WriteString("\n Body Size: ")
primitives.WriteNumber32(&out, uint32(len(transdata)))
out.WriteString("\n\n")
markPeriod := 0
for i, trans := range b.Transactions {
for markPeriod < 10 && i == b.endOfPeriod[markPeriod] {
out.WriteString(fmt.Sprintf("\n End of Minute %d\n\n", markPeriod+1))
markPeriod++
}
txt, err := trans.CustomMarshalText()
if err != nil {
return nil, err
}
out.Write(txt)
}
return out.DeepCopyBytes(), nil
}
func (m *FactoidTransaction) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{m.Type()})
if d, err := m.Transaction.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
return buf.DeepCopyBytes(), nil
}
// MarshalBinary. 'nuff said
func (a TransAddress) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
err := primitives.EncodeVarInt(&out, a.Amount)
if err != nil {
return nil, err
}
data, err := a.Address.MarshalBinary()
out.Write(data)
return out.DeepCopyBytes(), err
}
func (b *IncreaseBalance) MarshalBinary() ([]byte, error) {
buf := new(primitives.Buffer)
buf.Write(b.ECPubKey[:])
buf.Write(b.TXID.Bytes())
primitives.EncodeVarInt(buf, b.Index)
primitives.EncodeVarInt(buf, b.NumEC)
return buf.DeepCopyBytes(), nil
}
func (m *RequestBlock) MarshalForSignature() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{m.Type()})
if d, err := m.Timestamp.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
//TODO: expand
return buf.DeepCopyBytes(), nil
}
func (e *RemoveFederatedServer) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{e.Type()})
data, err = e.IdentityChainID.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
binary.Write(&buf, binary.BigEndian, e.DBHeight)
return buf.DeepCopyBytes(), nil
}
func (m *CommitEntryMsg) MarshalForSignature() (data []byte, err error) {
var buf primitives.Buffer
binary.Write(&buf, binary.BigEndian, m.Type())
data, err = m.CommitEntry.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
return buf.DeepCopyBytes(), nil
}
// Marshal to text. Largely a debugging thing.
func (t *Transaction) CustomMarshalText() (text []byte, err error) {
data, err := t.MarshalBinary()
if err != nil {
return nil, err
}
var out primitives.Buffer
out.WriteString(fmt.Sprintf("Transaction (size %d):\n", len(data)))
out.WriteString(" Version: ")
primitives.WriteNumber64(&out, uint64(t.GetVersion()))
out.WriteString("\n MilliTimestamp: ")
primitives.WriteNumber64(&out, uint64(t.MilliTimestamp))
ts := time.Unix(0, int64(t.MilliTimestamp*1000000))
out.WriteString(ts.UTC().Format(" Jan 2, 2006 at 15:04:05 (MST)"))
out.WriteString("\n # Inputs: ")
primitives.WriteNumber16(&out, uint16(len(t.Inputs)))
out.WriteString("\n # Outputs: ")
primitives.WriteNumber16(&out, uint16(len(t.Outputs)))
out.WriteString("\n # EntryCredit Outputs: ")
primitives.WriteNumber16(&out, uint16(len(t.OutECs)))
out.WriteString("\n")
for _, address := range t.Inputs {
text, _ := address.CustomMarshalText()
out.Write(text)
}
for _, address := range t.Outputs {
text, _ := address.CustomMarshalText()
out.Write(text)
}
for _, ecaddress := range t.OutECs {
text, _ := ecaddress.CustomMarshalText()
out.Write(text)
}
for i, rcd := range t.RCDs {
text, err = rcd.CustomMarshalText()
if err != nil {
return nil, err
}
out.Write(text)
for len(t.SigBlocks) <= i {
t.SigBlocks = append(t.SigBlocks, new(SignatureBlock))
}
text, err := t.SigBlocks[i].CustomMarshalText()
if err != nil {
return nil, err
}
out.Write(text)
}
return out.DeepCopyBytes(), nil
}
func (m *ServerFault) PreMarshalBinary() (data []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Error marshalling Invalid Server Fault: %v", r)
}
}()
var buf primitives.Buffer
buf.Write([]byte{m.Type()})
if d, err := m.ServerID.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
if d, err := m.AuditServerID.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
buf.WriteByte(m.VMIndex)
binary.Write(&buf, binary.BigEndian, uint32(m.DBHeight))
binary.Write(&buf, binary.BigEndian, uint32(m.Height))
binary.Write(&buf, binary.BigEndian, uint32(m.SystemHeight))
if d, err := m.Timestamp.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
return buf.DeepCopyBytes(), nil
}
func (e *ECBlock) marshalBodyBinary() ([]byte, error) {
buf := new(primitives.Buffer)
for _, v := range e.GetBody().GetEntries() {
p, err := v.MarshalBinary()
if err != nil {
return buf.Bytes(), err
}
buf.WriteByte(v.ECID())
buf.Write(p)
}
return buf.DeepCopyBytes(), nil
}
func (m *DataResponse) MarshalBinary() ([]byte, error) {
var buf primitives.Buffer
buf.Write([]byte{m.Type()})
if d, err := m.Timestamp.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
binary.Write(&buf, binary.BigEndian, uint8(m.DataType))
if d, err := m.DataHash.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
if m.DataObject != nil {
d, err := m.DataObject.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(d)
}
return buf.DeepCopyBytes(), nil
}
func (a SignatureBlock) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
for _, sig := range a.GetSignatures() {
data, err := sig.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("Signature failed to Marshal in RCD_1")
}
out.Write(data)
}
return out.DeepCopyBytes(), nil
}
func (c *CommitChain) MarshalBinarySig() ([]byte, error) {
buf := new(primitives.Buffer)
// 1 byte Version
if err := binary.Write(buf, binary.BigEndian, c.Version); err != nil {
return nil, err
}
// 6 byte MilliTime
buf.Write(c.MilliTime[:])
// 32 byte double sha256 hash of the ChainID
buf.Write(c.ChainIDHash.Bytes())
// 32 byte Commit Weld sha256(sha256(Entry Hash + ChainID))
buf.Write(c.Weld.Bytes())
// 32 byte Entry Hash
buf.Write(c.EntryHash.Bytes())
// 1 byte number of Entry Credits
if err := binary.Write(buf, binary.BigEndian, c.Credits); err != nil {
return nil, err
}
return buf.DeepCopyBytes(), nil
}
func (m *Heartbeat) MarshalForSignature() (data []byte, err error) {
if m.DBlockHash == nil || m.IdentityChainID == nil {
return nil, fmt.Errorf("Message is incomplete")
}
var buf primitives.Buffer
buf.Write([]byte{m.Type()})
if d, err := m.Timestamp.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
binary.Write(&buf, binary.BigEndian, m.SecretNumber)
if d, err := m.DBlockHash.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
if d, err := m.IdentityChainID.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
return buf.DeepCopyBytes(), nil
}
// marshalHeaderBinary returns a serialized binary Entry Block Header
func (e *EBlockHeader) MarshalBinary() ([]byte, error) {
buf := new(primitives.Buffer)
// 32 byte ChainID
buf.Write(e.ChainID.Bytes())
// 32 byte Body MR
buf.Write(e.BodyMR.Bytes())
// 32 byte Previous Key MR
buf.Write(e.PrevKeyMR.Bytes())
// 32 byte Previous Full Hash
buf.Write(e.PrevFullHash.Bytes())
if err := binary.Write(buf, binary.BigEndian, e.EBSequence); err != nil {
return nil, err
}
if err := binary.Write(buf, binary.BigEndian, e.DBHeight); err != nil {
return nil, err
}
if err := binary.Write(buf, binary.BigEndian, e.EntryCount); err != nil {
return nil, err
}
return buf.DeepCopyBytes(), nil
}
// MarshalExtIDsBinary marshals the ExtIDs into a []byte containing a series of
// 2 byte size of each ExtID followed by the ExtID.
func (e *Entry) MarshalExtIDsBinary() ([]byte, error) {
buf := new(primitives.Buffer)
for _, x := range e.ExtIDs {
// 2 byte size of the ExtID
if err := binary.Write(buf, binary.BigEndian, uint16(len(x.Bytes))); err != nil {
return nil, err
}
// ExtID bytes
buf.Write(x.Bytes)
}
return buf.DeepCopyBytes(), nil
}
func (sl *SigList) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
binary.Write(&buf, binary.BigEndian, uint32(sl.Length))
for _, individualSig := range sl.List {
if d, err := individualSig.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
}
return buf.DeepCopyBytes(), nil
}
func (a RCD_2) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
binary.Write(&out, binary.BigEndian, uint8(2))
binary.Write(&out, binary.BigEndian, uint16(a.N))
binary.Write(&out, binary.BigEndian, uint16(a.M))
for i := 0; i < a.M; i++ {
data, err := a.N_Addresses[i].MarshalBinary()
if err != nil {
return nil, err
}
out.Write(data)
}
return out.DeepCopyBytes(), nil
}
// Transaction hash of chain commit. (version through pub key hashed)
func (c *CommitChain) MarshalBinaryTransaction() ([]byte, error) {
buf := new(primitives.Buffer)
b, err := c.MarshalBinarySig()
if err != nil {
return nil, err
}
buf.Write(b)
// 32 byte Public Key
buf.Write(c.ECPubKey[:])
return buf.DeepCopyBytes(), nil
}
// Write out the block
func (b *FBlock) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
data, err := b.MarshalHeader()
if err != nil {
return nil, err
}
out.Write(data)
transdata, err := b.MarshalTrans() // first get trans data
if err != nil {
return nil, err
}
out.Write(transdata) // write out trans data
return out.DeepCopyBytes(), nil
}
func (m *DBStateMissing) MarshalForSignature() ([]byte, error) {
var buf primitives.Buffer
binary.Write(&buf, binary.BigEndian, m.Type())
t := m.GetTimestamp()
data, err := t.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
binary.Write(&buf, binary.BigEndian, m.DBHeightStart)
binary.Write(&buf, binary.BigEndian, m.DBHeightEnd)
return buf.DeepCopyBytes(), nil
}
func (s SignatureBlock) CustomMarshalText() ([]byte, error) {
var out primitives.Buffer
out.WriteString("Signature Block: \n")
for _, sig := range s.Signatures {
out.WriteString(" signature: ")
txt, err := sig.CustomMarshalText()
if err != nil {
return nil, err
}
out.Write(txt)
out.WriteString("\n ")
}
return out.DeepCopyBytes(), nil
}