Method replaceAndSwitchToBranch

blockproducer/chain.go:696–825

(
	newBlock *types.BPBlock, originBrIdx int, newBranch *branch)

}

func (c *Chain) replaceAndSwitchToBranch(
	newBlock *types.BPBlock, originBrIdx int, newBranch *branch) (err error,
) {
	var (
		lastIrre *blockNode
		newIrres []*blockNode
		sps      []storageProcedure
		up       storageCallback
		txCount  int
		height   = c.heightOfTime(newBlock.Timestamp())

		resultTxPool = make(map[hash.Hash]pi.Transaction)
		expiredTxs   []pi.Transaction
	)

	// Find new irreversible blocks
	//
	// NOTE(leventeliu):
	// May have multiple new irreversible blocks here if peer list shrinks. May also have
	// no new irreversible block at all if peer list expands.
	lastIrre = newBranch.head.lastIrreversible(c.confirms)
	newIrres = lastIrre.fetchNodeList(c.lastIrre.count + 1)

	// Apply irreversible blocks to create dirty map on immutable cache
	for k, v := range c.txPool {
		resultTxPool[k] = v
	}
	for _, b := range newIrres {
		txCount += b.txCount
		for _, tx := range b.load().Transactions {
			if err := c.immutable.apply(tx, b.height); err != nil {
				log.WithError(err).Fatal("failed to apply block to immutable database")
			}
			delete(resultTxPool, tx.Hash()) // Remove confirmed transaction
		}
	}

	// Check tx expiration
	for k, v := range resultTxPool {
		if base, err := c.immutable.nextNonce(
			v.GetAccountAddress(),
		); err != nil || v.GetAccountNonce() < base {
			log.WithFields(log.Fields{
				"hash":    k.Short(4),
				"type":    v.GetTransactionType(),
				"account": v.GetAccountAddress(),
				"nonce":   v.GetAccountNonce(),

				"immutable_base_nonce": base,
			}).Debug("transaction expired")
			expiredTxs = append(expiredTxs, v)
			delete(resultTxPool, k) // Remove expired transaction
		}
	}

	// Prepare storage procedures to update immutable database
	sps = c.immutable.compileChanges(sps)
	sps = append(sps, addBlock(height, newBlock))