/// <summary>
/// Converts the transaction to the corresponding trytes representation
/// </summary>
/// <returns></returns>
public string ToTransactionTrytes()
{
int[] valueTrits = Converter.ToTrits("" + Value, 81);
int[] timestampTrits = Converter.ToTrits("" + Timestamp, 27);
int[] currentIndexTrits = Converter.ToTrits("" + CurrentIndex, 27);
int[] lastIndexTrits = Converter.ToTrits("" + LastIndex, 27);
if (this.AttachmentTimestamp <= 0)
{
AttachmentTimestamp = IotaUtils.CreateAttachmentTimeStampNow();
}
return(SignatureFragment
+ Address
+ Converter.ToTrytes(valueTrits)
+ ObsoleteTag
+ Converter.ToTrytes(timestampTrits)
+ Converter.ToTrytes(currentIndexTrits)
+ Converter.ToTrytes(lastIndexTrits)
+ Bundle
+ TrunkTransaction
+ BranchTransaction
+ Tag
+ Converter.ToTrytes(Converter.ToTrits("" + this.AttachmentTimestamp, 27)) // AttachmentTime
+ Converter.ToTrytes(Converter.ToTrits("" + this.AttachmentTimestampLowerBound, 27)) // AttachmentLowerBound
+ Converter.ToTrytes(Converter.ToTrits("" + this.AttachmentTimestampUpperBound, 27)) // AttachmentUpperBound
+ Nonce);
}
public void GeneratedTryteTest()
{
var trytes = IotaUtils.GenerateRandomTrytes();
Assert.AreEqual(81, trytes.Length);
Assert.IsTrue(ContainsChars(trytes, Constants.TryteAlphabet));
}
public async Task <string> ApproveTransaction(string transactionHash, ApproveTransactionType approveType)
{
var api = CreateIotaClient();
//var address = await api.GetAddress(TestSeed2, 8);
var emptyAddress = IotaUtils.GenerateRandomTrytes(81); // "".Pad(81);
var transfer = new TransferItem()
{
Address = emptyAddress,
Value = 0,
Message = "",
Tag = ""
};
while (true)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
var transactions = transfer.CreateTransactions();
var trytesToPow = transactions.GetTrytes().Single();
var toApproveResult = await api.IriApi.GetTransactionsToApprove(9);
var toApprove = toApproveResult.Result;
var diver = new PowDiver();
cts.CancelAfter(20000);
var trunk = toApprove.TrunkTransaction;
var branch = toApprove.BranchTransaction;
if (approveType == ApproveTransactionType.Trunk)
{
trunk = transactionHash;
}
else
{
branch = transactionHash;
}
var trytesToSend = await diver.DoPow(trytesToPow.SetApproveTransactions(trunk, branch), 15, cts.Token);
await api.IriApi.BroadcastTransactions(trytesToSend);
await api.IriApi.StoreTransactions(trytesToSend);
var transaction = new TransactionItem(trytesToSend);
return(transaction.Hash);
}
catch (OperationCanceledException)
{
continue;
}
}
}
public void GenerateAddresses2()
{
Assert.AreEqual(ADDR_I0_S1, IotaUtils.GenerateAddress(ADDR_SEED, 0, 1).Address);
Assert.AreEqual(ADDR_I0_S2, IotaUtils.GenerateAddress(ADDR_SEED, 0, 2).Address);
Assert.AreEqual(ADDR_I0_S3, IotaUtils.GenerateAddress(ADDR_SEED, 0, 3).Address);
Assert.AreEqual(ADDR_LS_I0_S1, IotaUtils.GenerateAddress(ADDR_SEED + ADDR_SEED, 0, 1).Address);
Assert.AreEqual(ADDR_LS_I0_S2, IotaUtils.GenerateAddress(ADDR_SEED + ADDR_SEED, 0, 2).Address);
Assert.AreEqual(ADDR_LS_I0_S3, IotaUtils.GenerateAddress(ADDR_SEED + ADDR_SEED, 0, 3).Address);
}
public void CreateAddresses_FromSeed_CorrectAddressesReturned()
{
var seed = "ABM9ADN999VDXCHYJXDKUQITXAWQPBWZGYTBGTEIFWXOZTMHESEVHYLXWASWQFEJHUAKHIKSCA9AL9KMG";
for (int i = 0; i < 10; i++)
{
var address = IotaUtils.GenerateAddress(seed, i, 2, System.Threading.CancellationToken.None);
Console.WriteLine($"{i}: {address.AddressWithCheckSum}");
}
}
public void GenerateAddresses1()
{
var res1 = IotaUtils.GenerateAddress(TEST_SEED1, 0, 1).Address;
Assert.AreEqual(res1, TEST_ADDRESS_WITHOUT_CHECKSUM_SECURITY_LEVEL_1);
var res2 = IotaUtils.GenerateAddress(TEST_SEED1, 0, 2).Address;
Assert.AreEqual(res2, TEST_ADDRESS_WITHOUT_CHECKSUM_SECURITY_LEVEL_2);
var res3 = IotaUtils.GenerateAddress(TEST_SEED1, 0, 3).Address;
Assert.AreEqual(res3, TEST_ADDRESS_WITHOUT_CHECKSUM_SECURITY_LEVEL_3);
}
/// <summary>
/// Generates an address and gets transactions.
/// </summary>
/// <param name="seed">The seed from which an address should be generated</param>
/// <param name="index">The index of the address</param>
/// <param name="cancellationToken">The CancellationToken</param>
/// <returns></returns>
private async Task <AddressItem> GenerateAddressAsync(string seed, int index, CancellationToken cancellationToken)
{
await TaskIota.Yield().ConfigureAwait(false);
// need yield because new address generation is very costly
var addressItem = IotaUtils.GenerateAddress(seed, index, AddressSecurity, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
await RenewTransactions(addressItem);
return(addressItem);
}
public async Task SendVeryEmptyTransactionTest()
{
var api = CreateIotaClient();
var emptyAddress = IotaUtils.GenerateRandomTrytes(81); // "".Pad(81);
var transfer = new TransferItem()
{
Address = emptyAddress,
Value = 0,
Message = null,
Tag = null
};
while (true)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
var transactions = transfer.CreateTransactions();
var trytesToPow = transactions.GetTrytes().Single();
var toApproveResult = await api.IriApi.GetTransactionsToApprove(9);
var toApprove = toApproveResult.Result;
var diver = new PowDiver();
//cts.CancelAfter(15000);
var trunk = toApprove.TrunkTransaction;
var branch = toApprove.BranchTransaction;
var trytesToSend = await diver.DoPow(trytesToPow.SetApproveTransactions(trunk, branch), 15, cts.Token);
await api.IriApi.BroadcastTransactions(trytesToSend);
await api.IriApi.StoreTransactions(trytesToSend);
var transaction = new TransactionItem(trytesToSend);
}
catch (OperationCanceledException)
{
continue;
}
}
}
private static IEnumerable <TransactionItem> CreateDepositTransaction(TransferItem transferItem)
{
var timestamp = IotaUtils.CreateTimeStampNow().ToString();
var tag = transferItem.Tag.ValidateTrytes(nameof(transferItem.Tag)).Pad(27);
var messages = ChunksUpto(transferItem.Message, 2187).ToArray();
for (int i = 0; i < messages.Length; i++)
{
var message = messages[i].ValidateTrytes(nameof(transferItem.Message)).Pad(2187);
var transactionItem = new TransactionItem()
{
Address = transferItem.Address,
SignatureFragment = message,
Value = (i == 0 ? transferItem.Value : 0).ToString(),
Timestamp = timestamp,
Tag = tag,
};
yield return(transactionItem);
}
}
public void GerateAddressesWithChecksum()
{
Assert.AreEqual(FIRST_ADDR, IotaUtils.GenerateAddress(TEST_SEED, 0, 2).AddressWithCheckSum);
Assert.AreEqual(SIXTH_ADDR, IotaUtils.GenerateAddress(TEST_SEED, 5, 2).AddressWithCheckSum);
}
private static IEnumerable <TransactionItem> CreateWithdrawalTransactions(string tag, long withdrawAmount, string reminderAddress, params AddressItem[] addressItems)
{
if (string.IsNullOrWhiteSpace(reminderAddress))
{
throw new ArgumentNullException(nameof(reminderAddress));
}
tag = tag.ValidateTrytes(nameof(tag)).Pad(27);
foreach (var addressItem in addressItems)
{
if (addressItem.Balance <= 0)
{
continue;
}
var timestamp = IotaUtils.CreateTimeStampNow().ToString();
var amount = addressItem.Balance;
withdrawAmount -= amount;
var transactionItem = new TransactionItem()
{
Address = addressItem.Address,
Value = (-amount).ToString(), // withdraw all amount
Timestamp = timestamp,
Tag = tag
};
yield return(transactionItem);
transactionItem = new TransactionItem()
{
Address = addressItem.Address,
Value = "0",
Timestamp = timestamp,
Tag = tag
};
yield return(transactionItem);
if (withdrawAmount < 0) // deposit remind amount to reminder address
{
var message = "".Pad(2187);
transactionItem = new TransactionItem()
{
Address = reminderAddress,
Value = Math.Abs(withdrawAmount).ToString(),
Timestamp = timestamp,
SignatureFragment = message,
Tag = tag
};
yield return(transactionItem);
}
if (withdrawAmount <= 0)
{
break;
}
}
}
