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); });
}
