func (pool *TxPool) resetState() { currentState, err := pool.currentState() if err != nil { glog.V(logger.Info).Infoln("failed to get current state: %v", err) return } managedState := state.ManageState(currentState) if err != nil { glog.V(logger.Info).Infoln("failed to get managed state: %v", err) return } pool.pendingState = managedState // validate the pool of pending transactions, this will remove // any transactions that have been included in the block or // have been invalidated because of another transaction (e.g. // higher gas price) pool.validatePool() // Loop over the pending transactions and base the nonce of the new // pending transaction set. for _, tx := range pool.pending { if addr, err := tx.From(); err == nil { // Set the nonce. Transaction nonce can never be lower // than the state nonce; validatePool took care of that. if pool.pendingState.GetNonce(addr) <= tx.Nonce() { pool.pendingState.SetNonce(addr, tx.Nonce()+1) } } } // Check the queue and move transactions over to the pending if possible // or remove those that have become invalid pool.checkQueue() }
func (pool *TxPool) resetState() { pool.pendingState = state.ManageState(pool.currentState()) // validate the pool of pending transactions, this will remove // any transactions that have been included in the block or // have been invalidated because of another transaction (e.g. // higher gas price) pool.validatePool() // Loop over the pending transactions and base the nonce of the new // pending transaction set. for _, tx := range pool.pending { if addr, err := tx.From(); err == nil { // Set the nonce. Transaction nonce can never be lower // than the state nonce; validatePool took care of that. if pool.pendingState.GetNonce(addr) < tx.Nonce() { pool.pendingState.SetNonce(addr, tx.Nonce()) } } } // Check the queue and move transactions over to the pending if possible // or remove those that have become invalid pool.checkQueue() }
// Equivalent of the tx-pool state; updated by CheckTx and replaced on commit // For now, we just return the last block state func (app *EthereumApplication) ManagedState() *state.ManagedState { st, err := state.New(app.StateRoot(), app.ethereum.ChainDb()) if err != nil { return nil // (?!) } return state.ManageState(st) }
func chm(genesis *types.Block, db common.Database) *ChainManager { var eventMux event.TypeMux bc := &ChainManager{blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: &eventMux} bc.cache = NewBlockCache(100) bc.futureBlocks = NewBlockCache(100) bc.processor = bproc{} bc.ResetWithGenesisBlock(genesis) bc.txState = state.ManageState(bc.State()) return bc }
func chm(genesis *types.Block, db common.Database) *ChainManager { var eventMux event.TypeMux bc := &ChainManager{extraDb: db, blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: &eventMux, pow: FakePow{}} bc.cache, _ = lru.New(100) bc.futureBlocks, _ = lru.New(100) bc.processor = bproc{} bc.ResetWithGenesisBlock(genesis) bc.txState = state.ManageState(bc.State()) return bc }
// Create a new chain manager starting from given block // Effectively a fork factory func newChainManager(block *types.Block, eventMux *event.TypeMux, db common.Database) *ChainManager { genesis := GenesisBlock(db) bc := &ChainManager{blockDb: db, stateDb: db, genesisBlock: genesis, eventMux: eventMux} bc.txState = state.ManageState(state.New(genesis.Root(), db)) bc.futureBlocks = NewBlockCache(1000) if block == nil { bc.Reset() } else { bc.currentBlock = block bc.td = block.Td } return bc }
func NewTxPool(eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool { pool := &TxPool{ pending: make(map[common.Hash]*types.Transaction), queue: make(map[common.Address]map[common.Hash]*types.Transaction), quit: make(chan bool), eventMux: eventMux, currentState: currentStateFn, gasLimit: gasLimitFn, minGasPrice: new(big.Int), pendingState: state.ManageState(currentStateFn()), events: eventMux.Subscribe(ChainHeadEvent{}, GasPriceChanged{}), } go pool.eventLoop() return pool }
func NewChainManager(blockDb, stateDb, extraDb common.Database, pow pow.PoW, mux *event.TypeMux) (*ChainManager, error) { cache, _ := lru.New(blockCacheLimit) bc := &ChainManager{ blockDb: blockDb, stateDb: stateDb, extraDb: extraDb, eventMux: mux, quit: make(chan struct{}), cache: cache, pow: pow, } bc.genesisBlock = bc.GetBlockByNumber(0) if bc.genesisBlock == nil { return nil, ErrNoGenesis } if err := bc.setLastState(); err != nil { return nil, err } // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain for hash, _ := range BadHashes { if block := bc.GetBlock(hash); block != nil { glog.V(logger.Error).Infof("Found bad hash. Reorganising chain to state %x\n", block.ParentHash().Bytes()[:4]) block = bc.GetBlock(block.ParentHash()) if block == nil { glog.Fatal("Unable to complete. Parent block not found. Corrupted DB?") } bc.SetHead(block) glog.V(logger.Error).Infoln("Chain reorg was successfull. Resuming normal operation") } } bc.transState = bc.State().Copy() // Take ownership of this particular state bc.txState = state.ManageState(bc.State().Copy()) bc.futureBlocks, _ = lru.New(maxFutureBlocks) bc.makeCache() go bc.update() return bc, nil }
func NewChainManager(genesis *types.Block, blockDb, stateDb, extraDb common.Database, pow pow.PoW, mux *event.TypeMux) (*ChainManager, error) { cache, _ := lru.New(blockCacheLimit) bc := &ChainManager{ blockDb: blockDb, stateDb: stateDb, extraDb: extraDb, genesisBlock: GenesisBlock(42, stateDb), eventMux: mux, quit: make(chan struct{}), cache: cache, pow: pow, } // Check the genesis block given to the chain manager. If the genesis block mismatches block number 0 // throw an error. If no block or the same block's found continue. if g := bc.GetBlockByNumber(0); g != nil && g.Hash() != genesis.Hash() { return nil, fmt.Errorf("Genesis mismatch. Maybe different nonce (%d vs %d)? %x / %x", g.Nonce(), genesis.Nonce(), g.Hash().Bytes()[:4], genesis.Hash().Bytes()[:4]) } bc.genesisBlock = genesis bc.setLastState() // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain for hash, _ := range BadHashes { if block := bc.GetBlock(hash); block != nil { glog.V(logger.Error).Infof("Found bad hash. Reorganising chain to state %x\n", block.ParentHash().Bytes()[:4]) block = bc.GetBlock(block.ParentHash()) if block == nil { glog.Fatal("Unable to complete. Parent block not found. Corrupted DB?") } bc.SetHead(block) glog.V(logger.Error).Infoln("Chain reorg was successfull. Resuming normal operation") } } bc.transState = bc.State().Copy() // Take ownership of this particular state bc.txState = state.ManageState(bc.State().Copy()) bc.futureBlocks, _ = lru.New(maxFutureBlocks) bc.makeCache() go bc.update() return bc, nil }
func (bc *ChainManager) SetHead(head *types.Block) { bc.mu.Lock() defer bc.mu.Unlock() for block := bc.currentBlock; block != nil && block.Hash() != head.Hash(); block = bc.GetBlock(block.Header().ParentHash) { bc.removeBlock(block) } bc.cache = NewBlockCache(blockCacheLimit) bc.currentBlock = head bc.makeCache() statedb := state.New(head.Root(), bc.stateDb) bc.txState = state.ManageState(statedb) bc.transState = statedb.Copy() bc.setTotalDifficulty(head.Td) bc.insert(head) bc.setLastState() }
func NewChainManager(blockDb, stateDb common.Database, mux *event.TypeMux) *ChainManager { bc := &ChainManager{ blockDb: blockDb, stateDb: stateDb, genesisBlock: GenesisBlock(stateDb), eventMux: mux, quit: make(chan struct{}), cache: NewBlockCache(blockCacheLimit), } bc.setLastState() // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain for _, hash := range badHashes { if block := bc.GetBlock(hash); block != nil { glog.V(logger.Error).Infof("Found bad hash. Reorganising chain to state %x\n", block.ParentHash().Bytes()[:4]) block = bc.GetBlock(block.ParentHash()) if block == nil { glog.Fatal("Unable to complete. Parent block not found. Corrupted DB?") } bc.SetHead(block) glog.V(logger.Error).Infoln("Chain reorg was successfull. Resuming normal operation") } } bc.transState = bc.State().Copy() // Take ownership of this particular state bc.txState = state.ManageState(bc.State().Copy()) bc.futureBlocks = NewBlockCache(maxFutureBlocks) bc.makeCache() go bc.update() return bc }
func (self *ChainManager) setTxState(statedb *state.StateDB) { self.tsmu.Lock() defer self.tsmu.Unlock() self.txState = state.ManageState(statedb) }