public void addPublicKeysSeen(Crypto.Hash transactionHash, Crypto.PublicKey outputKey)
{
lock (seen_mutex)
{
GlobalMembers.transactions_hash_seen.Add(transactionHash);
}
GlobalMembers.public_keys_seen.Add(outputKey);
}
public override void removeUnconfirmedTransaction(Crypto.Hash transactionHash)
{
m_observerManager.notify(IBlockchainConsumerObserver.onTransactionDeleteBegin, this, transactionHash);
foreach (var subscription in m_subscriptions)
{
subscription.second.deleteUnconfirmedTransaction(transactionHash);
}
m_observerManager.notify(IBlockchainConsumerObserver.onTransactionDeleteEnd, this, transactionHash);
}
public void addPublicKeysSeen(AccountPublicAddress acc, Crypto.Hash transactionHash, Crypto.PublicKey outputKey)
{
var it = m_consumers.find(acc.viewPublicKey);
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
if (it != m_consumers.end())
{
//C++ TO C# CONVERTER TODO TASK: Iterators are only converted within the context of 'while' and 'for' loops:
it.second.addPublicKeysSeen(transactionHash, outputKey);
}
}
// extra
//C++ TO C# CONVERTER WARNING: 'const' methods are not available in C#:
//ORIGINAL LINE: virtual bool getPaymentId(Hash& hash) const override
public override bool getPaymentId(ref Hash hash)
{
List <ushort> nonce = new List <ushort>();
if (getExtraNonce(nonce))
{
Crypto.Hash paymentId = new Crypto.Hash();
if (getPaymentIdFromTransactionExtraNonce(nonce, paymentId))
{
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#:
hash = reinterpret_cast <const Hash&>(paymentId);
return(true);
}
}
return(false);
}
public override std::future removeUnconfirmedTransaction(Crypto.Hash transactionHash)
{
m_logger.functorMethod(INFO, BRIGHT_WHITE) << "Removing unconfirmed transaction, hash " << transactionHash;
std::unique_lock <object> @lock = new std::unique_lock <object>(m_stateMutex);
if (m_currentState == State.stopped || m_futureState == State.stopped)
{
var message = "Failed to remove unconfirmed transaction: not stopped";
m_logger.functorMethod(ERROR, BRIGHT_RED) << message << ", hash " << transactionHash;
throw new System.Exception(message);
}
std::promise promise = new std::promise();
var future = promise.get_future();
m_removeTransactionTasks.emplace_back(transactionHash, std::move(promise));
m_hasWork.notify_one();
return(future);
}
//--------------------------------------------------------------------------------
private bool print_tx(List <string> args)
{
if (args.Count == 0)
{
Console.Write("expected: print_tx <transaction hash>");
Console.Write("\n");
return(true);
}
string str_hash = args[0];
Crypto.Hash tx_hash = new Crypto.Hash();
if (!parse_hash256(str_hash, tx_hash))
{
return(true);
}
List <Crypto.Hash> tx_ids = new List <Crypto.Hash>();
tx_ids.Add(tx_hash);
List <List <ushort> > txs = new List <List <ushort> >();
List <Crypto.Hash> missed_ids = new List <Crypto.Hash>();
m_core.getTransactions(tx_ids, txs, missed_ids);
if (1 == txs.Count)
{
CryptoNote.CachedTransaction tx = new CryptoNote.CachedTransaction(new List <List <ushort> >(txs[0]));
GlobalMembers.print_as_json(tx.getTransaction());
}
else
{
Console.Write("transaction wasn't found: <");
Console.Write(str_hash);
Console.Write('>');
Console.Write("\n");
}
return(true);
}
//--------------------------------------------------------------------------------
private bool print_block_by_hash(string arg)
{
Crypto.Hash block_hash = new Crypto.Hash();
if (!parse_hash256(arg, block_hash))
{
return(false);
}
if (m_core.hasBlock(block_hash))
{
GlobalMembers.print_as_json(m_core.getBlockByHash(block_hash));
}
else
{
Console.Write("block wasn't found: ");
Console.Write(arg);
Console.Write("\n");
return(false);
}
return(true);
}
public MarkTransactionConfirmedException(Crypto.Hash txHash)
{
}
public SHA512Hash()
{
hash = new Hash(new SHA512Managed());
}
