heeelp

blockchain/blockchain.go

@@ -870,23 +870,51 @@ func (b *Blockchain) WriteFullBlock(fblock *types.FullBlock, source string) erro
 
 	header := block.Header
 
+	b.logger.Warn("LOGS RECEIPT WriteFullBlock 1", "bi", fblock.Block.Number(), "ln", len(fblock.Receipts))
+	for _, r := range fblock.Receipts {
+		for _, x := range r.Logs {
+			b.logger.Warn("WriteFullBlockX", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	if err := b.writeBody(block); err != nil {
 		return err
 	}
 
+	b.logger.Warn("LOGS RECEIPT WriteFullBlock 2", "bi", fblock.Block.Number(), "ln", len(fblock.Receipts))
+	for _, r := range fblock.Receipts {
+		for _, x := range r.Logs {
+			b.logger.Warn("WriteFullBlockY", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	// Write the header to the chain
 	evnt := &Event{Source: source}
 	if err := b.writeHeaderImpl(evnt, header); err != nil {
 		return err
 	}
 
+	b.logger.Warn("LOGS RECEIPT WriteFullBlock 3", "bi", fblock.Block.Number(), "ln", len(fblock.Receipts))
+	for _, r := range fblock.Receipts {
+		for _, x := range r.Logs {
+			b.logger.Warn("WriteFullBlockZ", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	// write the receipts, do it only after the header has been written.
 	// Otherwise, a client might ask for a header once the receipt is valid,
 	// but before it is written into the storage
 	if err := b.db.WriteReceipts(block.Hash(), fblock.Receipts); err != nil {
 		return err
 	}
 
+	b.logger.Warn("LOGS RECEIPT WriteFullBlock 4", "bi", fblock.Block.Number(), "ln", len(fblock.Receipts))
+	for _, r := range fblock.Receipts {
+		for _, x := range r.Logs {
+			b.logger.Warn("WriteFullBlockU", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	// update snapshot
 	if err := b.consensus.ProcessHeaders([]*types.Header{header}); err != nil {
 		return err
@@ -910,6 +938,13 @@ func (b *Blockchain) WriteFullBlock(fblock *types.FullBlock, source string) erro
 		logArgs = append(logArgs, "generation_time_in_seconds", diff)
 	}
 
+	b.logger.Warn("LOGS RECEIPT WriteFullBlock 5", "bi", fblock.Block.Number(), "ln", len(fblock.Receipts))
+	for _, r := range fblock.Receipts {
+		for _, x := range r.Logs {
+			b.logger.Warn("WriteFullBlockV", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	b.logger.Info("new block", logArgs...)
 
 	return nil

consensus/polybft/consensus_runtime.go

@@ -293,6 +293,11 @@ func (c *consensusRuntime) OnBlockInserted(fullBlock *types.FullBlock) {
 
 	postBlock := &PostBlockRequest{FullBlock: fullBlock, Epoch: epoch.Number, IsEpochEndingBlock: isEndOfEpoch}
 
+	// handle transfer events that happened in block
+	if err := c.stakeManager.PostBlock(postBlock); err != nil {
+		c.logger.Error("failed to post block in stake manager", "err", err)
+	}
+
 	// handle commitment and proofs creation
 	if err := c.stateSyncManager.PostBlock(postBlock); err != nil {
 		c.logger.Error("failed to post block state sync", "err", err)
@@ -308,11 +313,6 @@ func (c *consensusRuntime) OnBlockInserted(fullBlock *types.FullBlock) {
 		c.logger.Error("Could not update proposer calculator", "err", err)
 	}
 
-	// handle transfer events that happened in block
-	if err := c.stakeManager.PostBlock(postBlock); err != nil {
-		c.logger.Error("failed to post block in stake manager", "err", err)
-	}
-
 	if isEndOfEpoch {
 		if epoch, err = c.restartEpoch(fullBlock.Block.Header); err != nil {
 			c.logger.Error("failed to restart epoch after block inserted", "error", err)

consensus/polybft/fsm.go

@@ -506,6 +506,13 @@ func (f *fsm) VerifyStateTransactions(transactions []*types.Transaction) error {
 func (f *fsm) Insert(proposal []byte, committedSeals []*messages.CommittedSeal) (*types.FullBlock, error) {
 	newBlock := f.target
 
+	f.logger.Warn("LOGS RECEIPT ON Insert FSM", "bi", newBlock.Block.Number(), "ln", len(newBlock.Receipts))
+	for _, r := range newBlock.Receipts {
+		for _, x := range r.Logs {
+			f.logger.Warn("LOGGGGGGGG", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	var proposedBlock types.Block
 	if err := proposedBlock.UnmarshalRLP(proposal); err != nil {
 		return nil, fmt.Errorf("failed to insert proposal, block unmarshaling failed: %w", err)
@@ -568,10 +575,24 @@ func (f *fsm) Insert(proposal []byte, committedSeals []*messages.CommittedSeal)
 	// Write extra data to header
 	newBlock.Block.Header.ExtraData = extra.MarshalRLPTo(nil)
 
+	f.logger.Warn("LOGS RECEIPT PRE COMMIT FSM", "bi", newBlock.Block.Number(), "ln", len(newBlock.Receipts))
+	for _, r := range newBlock.Receipts {
+		for _, x := range r.Logs {
+			f.logger.Warn("LOGGGGGGGG", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	if err := f.backend.CommitBlock(newBlock); err != nil {
 		return nil, err
 	}
 
+	f.logger.Warn("LOGS RECEIPT POS COMMIT FSM", "bi", newBlock.Block.Number(), "ln", len(newBlock.Receipts))
+	for _, r := range newBlock.Receipts {
+		for _, x := range r.Logs {
+			f.logger.Warn("LOGGGGGGGG", "d", x.Data, "a", x.Address)
+		}
+	}
+
 	return newBlock, nil
 }
 

consensus/polybft/stake_manager.go

@@ -249,9 +249,11 @@ func (s *stakeManager) getTransferEventsFromReceipts(receipts []*types.Receipt)
 
 			var transferEvent contractsapi.TransferEvent
 
+			s.logger.Warn("Transfer event log before 1", "Log", log.Data)
+
 			convertedLog := convertLog(log)
 
-			s.logger.Warn("Transfer event log before", "Log", log.Data)
+			s.logger.Warn("Transfer event log before 2", "Log", convertedLog.Data)
 
 			doesMatch, err := transferEvent.ParseLog(convertedLog)
 			if err != nil {
@@ -262,7 +264,8 @@ func (s *stakeManager) getTransferEventsFromReceipts(receipts []*types.Receipt)
 				continue
 			}
 
-			s.logger.Warn("Transfer event log after", "Log", log.Data)
+			s.logger.Warn("Transfer event log after 1", "Log", log.Data)
+			s.logger.Warn("Transfer event log after 2", "Log", convertedLog.Data)
 
 			events = append(events, &transferEvent)
 		}

consensus/polybft/state_store_checkpoint.go

@@ -195,10 +195,12 @@ func decodeExitEvent(log *ethgo.Log, epoch, block uint64) (*ExitEvent, error) {
 func convertLog(log *types.Log) *ethgo.Log {
 	l := &ethgo.Log{
 		Address: ethgo.Address(log.Address),
-		Data:    log.Data,
+		Data:    make([]byte, len(log.Data)),
 		Topics:  make([]ethgo.Hash, len(log.Topics)),
 	}
 
+	copy(l.Data, log.Data)
+
 	for i, topic := range log.Topics {
 		l.Topics[i] = ethgo.Hash(topic)
 	}

helper/common/common.go

@@ -334,6 +334,7 @@ func ExtendByteSlice(b []byte, needLength int) []byte {
 	if oldLen := len(b); oldLen < needLength {
 		b = append(b, make([]byte, needLength-oldLen)...)
 	}
+
 	return b[:needLength]
 }
 

state/executor.go

@@ -357,6 +357,11 @@ func (t *Transition) Write(txn *types.Transaction) error {
 
 	logs := t.state.Logs()
 
+	t.logger.Warn("LOGS WRITTEN IN THE RECEIPT", "ln", len(logs))
+	for _, x := range logs {
+		t.logger.Warn("LOGGGGGGGG", "d", x.Data, "a", x.Address)
+	}
+
 	receipt := &types.Receipt{
 		CumulativeGasUsed: t.totalGas,
 		TransactionType:   txn.Type,

state/txn.go

@@ -471,12 +471,6 @@ func (txn *Txn) Logs() []*types.Log {
 	//nolint:forcetypeassert
 	logs := data.([]*types.Log)
 
-	fmt.Println("TXN LOGS RETRIEVE FROM DB", len(logs))
-
-	for _, x := range logs {
-		fmt.Println(x.Address, x.Data)
-	}
-
 	txn.txn.Delete(logIndex)
 
 	return logs