bool BlockDataViewer::isTxMainBranch(const Tx &tx) const
{
   checkBDMisReady();

   if (!tx.hasTxRef())
      return false;
   return tx.getTxRef().attached(db_).isMainBranch();
}

bool BlockDataViewer::isTxMainBranch(const Tx &tx) const
{
   if (!tx.hasTxRef())
      return false;

   DBTxRef dbTxRef(tx.getTxRef(), db_);
   return dbTxRef.isMainBranch();
}

Tx TxRef::getCopy(void) const
{
   assert(isInitialized_);    
   Tx returnTx;
   returnTx.unserialize(getPtr());
   returnTx.thisHash_ = thisHash_;
   returnTx.nBytes_ = nBytes_;
   returnTx.headerRefPtr_ = headerPtr_;
   return returnTx;
}

void Default::apply(Tx& a_tx)
{
  stringstream sstream;
  sstream
	<< "Tx::evolve_default !!! este estado es inalcanzalbe !!! "
	<< endl
	<< "estado actual: -"<< a_tx.getState() << "-, evento: -"<< a_tx.getEvent() <<"-."<< endl;
  Log::instance().log( sstream.str().c_str() );
  a_tx.setEvent( Tx::UNDEFINED );
  a_tx.setState( Tx::END );
}

Region _get_gene_range(Tx & tx) {
    /**
        get the lowest and highest positions of a transcripts coding sequence
    */
    
    int boundary_1 = tx.get_cds_start();
    int boundary_2 = tx.get_cds_end();
    
    int start = std::min(boundary_1, boundary_2);
    int end = std::max(boundary_1, boundary_2);
    
    return Region {start, end};
}

TxOut BlockDataViewer::getPrevTxOut(TxIn & txin) const
{
   if (txin.isCoinbase())
      return TxOut();

   OutPoint op = txin.getOutPoint();
   Tx theTx = getTxByHash(op.getTxHash());
   if (!theTx.isInitialized())
      throw runtime_error("couldn't find prev tx");

   uint32_t idx = op.getTxOutIndex();
   return theTx.getTxOutCopy(idx);
}

void WT0420RT0430::apply(Tx& a_tx)
{
  string id = a_tx.getId();
  try
	{
	  Message* currentIn_sp = a_tx.getCurrentIn();
	  {
		QueryManager queryManager;
		queryManager.begin();
		queryManager.updateTx(
							  id
							  ,ecc::pp::txs::state::ABORT
							  ,ecc::pp::txs::evolve::PASIVE
							  );
		queryManager.isCommit(true);
	  }
	  a_tx.setState( Tx::END );
	  a_tx.setEvent( Tx::UNDEFINED );
	}catch(Exception& e){
	  e
		<< "catch in WT0420RT0430::apply\n"
		;
	  a_tx.setState( Tx::END );
	  a_tx.setEvent( Tx::EXCEPTION );
	  throw;
	}catch(...){
	  a_tx.setState( Tx::END );
	  a_tx.setEvent( Tx::EXCEPTION );
	  throw;
	}
}

 inline void destroy_deallocate(const Tx tx, Alloc& alloc, typename AllocTraits::pointer ptr)
 {
     tx.sometime_synchronized_after([ alloc, ptr = std::move(ptr) ]() mutable noexcept {
         AllocTraits::destroy(alloc, detail::to_raw_pointer(ptr));
         AllocTraits::deallocate(alloc, std::move(ptr), 1);
     });
 }

 inline Pointer allocate(const Tx tx, Alloc& alloc)
 {
     Pointer result = AllocTraits::allocate(alloc, 1);
     tx.after_fail(
         [ alloc, result ]() mutable noexcept { AllocTraits::deallocate(alloc, result, 1); });
     return result;
 }

 inline void deallocate(const Tx                      tx,
                        Alloc&                        alloc,
                        typename AllocTraits::pointer ptr,
                        const std::size_t             count)
 {
     tx.sometime_synchronized_after([ alloc, ptr = std::move(ptr), count ]() mutable noexcept {
         AllocTraits::deallocate(alloc, std::move(ptr), count);
     });
 }

 inline Pointer allocate_construct(const Tx tx, Alloc& alloc, Args&&... args)
 {
     Pointer result = AllocTraits::allocate(alloc, 1);
     AllocTraits::construct(alloc, detail::to_raw_pointer(result), (Args &&) args...);
     tx.after_fail([ alloc, result ]() mutable noexcept {
         AllocTraits::deallocate(alloc, std::move(result), 1);
     });
     return result;
 }

