// Initialize Entry Credit Block Chain from database
func initECChain() {
eCreditMap = make(map[string]int32)
//Initialize the Entry Credit Chain ID
ecchain = common.NewECChain()
// get all ecBlocks from db
ecBlocks, _ := db.FetchAllECBlocks()
sort.Sort(util.ByECBlockIDAccending(ecBlocks))
for i, v := range ecBlocks {
if v.Header.DBHeight != uint32(i) {
panic("Error in initializing dChain:" + ecchain.ChainID.String() + " DBHeight:" + strconv.Itoa(int(v.Header.DBHeight)) + " i:" + strconv.Itoa(i))
}
// Calculate the EC balance for each account
initializeECreditMap(&v)
}
//Create an empty block and append to the chain
if len(ecBlocks) == 0 || dchain.NextDBHeight == 0 {
ecchain.NextBlockHeight = 0
ecchain.NextBlock = common.NewECBlock()
ecchain.NextBlock.AddEntry(serverIndex)
for i := 0; i < 10; i++ {
marker := common.NewMinuteNumber()
marker.Number = uint8(i + 1)
ecchain.NextBlock.AddEntry(marker)
}
} else {
// Entry Credit Chain should have the same height as the dir chain
ecchain.NextBlockHeight = dchain.NextDBHeight
var err error
ecchain.NextBlock, err = common.NextECBlock(&ecBlocks[ecchain.NextBlockHeight-1])
if err != nil {
panic(err)
}
}
// create a backup copy before processing entries
copyCreditMap(eCreditMap, eCreditMapBackup)
exportECChain(ecchain)
// ONly for debugging
if procLog.Level() > factomlog.Info {
printCreditMap()
}
}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgECBlock) BtcDecode(r io.Reader, pver uint32) error {
bytes, err := readVarBytes(r, pver, uint32(MaxBlockMsgPayload), CmdECBlock)
if err != nil {
return err
}
msg.ECBlock = common.NewECBlock()
err = msg.ECBlock.UnmarshalBinary(bytes)
if err != nil {
return err
}
return nil
}
// FetchECBlockByHash gets an Entry Credit block by hash from the database.
func (db *LevelDb) FetchECBlockByHash(ecBlockHash *common.Hash) (ecBlock *common.ECBlock, err error) {
db.dbLock.Lock()
defer db.dbLock.Unlock()
var key []byte = []byte{byte(TBL_CB)}
key = append(key, ecBlockHash.Bytes()...)
data, err := db.lDb.Get(key, db.ro)
if data != nil {
ecBlock = common.NewECBlock()
_, err := ecBlock.UnmarshalBinaryData(data)
if err != nil {
return nil, err
}
}
return ecBlock, nil
}
// FetchECBlockByHash gets an Entry Credit block by hash from the database.
func (db *LevelDb) FetchECBlockByHash(ecBlockHash *common.Hash) (ecBlock *common.ECBlock, err error) {
var key = []byte{byte(TBL_CB)}
key = append(key, ecBlockHash.Bytes()...)
var data []byte
db.dbLock.RLock()
data, err = db.lDb.Get(key, db.ro)
db.dbLock.RUnlock()
if err != nil {
return nil, err
}
//fmt.Println("FetchECBlockByHash: key=", hex.EncodeToString(key), ", data=", string(data))
if data != nil {
ecBlock = common.NewECBlock()
_, err := ecBlock.UnmarshalBinaryData(data)
if err != nil {
return nil, err
}
}
//fmt.Println("FetchECBlockByHash: ecBlock=", spew.Sdump(ecBlock))
return ecBlock, nil
}
// FetchAllECBlocks gets all of the entry credit blocks
func (db *LevelDb) FetchAllECBlocks() (ecBlocks []common.ECBlock, err error) {
db.dbLock.RLock()
defer db.dbLock.RUnlock()
var fromkey = []byte{byte(TBL_CB)} // Table Name (1 bytes) // Timestamp (8 bytes)
var tokey = []byte{byte(TBL_CB + 1)} // Table Name (1 bytes)
ecBlockSlice := make([]common.ECBlock, 0, 10)
var iter iterator.Iterator
iter = db.lDb.NewIterator(&util.Range{Start: fromkey, Limit: tokey}, db.ro)
for iter.Next() {
ecBlock := common.NewECBlock()
_, err := ecBlock.UnmarshalBinaryData(iter.Value())
if err != nil {
return nil, err
}
ecBlockSlice = append(ecBlockSlice, *ecBlock)
}
iter.Release()
err = iter.Error()
return ecBlockSlice, nil
}
func ParseEntryCreditBlock(chainID, hash string, rawBlock []byte, blockTime string) (*Block, error) {
answer := new(Block)
ecBlock := common.NewECBlock()
_, err := ecBlock.UnmarshalBinaryData(rawBlock)
if err != nil {
return nil, err
}
answer.ChainID = chainID
h, err := ecBlock.Hash()
if err != nil {
return nil, err
}
answer.FullHash = h.String()
h, err = ecBlock.HeaderHash()
if err != nil {
return nil, err
}
answer.PartialHash = h.String()
answer.PrevBlockHash = ecBlock.Header.PrevLedgerKeyMR.String()
answer.EntryCount = len(ecBlock.Body.Entries)
answer.EntryList = make([]*Entry, answer.EntryCount)
answer.BinaryString = fmt.Sprintf("%x", rawBlock)
for i, v := range ecBlock.Body.Entries {
entry := new(Entry)
marshalled, err := v.MarshalBinary()
if err != nil {
return nil, err
}
entry.BinaryString = fmt.Sprintf("%x", marshalled)
entry.Timestamp = blockTime
entry.ChainID = chainID
entry.Hash = v.Hash().String()
entry.JSONString, err = v.JSONString()
if err != nil {
return nil, err
}
entry.SpewString = v.Spew()
entry.ShortEntry = v.Interpret()
answer.EntryList[i] = entry
}
answer.JSONString, err = ecBlock.JSONString()
if err != nil {
return nil, err
}
answer.SpewString = ecBlock.Spew()
answer.IsEntryCreditBlock = true
return answer, nil
}
func TestECBlockMarshal(t *testing.T) {
ecb1 := common.NewECBlock()
// build a CommitChain for testing
cc := common.NewCommitChain()
cc.Version = 0
cc.MilliTime = &[6]byte{1, 1, 1, 1, 1, 1}
cc.ChainIDHash.SetBytes(byteof(0xaa))
cc.Weld.SetBytes(byteof(0xbb))
cc.EntryHash.SetBytes(byteof(0xcc))
cc.Credits = 11
// make a key and sign the msg
if pub, privkey, err := ed.GenerateKey(rand.Reader); err != nil {
t.Error(err)
} else {
cc.ECPubKey = pub
cc.Sig = ed.Sign(privkey, cc.CommitMsg())
}
// create a ECBlock for testing
ecb1.Header.ECChainID.SetBytes(byteof(0x11))
ecb1.Header.BodyHash.SetBytes(byteof(0x22))
ecb1.Header.PrevHeaderHash.SetBytes(byteof(0x33))
ecb1.Header.PrevLedgerKeyMR.SetBytes(byteof(0x44))
ecb1.Header.EBHeight = 10
ecb1.Header.HeaderExpansionArea = byteof(0x55)
ecb1.Header.ObjectCount = 0
// add the CommitChain to the ECBlock
ecb1.AddEntry(cc)
m1 := common.NewMinuteNumber()
m1.Number = 0x01
ecb1.AddEntry(m1)
// add a ServerIndexNumber
si1 := common.NewServerIndexNumber()
si1.Number = 3
ecb1.AddEntry(si1)
// create an IncreaseBalance for testing
ib := common.NewIncreaseBalance()
pub := new([32]byte)
copy(pub[:], byteof(0xaa))
ib.ECPubKey = pub
ib.TXID.SetBytes(byteof(0xbb))
ib.NumEC = uint64(13)
// add the IncreaseBalance
ecb1.AddEntry(ib)
m2 := common.NewMinuteNumber()
m2.Number = 0x02
ecb1.AddEntry(m2)
ecb2 := common.NewECBlock()
if p, err := ecb1.MarshalBinary(); err != nil {
t.Error(err)
} else {
if err := ecb2.UnmarshalBinary(p); err != nil {
t.Error(err)
}
t.Log(spew.Sdump(ecb1))
t.Log(spew.Sdump(ecb2))
if q, err := ecb2.MarshalBinary(); err != nil {
t.Error(err)
} else if string(p) != string(q) {
t.Errorf("ecb1 = %x\n", p)
t.Errorf("ecb2 = %x\n", q)
}
}
}
