/// <summary>
/// Promotes the transaction by creating a new zero sum transaction and linking to it as the trunk.
/// It will get a tip to for the branch.
/// </summary>
/// <param name="transactionHash">The has of the transaction to promote</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <APIResult <TransactionItem> > PromoteTransaction(string transactionHash, CancellationToken cancellationToken)
{
var tipsTask = this.IriApi.GetTransactionsToApprove(this.Depth);
var transaction = new TransactionItem(new string('9', 81), 0, "BEEFROG9PROMOTE");
transaction.TrunkTransaction = transactionHash;
var tips = await tipsTask;
if (!tips.Successful)
{
return(tips.RePackage <TransactionItem>(r => null));
}
transaction.BranchTransaction = tips.Result.TrunkTransaction;
transaction.FinalizeBundleHash();
var trytes = new string[] { };
var trytesToSend = (await NonceSeeker
.SearchNonce(new string[] { transaction.ToTransactionTrytes() }, transactionHash, tips.Result.TrunkTransaction, cancellationToken))
.Single();
await IriApi.BroadcastTransactions(trytesToSend);
await IriApi.StoreTransactions(trytesToSend);
return(new APIResult <TransactionItem>(new TransactionItem(trytesToSend)));
}
/// <summary>
/// Approve transactions, do pow, broadcast and store trytes to tangle
/// </summary>
/// <param name="transactionTrytes"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <string[]> AttackTrytes(string[] transactionTrytes, CancellationToken cancellationToken)
{
if (transactionTrytes == null)
{
throw new ArgumentNullException(nameof(transactionTrytes));
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
if (NonceSeeker == null)
{
throw new NullReferenceException(nameof(NonceSeeker));
}
var toApprove = await IriApi.GetTransactionsToApprove(Depth);
var trunk = toApprove.TrunkTransaction;
var branch = toApprove.BranchTransaction;
var trytesToSend = await NonceSeeker.SearchNonce(transactionTrytes, trunk, branch, cancellationToken);
//var trytesToSend = await transactionTrytes
// .DoPow(trunk, branch, IriApi.MinWeightMagnitude, NumberOfThreads, cancellationToken);
await BroadcastAndStore(trytesToSend);
return(trytesToSend);
}
/// <summary>
/// Fast transaction reattach. It approves only branch transaction.
/// </summary>
/// <param name="trytes">Trytes to rebroadcast</param>
/// <param name="cancellationToken">The CancellationToken</param>
/// <returns></returns>
public async Task <string> FastReattach(string trytes, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(trytes))
{
throw new ArgumentNullException(nameof(trytes));
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
if (NonceSeeker == null)
{
throw new NullReferenceException(nameof(NonceSeeker));
}
while (true)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
cancellationToken.Register(() => cts.Cancel());
var toApprove = await IriApi.GetTransactionsToApprove(Depth);
cts.CancelAfter(RebroadcastMaximumPowTime);
var trunk = trytes.GetTrunkTransaction();
var branch = toApprove.Result.TrunkTransaction;
var trytesToSend = (await NonceSeeker
.SearchNonce(new string[] { trytes }, trunk, branch, cts.Token))
.Single();
cts.Token.ThrowIfCancellationRequested();
await IriApi.BroadcastTransactions(trytesToSend);
await IriApi.StoreTransactions(trytesToSend);
var transaction = new TransactionItem(trytesToSend);
return(transaction.Hash);
}
catch (OperationCanceledException)
{
if (cancellationToken.IsCancellationRequested)
{
throw;
}
continue;
}
}
}
/// <summary>
/// Approve transactions, do pow, broadcast and store trytes to tangle
/// </summary>
/// <param name="transactionTrytes"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <APIResult <string[]> > AttachTrytes(string[] transactionTrytes, CancellationToken cancellationToken)
{
if (transactionTrytes == null)
{
throw new ArgumentNullException(nameof(transactionTrytes));
}
if (cancellationToken == null)
{
throw new ArgumentNullException(nameof(cancellationToken));
}
if (NonceSeeker == null)
{
throw new NullReferenceException(nameof(NonceSeeker));
}
RaiseAPIAction("Getting Transactions");
var toApprove = await IriApi.GetTransactionsToApprove(Depth);
if (!toApprove.Successful)
{
return(toApprove.RePackage(r => new string[0]));
}
var trunk = toApprove.Result.TrunkTransaction;
var branch = toApprove.Result.BranchTransaction;
RaiseAPIAction("Performing POW");
var trytesToSend = await NonceSeeker.SearchNonce(transactionTrytes, trunk, branch, cancellationToken);
RaiseAPIAction("Broadcasting transaction");
await BroadcastAndStore(trytesToSend);
RaiseAPIAction("Transaction Sent.");
return(new APIResult <string[]>(trytesToSend));
}
