func HandleV2CommitEntry(state interfaces.IState, params interface{}) (interface{}, *primitives.JSONError) {
commitEntryMsg := new(EntryRequest)
err := MapToObject(params, commitEntryMsg)
if err != nil {
return nil, NewInvalidParamsError()
}
commit := entryCreditBlock.NewCommitEntry()
if p, err := hex.DecodeString(commitEntryMsg.Entry); err != nil {
return nil, NewInvalidCommitEntryError()
} else {
_, err := commit.UnmarshalBinaryData(p)
if err != nil {
return nil, NewInvalidCommitEntryError()
}
}
msg := new(messages.CommitEntryMsg)
msg.CommitEntry = commit
state.APIQueue() <- msg
state.IncECommits()
resp := new(CommitEntryResponse)
resp.Message = "Entry Commit Success"
resp.TxID = commit.GetSigHash().String()
return resp, nil
}
func (m *CommitEntryMsg) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Error unmarshalling Commit entry Message: %v", r)
}
}()
newData = data
if newData[0] != m.Type() {
return nil, fmt.Errorf("Invalid Message type")
}
newData = newData[1:]
ce := entryCreditBlock.NewCommitEntry()
newData, err = ce.UnmarshalBinaryData(newData)
if err != nil {
return nil, err
}
m.CommitEntry = ce
if len(newData) > 0 {
m.Signature = new(primitives.Signature)
newData, err = m.Signature.UnmarshalBinaryData(newData)
if err != nil {
return nil, err
}
}
return newData, nil
}
func newCommitEntry() *CommitEntryMsg {
cem := new(CommitEntryMsg)
ce := entryCreditBlock.NewCommitEntry()
// build a CommitEntry for testing
ce.Version = 0
ce.MilliTime = (*primitives.ByteSlice6)(&[6]byte{1, 1, 1, 1, 1, 1})
p, _ := hex.DecodeString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
ce.EntryHash.SetBytes(p)
ce.Credits = 1
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
panic(err)
} else {
ce.ECPubKey = (*primitives.ByteSlice32)(pub)
ce.Sig = (*primitives.ByteSlice64)(ed.Sign(privkey, ce.CommitMsg()))
}
cem.CommitEntry = ce
//cem.Timestamp = primitives.NewTimestampNow()
return cem
}
func (m *CommitEntryMsg) UnmarshalBinaryData(data []byte) (newData []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Error unmarshalling: %v", r)
}
}()
newData = data[1:]
ce := entryCreditBlock.NewCommitEntry()
newData, err = ce.UnmarshalBinaryData(newData)
if err != nil {
return nil, err
}
m.CommitEntry = ce
return newData, nil
}
func NewCommitEntry(eBlock *entryBlock.EBlock) *entryCreditBlock.CommitEntry {
commit := entryCreditBlock.NewCommitEntry()
commit.Version = 1
err := commit.MilliTime.UnmarshalBinary([]byte{0, 0, 0, 0, 0, byte(eBlock.GetHeader().GetDBHeight())})
if err != nil {
panic(err)
}
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
}
//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
}