func TestCommitEntryMarshal(t *testing.T) {
fmt.Printf("---\nTestCommitEntryMarshal\n---\n")
ce := common.NewCommitEntry()
// test MarshalBinary on a zeroed CommitEntry
if p, err := ce.MarshalBinary(); err != nil {
t.Error(err)
} else if z := make([]byte, common.CommitEntrySize); string(p) != string(z) {
t.Errorf("Marshal failed on zeroed CommitEntry")
}
// build a CommitEntry for testing
ce.Version = 0
ce.MilliTime = &[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 {
t.Error(err)
} else {
ce.ECPubKey = pub
ce.Sig = ed.Sign(privkey, ce.CommitMsg())
}
// marshal and unmarshal the commit and see if it matches
ce2 := common.NewCommitEntry()
if p, err := ce.MarshalBinary(); err != nil {
t.Error(err)
} else {
t.Logf("%x\n", p)
ce2.UnmarshalBinary(p)
}
if !ce2.IsValid() {
t.Errorf("signature did not match after unmarshalbinary")
}
}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgCommitEntry) BtcDecode(r io.Reader, pver uint32) error {
bytes, err := readVarBytes(r, pver, uint32(common.CommitEntrySize),
CmdEntry)
if err != nil {
return err
}
msg.CommitEntry = common.NewCommitEntry()
err = msg.CommitEntry.UnmarshalBinary(bytes)
if err != nil {
return err
}
return nil
}
func handleCommitEntry(ctx *web.Context) {
type commitentry struct {
CommitEntryMsg string
}
c := new(commitentry)
if p, err := ioutil.ReadAll(ctx.Request.Body); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
if err := json.Unmarshal(p, c); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
commit := common.NewCommitEntry()
if p, err := hex.DecodeString(c.CommitEntryMsg); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
_, err := commit.UnmarshalBinaryData(p)
if err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
if err := factomapi.CommitEntry(commit); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
// NewMsgCommitEntry returns a new Commit Entry message that conforms to the
// Message interface.
func NewMsgCommitEntry() *MsgCommitEntry {
m := new(MsgCommitEntry)
m.CommitEntry = common.NewCommitEntry()
return m
}
//Construct the entry and submit it to the server
func submitEntryToAnchorChain(aRecord *AnchorRecord) error {
//Marshal aRecord into json
jsonARecord, err := json.Marshal(aRecord)
anchorLog.Debug("submitEntryToAnchorChain - jsonARecord: ", string(jsonARecord))
if err != nil {
return err
}
bufARecord := new(bytes.Buffer)
bufARecord.Write(jsonARecord)
//Sign the json aRecord with the server key
aRecordSig := serverPrivKey.Sign(jsonARecord)
//Encode sig into Hex string
bufARecord.Write([]byte(hex.EncodeToString(aRecordSig.Sig[:])))
//Create a new entry
entry := common.NewEntry()
entry.ChainID = anchorChainID
anchorLog.Debug("anchorChainID: ", anchorChainID)
entry.Content = bufARecord.Bytes()
buf := new(bytes.Buffer)
// 1 byte version
buf.Write([]byte{0})
// 6 byte milliTimestamp (truncated unix time)
buf.Write(milliTime())
// 32 byte Entry Hash
buf.Write(entry.Hash().Bytes())
// 1 byte number of entry credits to pay
binaryEntry, err := entry.MarshalBinary()
if err != nil {
return err
}
anchorLog.Info("jsonARecord binary entry: ", hex.EncodeToString(binaryEntry))
if c, err := util.EntryCost(binaryEntry); err != nil {
return err
} else {
buf.WriteByte(byte(c))
}
tmp := buf.Bytes()
sig := serverECKey.Sign(tmp)
buf = bytes.NewBuffer(tmp)
buf.Write(serverECKey.Pub.Key[:])
buf.Write(sig.Sig[:])
commit := common.NewCommitEntry()
err = commit.UnmarshalBinary(buf.Bytes())
if err != nil {
return err
}
// create a CommitEntry msg and send it to the local inmsgQ
cm := factomwire.NewMsgCommitEntry()
cm.CommitEntry = commit
inMsgQ <- cm
// create a RevealEntry msg and send it to the local inmsgQ
rm := factomwire.NewMsgRevealEntry()
rm.Entry = entry
inMsgQ <- rm
return nil
}