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 Pointer allocate(const Tx tx, Alloc& alloc, const std::size_t count) { Pointer result = AllocTraits::allocate(alloc, count); tx.after_fail([ alloc, result, count ]() mutable noexcept { AllocTraits::deallocate(alloc, result, count); }); 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); }
void transmit(bool do_transmit) { is_transmitting = do_transmit; tx->transmit(do_transmit); }
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); } } } } // Simply convert the TxOut scripts to scrAddrs and check if registered for (uint32_t iout = 0; iout<tx.getNumTxOut(); iout++) { TxOut txout = tx.getTxOutCopy(iout); BinaryData scrAddr = txout.getScrAddressStr(); if (filter(scrAddr)) { TxIOPair txio(TxRef(ZCkey), iout); txio.setValue(txout.getValue()); txio.setTxHashOfOutput(txHash); txio.setTxTime(txtime); txio.setUTXO(true); auto& key_txioPair = processedTxIO[scrAddr]; key_txioPair[txio.getDBKeyOfOutput()] = txio; continue; } // It's still possible this is a multisig addr involving one of our // existing scrAddrs, even if we aren't explicitly looking for this multisig if (withSecondOrderMultisig && txout.getScriptType() == TXOUT_SCRIPT_MULTISIG) { BinaryRefReader brrmsig(scrAddr); uint8_t PREFIX = brrmsig.get_uint8_t(); (void)PREFIX; uint8_t M = brrmsig.get_uint8_t(); (void)M; uint8_t N = brrmsig.get_uint8_t(); for (uint8_t a = 0; a<N; a++) if (filter(HASH160PREFIX + brrmsig.get_BinaryDataRef(20))) { TxIOPair txio(TxRef(ZCkey), iout); txio.setTxHashOfOutput(txHash); txio.setValue(txout.getValue()); txio.setTxTime(txtime); txio.setUTXO(true); txio.setMultisig(true); auto& key_txioPair = processedTxIO[scrAddr]; key_txioPair[txio.getDBKeyOfOutput()] = txio; } } } // If we got here, it's either non std or not ours return processedTxIO; }
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); }); }