func (m *ChangeServerKeyMsg) 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)
data, err = m.IdentityChainID.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
binary.Write(&buf, binary.BigEndian, uint8(m.AdminBlockChange))
binary.Write(&buf, binary.BigEndian, uint8(m.KeyType))
binary.Write(&buf, binary.BigEndian, uint8(m.KeyPriority))
data, err = m.Key.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
return buf.DeepCopyBytes(), nil
}
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
}
// Write out the ABlockHeader to binary.
func (b *ABlockHeader) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
data, err = b.GetAdminChainID().MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
data, err = b.PrevBackRefHash.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
binary.Write(&buf, binary.BigEndian, b.DBHeight)
primitives.EncodeVarInt(&buf, b.HeaderExpansionSize)
buf.Write(b.HeaderExpansionArea)
binary.Write(&buf, binary.BigEndian, b.MessageCount)
binary.Write(&buf, binary.BigEndian, b.BodySize)
return buf.DeepCopyBytes(), err
}
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 *EOM) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
resp, err := m.MarshalForSignature()
if err != nil {
return nil, err
}
buf.Write(resp)
binary.Write(&buf, binary.BigEndian, m.DBHeight)
binary.Write(&buf, binary.BigEndian, m.SysHeight)
if m.SysHash == nil {
m.SysHash = primitives.NewHash(constants.ZERO_HASH)
}
if d, err := m.SysHash.MarshalBinary(); err != nil {
return nil, err
} else {
buf.Write(d)
}
sig := m.GetSignature()
if sig != nil {
sigBytes, err := sig.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(sigBytes)
}
return buf.DeepCopyBytes(), nil
}
func (m *DBStateMsg) 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)
data, err = m.DirectoryBlock.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
data, err = m.AdminBlock.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
data, err = m.FactoidBlock.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
data, err = m.EntryCreditBlock.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
eBlockCount := uint32(len(m.EBlocks))
binary.Write(&buf, binary.BigEndian, eBlockCount)
for _, eb := range m.EBlocks {
bin, err := eb.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(bin)
}
entryCount := uint32(len(m.Entries))
binary.Write(&buf, binary.BigEndian, entryCount)
for _, e := range m.Entries {
bin, err := e.MarshalBinary()
if err != nil || bin == nil || len(bin) == 0 {
return nil, err
}
entrySize := uint32(len(bin))
binary.Write(&buf, binary.BigEndian, entrySize)
buf.Write(bin)
}
return buf.DeepCopyBytes(), nil
}
func (m *Bounce) MarshalForSignature() ([]byte, error) {
var buf primitives.Buffer
binary.Write(&buf, binary.BigEndian, m.Type())
var buff [32]byte
copy(buff[:32], []byte(fmt.Sprintf("%32s", m.Name)))
buf.Write(buff[:])
binary.Write(&buf, binary.BigEndian, m.Number)
t := m.GetTimestamp()
data, err := t.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
binary.Write(&buf, binary.BigEndian, int32(len(m.Stamps)))
for _, ts := range m.Stamps {
data, err := ts.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(data)
}
return buf.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 (e *ECBlockBody) String() string {
var out primitives.Buffer
for _, v := range e.Entries {
out.WriteString(v.String())
}
return string(out.DeepCopyBytes())
}
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 (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 (a *Address) CustomMarshalText() (text []byte, err error) {
var out primitives.Buffer
addr := hex.EncodeToString(a.Bytes())
out.WriteString("addr ")
out.WriteString(addr)
return out.DeepCopyBytes(), nil
}
func (e *Entry) MarshalBinary() ([]byte, error) {
buf := new(primitives.Buffer)
// 1 byte Version
if err := binary.Write(buf, binary.BigEndian, e.Version); err != nil {
return nil, err
}
// 32 byte ChainID
buf.Write(e.ChainID.Bytes())
// ExtIDs
if ext, err := e.MarshalExtIDsBinary(); err != nil {
return nil, err
} else {
// 2 byte size of ExtIDs
if err := binary.Write(buf, binary.BigEndian, int16(len(ext))); err != nil {
return nil, err
}
// binary ExtIDs
buf.Write(ext)
}
// Content
buf.Write(e.Content.Bytes)
return buf.DeepCopyBytes(), nil
}
func (m *EntryBlockResponse) 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)
m.EBlockCount = uint32(len(m.EBlocks))
binary.Write(&buf, binary.BigEndian, m.EBlockCount)
for _, eb := range m.EBlocks {
bin, err := eb.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(bin)
}
m.EntryCount = uint32(len(m.Entries))
binary.Write(&buf, binary.BigEndian, m.EntryCount)
for _, e := range m.Entries {
bin, err := e.MarshalBinary()
if err != nil {
return nil, err
}
buf.Write(bin)
}
return buf.DeepCopyBytes(), nil
}
// This just Marshals what gets signed, i.e. MarshalBinarySig(), then
// Marshals the signatures and the RCDs for this transaction.
func (t Transaction) MarshalBinary() ([]byte, error) {
var out primitives.Buffer
data, err := t.MarshalBinarySig()
if err != nil {
return nil, err
}
out.Write(data)
for i, rcd := range t.RCDs {
// Write the RCD
data, err := rcd.MarshalBinary()
if err != nil {
return nil, err
}
out.Write(data)
// Then write its signature blocks. This needs to be
// reworked so we use the information from the RCD block
// to control the writing of the signatures. After all,
// we don't want to restrict what might be required to
// sign an input.
if len(t.SigBlocks) <= i {
t.SigBlocks = append(t.SigBlocks, new(SignatureBlock))
}
data, err = t.SigBlocks[i].MarshalBinary()
if err != nil {
return nil, err
}
out.Write(data)
}
return out.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
}
// 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
}
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
}
// MilliTime returns a 6 byte slice representing the unix time in milliseconds
func milliTime() (r []byte) {
buf := new(primitives.Buffer)
t := time.Now().UnixNano()
m := t / 1e6
binary.Write(buf, binary.BigEndian, m)
return buf.DeepCopyBytes()[2:]
}
// Write out the AdminBlock to binary.
func (b *AdminBlock) MarshalBinary() ([]byte, error) {
// Marshal all the entries into their own thing (need the size)
var buf2 primitives.Buffer
for _, v := range b.ABEntries {
data, err := v.MarshalBinary()
if err != nil {
return nil, err
}
buf2.Write(data)
}
b.Header.SetMessageCount(uint32(len(b.ABEntries)))
b.Header.SetBodySize(uint32(buf2.Len()))
data, err := b.Header.MarshalBinary()
if err != nil {
return nil, err
}
var buf primitives.Buffer
buf.Write(data)
// Write the Body out
buf.Write(buf2.DeepCopyBytes())
return buf.DeepCopyBytes(), err
}
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
}
func (e *EBlockBody) String() string {
var out primitives.Buffer
for _, eh := range e.EBEntries {
out.WriteString(fmt.Sprintf(" %20s: %x\n", "Entry Hash", eh.Bytes()[:3]))
}
return (string)(out.DeepCopyBytes())
}
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 *AddReplaceMatryoshkaHash) String() string {
var out primitives.Buffer
out.WriteString(fmt.Sprintf(" E: %35s -- %17s %8x %12s %8s\n",
"AddReplaceMatryoshkaHash",
"IdentityChainID", e.IdentityChainID.Bytes()[:4],
"MHash", e.MHash.String()[:8]))
return (string)(out.DeepCopyBytes())
}
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
}
func (s FactoidSignature) CustomMarshalText() ([]byte, error) {
var out primitives.Buffer
out.WriteString(" FactoidSignature: ")
out.WriteString(hex.EncodeToString(s.Signature[:]))
out.WriteString("\n")
return out.DeepCopyBytes(), nil
}
func NewPrivKeyString(n uint64) string {
buf := new(primitives.Buffer)
if err := binary.Write(buf, binary.BigEndian, n); err != nil {
panic(err)
}
priv := fmt.Sprintf("000000000000000000000000000000000000000000000000%x", buf.DeepCopyBytes())
return priv
}
func (e *RevealMatryoshkaHash) MarshalBinary() (data []byte, err error) {
var buf primitives.Buffer
buf.Write([]byte{e.Type()})
buf.Write(e.IdentityChainID.Bytes())
buf.Write(e.MHash.Bytes())
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
}