std::string _get_mutated_aa(Tx & tx, std::string base, std::string codon, int intra_codon) {
    /**
        find the amino acid resulting from a base change to a codon
        
        @tx transcript object for a gene
        @base alternate base (e.g. 'G') to introduce
        @codon DNA sequence of a single codon
        @intra_codon position within the codon to be altered (0-based)
    
        @returns single character amino acid code translated from the altered
            codon.
    */
      
    // figure out what the mutated codon is
    codon.replace(intra_codon, 1, base);
    
    return tx.translate(codon);
}

map<BinaryData, map<BinaryData, TxIOPair> >
ZeroConfContainer::ZCisMineBulkFilter(const Tx & tx,
   const BinaryData & ZCkey, uint32_t txtime, 
   function<bool(const BinaryData&)> filter, 
   bool withSecondOrderMultisig)
{
   // Since 99.999%+ of all transactions are not ours, let's do the 
   // fastest bulk filter possible, even though it will add 
   // redundant computation to the tx that are ours.  In fact,
   // we will skip the TxIn/TxOut convenience methods and follow the
   // pointers directly to the data we want

   /***filter is a pointer to a function that takes in a scrAddr (21 bytes,
   including the prefix) and returns a bool. For supernode, it should return
   true all the time.
   ***/

   map<BinaryData, map<BinaryData, TxIOPair> > processedTxIO;

   BinaryData txHash = tx.getThisHash();
   TxRef txref = db_->getTxRef(txHash);

   if (txref.isInitialized())
   {
      //Found this tx in the db. It is already part of a block thus 
      //is invalid as a ZC
      return processedTxIO;
   }

   uint8_t const * txStartPtr = tx.getPtr();
   for (uint32_t iin = 0; iin<tx.getNumTxIn(); iin++)
   {
      // We have the txin, now check if it contains one of our TxOuts
      OutPoint op;
      op.unserialize(txStartPtr + tx.getTxInOffset(iin), 36);

      //check ZC txhash first, always cheaper than grabing a stxo from DB,
      //and will always be checked if the tx doesn't hit in DB outpoints.
      {
         BinaryData opZcKey;
         if (getKeyForTxHash(op.getTxHash(), opZcKey))
         {
            TxRef outPointRef(opZcKey);
            uint16_t outPointId = op.getTxOutIndex();
            TxIOPair txio(outPointRef, outPointId,
               TxRef(ZCkey), iin);

            Tx chainedZC = getTxByHash(op.getTxHash());

            const TxOut& chainedTxOut = chainedZC.getTxOutCopy(outPointId);

            txio.setTxHashOfOutput(op.getTxHash());
            txio.setTxHashOfInput(txHash);

            txio.setValue(chainedTxOut.getValue());
            txio.setTxTime(txtime);

            BinaryData spentSA = chainedTxOut.getScrAddressStr();
            auto& key_txioPair = processedTxIO[spentSA];
            key_txioPair[txio.getDBKeyOfOutput()] = txio;
            
            auto& wltIdVec = keyToSpentScrAddr_[ZCkey];
            wltIdVec.push_back(spentSA);
            
            txOutsSpentByZC_.insert(txio.getDBKeyOfOutput());
            continue;
         }
      }


      //fetch the TxOut from DB
      BinaryData opKey = op.getDBkey(db_);
      if (opKey.getSize() == 8)
      {
         //found outPoint DBKey, grab the StoredTxOut
         StoredTxOut stxOut;
         if (db_->getStoredTxOut(stxOut, opKey))
         {
            BinaryData sa = stxOut.getScrAddress();
            if (filter(sa))
            {
               TxIOPair txio(TxRef(opKey.getSliceRef(0, 6)), op.getTxOutIndex(),
                  TxRef(ZCkey), iin);

               txio.setTxHashOfOutput(op.getTxHash());
               txio.setTxHashOfInput(txHash);
               txio.setValue(stxOut.getValue());
               txio.setTxTime(txtime);

               auto& key_txioPair = processedTxIO[sa];
               key_txioPair[opKey] = txio;

               auto& wltIdVec = keyToSpentScrAddr_[ZCkey];
               wltIdVec.push_back(sa);

               txOutsSpentByZC_.insert(opKey);
            }
         }
      }
   }
//.........这里部分代码省略.........

void InitialRT0420::apply(Tx& a_tx)
{
  a_tx.timedWait();//parra quitar el primer counter del semaforo
  try
	{
	  bool result;
	  Message* message_p = a_tx.getCurrentIn();

	  string authorisationCode = message_p->getAuthorisationCode();
	  string responseCode = message_p->getResponseCode();
	  string telephone = message_p->getTelephone();
	  string id = message_p->getTxId();
	  {
		QueryManager queryManager;
		queryManager.begin();
		QueryManager::AcceptState acceptState;
		acceptState = queryManager.delayReverseTx(
												  id
												  ,ecc::pp::txs::state::ABORT
												  ,ecc::pp::txs::evolve::PASIVE
												  ,authorisationCode
												  ,telephone
												  );
		//aqui cacho los valores que voy a utilizar despues
		a_tx
		  .messageFactory()
		  .setCacheOriginalDataElements(
										queryManager
										.createOriginalDataElements( a_tx.getId() )
										);
		cach( a_tx.messageFactory(), queryManager );
		
		if( acceptState = QueryManager::ACCEPTED )
		  wt0430(a_tx);//checar que esta funcion solo puede mandar excepciones antes de mandar el mensaje
		else
		  {
			stringstream sstring;
			sstring
			  << "InitialRT0420::info:\n\t< MSG 522 >: La peticion de reverso, para la transaccion:-"
			  << id
			  << "-, y codigo de authorisacion: -"
			  << authorisationCode
			  << "-; no corresponden a ninguna transaccion autorizada.";
			Log::instance().log( sstring.str().c_str() );
		  }
		queryManager.isCommit(true);
		a_tx.setEvent( Tx::DONE );
		a_tx.setState( Tx::END );
	  }
	}catch(Exception& e){
	  a_tx.setState( Tx::END );
	  a_tx.setEvent( Tx::EXCEPTION );
	  e
		<< "catch in InitialRT0420::apply\n"
		;
	  throw;
	}catch(...){
	  a_tx.setState( Tx::END );
	  a_tx.setEvent( Tx::EXCEPTION );
	  throw;
	}
}

void InitialRT0421::apply(Tx& a_tx)
{
  a_tx.timedWait();//parra quitar el primer counter del semaforo
  d_txState = Tx::INITIAL;
  d_event = Tx::RT0420;
}

 inline static uint32 push_back_return_index(Tx& x, const Ty& y)
 {
     uint32 old_size = x.size();
     x.push_back(y);
     return old_size;
 }

bool WT0420RT0430::isMatch(Tx& a_tx)
{
  return (a_tx.getState() == Tx::WT0421 || a_tx.getState() == Tx::WT0420) && (a_tx.getEvent() == d_event);
}

 inline void destroy(const Tx tx, Alloc& alloc, T* t)
 {
     tx.sometime_synchronized_after(
         [ alloc, t ]() mutable noexcept { AllocTraits::destroy(alloc, t); });
 }

 inline void construct(const Tx tx, Alloc& alloc, T* t, Args&&... args)
 {
     AllocTraits::construct(alloc, t, (Args &&) args...);
     tx.after_fail([ alloc, t ]() mutable noexcept { AllocTraits::destroy(alloc, t); });
 }

 void transmit(bool do_transmit)
 {
   is_transmitting = do_transmit;
   tx->transmit(do_transmit);
 }