func NewCommitChain(eBlock *entryBlock.EBlock) *entryCreditBlock.CommitChain {
commit := entryCreditBlock.NewCommitChain()
commit.Version = 1
err := commit.MilliTime.UnmarshalBinary([]byte{0, 0, 0, 0, 0, byte(eBlock.GetHeader().GetDBHeight())})
if err != nil {
panic(err)
}
commit.ChainIDHash = eBlock.GetHashOfChainIDHash()
commit.Weld = eBlock.GetWeldHashes()[0]
commit.EntryHash = eBlock.Body.EBEntries[0]
bin, err := commit.MarshalBinary()
if err != nil {
panic(err)
}
cost, err := util.EntryCost(bin)
if err != nil {
panic(err)
}
commit.Credits = cost
SignCommit(0, commit)
return commit
}
func getEntry(hash string) *EntryHolder {
entryHash, err := primitives.HexToHash(hash)
if err != nil {
return nil
}
dbase := StatePointer.GetAndLockDB()
entry, err := dbase.FetchEntry(entryHash)
StatePointer.UnlockDB()
if err != nil {
return nil
}
if entry == nil {
return nil
}
holder := new(EntryHolder)
holder.Hash = hash
holder.ChainID = entry.GetChainID().String()
max := byte(0x80)
for _, data := range entry.ExternalIDs() {
hexString := false
for _, bytes := range data {
if bytes > max {
hexString = true
break
}
}
if hexString {
str := hex.EncodeToString(data)
holder.ExtIDs = append(holder.ExtIDs[:], "<span id='encoding'><a>Hex : </a></span><span id='data'>"+htemp.HTMLEscaper(str)+"</span>")
} else {
str := string(data)
holder.ExtIDs = append(holder.ExtIDs[:], "<span id='encoding'><a>Ascii: </a></span><span id='data'>"+htemp.HTMLEscaper(str)+"</span>")
}
}
holder.Version = 0
holder.Height = fmt.Sprintf("%d", entry.GetDatabaseHeight())
holder.ContentLength = len(entry.GetContent())
data := sha256.Sum256(entry.GetContent())
content := string(entry.GetContent())
holder.Content = htemp.HTMLEscaper(content)
if bytes, err := entry.MarshalBinary(); err != nil {
holder.ECCost = "Error"
} else {
if eccost, err := util.EntryCost(bytes); err != nil {
holder.ECCost = "Error"
} else {
holder.ECCost = fmt.Sprintf("%d", eccost)
}
}
//holder.Content = string(entry.GetContent())
holder.ContentHash = primitives.NewHash(data[:]).String()
return holder
}
//Construct the entry and submit it to the server
func (a *Anchor) submitEntryToAnchorChain(aRecord *AnchorRecord) error {
jsonARecord, err := json.Marshal(aRecord)
//anchorLog.Debug("submitEntryToAnchorChain - jsonARecord: ", string(jsonARecord))
if err != nil {
return err
}
bufARecord := new(primitives.Buffer)
bufARecord.Write(jsonARecord)
aRecordSig := a.serverPrivKey.Sign(jsonARecord)
//Create a new entry
entry := entryBlock.NewEntry()
entry.ChainID = a.anchorChainID
anchorLog.Debug("anchorChainID: ", a.anchorChainID)
// instead of append signature at the end of anchor record
// it can be added as the first entry.ExtIDs[0]
entry.ExtIDs = append(entry.ExtIDs, primitives.ByteSlice{Bytes: aRecordSig.Bytes()})
entry.Content = primitives.ByteSlice{Bytes: bufARecord.DeepCopyBytes()}
//anchorLog.Debug("entry: ", spew.Sdump(entry))
buf := new(primitives.Buffer)
// 1 byte version
buf.Write([]byte{0})
// 6 byte milliTimestamp (truncated unix time)
buf.Write(milliTime())
// 32 byte Entry Hash
buf.Write(entry.GetHash().Bytes())
// 1 byte number of entry credits to pay
binaryEntry, err := entry.MarshalBinary()
if err != nil {
return err
}
anchorLog.Debug("jsonARecord binary entry: ", hex.EncodeToString(binaryEntry))
if c, err := util.EntryCost(binaryEntry); err == nil {
buf.WriteByte(byte(c))
} else {
return err
}
tmp := buf.DeepCopyBytes()
sig := a.serverECKey.Sign(tmp).(*primitives.Signature)
buf = primitives.NewBuffer(tmp)
buf.Write(a.serverECKey.Pub[:])
buf.Write(sig.Sig[:])
commit := entryCreditBlock.NewCommitEntry()
err = commit.UnmarshalBinary(buf.DeepCopyBytes())
if err != nil {
return err
}
// create a CommitEntry msg and send it to the local inmsgQ
cm := messages.NewCommitEntryMsg()
cm.CommitEntry = commit
a.state.InMsgQueue() <- cm
// create a RevealEntry msg and send it to the local inmsgQ
rm := messages.NewRevealEntryMsg()
rm.Entry = entry
a.state.InMsgQueue() <- rm
return nil
}