private void TestSendMoney()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = new CreateTransactionByPublicKey(1440, Amount.OneNxt, TestSettings.Account1.PublicKey);
var sendMoneyReply = _accountService.SendMoney(parameters, TestSettings.Account2, Amount.OneNxt).Result;
_localTransactionService.VerifySendMoneyTransactionBytes(sendMoneyReply, parameters, TestSettings.Account2, Amount.OneNxt);
}
}
private void TestPublicKeyAnnouncement()
{
using (Logger = new TestsessionLogger(_logger))
{
const string account = "NXT-UJN3-RRHW-XPAC-2BTM8";
var parameters = new CreateTransactionByPublicKey(1440, Amount.OneNxt, TestSettings.Account1.PublicKey);
parameters.RecipientPublicKey = "9948dc7c342b685d41d8104c8fa66b9ae656078f84d8a08e317114165d71fc01";
var sendMoneyReply = _accountService.SendMoney(parameters, account, Amount.OneNxt).Result;
_localTransactionService.VerifySendMoneyTransactionBytes(sendMoneyReply, parameters, account, Amount.OneNxt);
}
}
private void TestSendEncryptedMessageToSelf()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = new CreateTransactionByPublicKey(1440, Amount.CreateAmountFromNxt(3), TestSettings.Account1.PublicKey);
parameters.EncryptedMessageToSelf = new AlreadyEncryptedMessageToSelf("01020304050607080910", "0102030405060708091011121314151617181920212223242526272829303132", true, true);
var sendMessageReply = _messageService.SendMessage(parameters, TestSettings.Account2).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, TestSettings.Account2);
parameters.EncryptedMessageToSelf = new AlreadyEncryptedMessageToSelf("01020304050607080910", "0102030405060708091011121314151617181920212223242526272829303132", false, false);
sendMessageReply = _messageService.SendMessage(parameters, TestSettings.Account2).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, TestSettings.Account2);
}
}
private async Task <TransactionCreatedReply> CreateUnsignedSendMoneyReply(Account recipient, Amount amount,
CreateTransactionParameters.UnencryptedMessage plainMessage,
CreateTransactionParameters.AlreadyEncryptedMessage encryptedMessage,
CreateTransactionParameters.AlreadyEncryptedMessageToSelf noteToSelfMessage)
{
var accountService = _serviceFactory.CreateAccountService();
var createTransactionByPublicKey = new CreateTransactionByPublicKey(1440, Amount.Zero, _walletRepository.NxtAccountWithPublicKey.PublicKey);
createTransactionByPublicKey.Message = plainMessage;
createTransactionByPublicKey.EncryptedMessage = encryptedMessage;
createTransactionByPublicKey.EncryptedMessageToSelf = noteToSelfMessage;
var sendMoneyReply = await accountService.SendMoney(createTransactionByPublicKey, recipient, amount);
return(sendMoneyReply);
}
private void TestPhasing()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = new CreateTransactionByPublicKey(1440, Amount.CreateAmountFromNxt(2), TestSettings.Account1.PublicKey);
parameters.Phasing = new CreateTransactionPhasing(TestSettings.MaxHeight + 100, VotingModel.Account, 1);
parameters.Phasing.WhiteListed.Add(TestSettings.Account2);
var sendMoneyReply = _accountService.SendMoney(parameters, TestSettings.Account2, Amount.OneNxt).Result;
_localTransactionService.VerifySendMoneyTransactionBytes(sendMoneyReply, parameters, TestSettings.Account2, Amount.OneNxt);
parameters = new CreateTransactionByPublicKey(1440, Amount.CreateAmountFromNxt(21), TestSettings.Account1.PublicKey);
parameters.Phasing = new CreateTransactionPhasing(TestSettings.MaxHeight + 100, VotingModel.Account, 100);
parameters.Phasing.MinBalanceModel = MinBalanceModel.Nqt;
parameters.Phasing.MinBalance = Amount.CreateAmountFromNxt(100).Nqt;
sendMoneyReply = _accountService.SendMoney(parameters, TestSettings.Account2, Amount.OneNxt).Result;
_localTransactionService.VerifySendMoneyTransactionBytes(sendMoneyReply, parameters, TestSettings.Account2, Amount.OneNxt);
}
}
public static void Main()
{
var monetarySystemService = new MonetarySystemService();
var transactionService = new TransactionService();
var localTransactionService = new LocalTransactionService();
// Get the unsigned transaction bytes from the NRS server
var parameters = new CreateTransactionByPublicKey(1440, Amount.Zero, SenderPublicKey);
var unsigned = monetarySystemService.TransferCurrency(Recipient, CurrencyId, Units, parameters).Result;
// Verify the unsigned transaction bytes from the node, will throw exception if bytes have been tampered with
localTransactionService.VerifyTransferCurrencyTransactionBytes(unsigned, parameters, Recipient, CurrencyId, Units);
// Sign the transaction locally and broadcast the signed bytes
var signed = localTransactionService.SignTransaction(unsigned, SecretPhrase);
var result = transactionService.BroadcastTransaction(new TransactionParameter(signed.ToString())).Result;
var transactionId = result.TransactionId;
Console.WriteLine($"Sent transaction: {transactionId}");
Console.ReadLine();
}
public static void Main()
{
var localMessageService = new LocalMessageService();
var localTransactionService = new LocalTransactionService();
var messageService = new MessageService();
var transactionService = new TransactionService();
const bool useCompression = true;
// Encrypt message to send locally
const string message = "Sending a permanent message";
var nonce = localMessageService.CreateNonce();
var encrypted = localMessageService.EncryptTextTo(RecipientPublicKey, message, nonce, useCompression, SecretPhrase);
// Encrypt message to self locally
const string messageToSelf = "Note to self: sending a permanent message";
var nonceToSelf = localMessageService.CreateNonce();
var encryptedToSelf = localMessageService.EncryptTextTo(SenderPublicKey, messageToSelf, nonceToSelf, useCompression, SecretPhrase);
// Prepare the transaction with your public key
var parameters = new CreateTransactionByPublicKey(1440, Amount.Zero, SenderPublicKey)
{
EncryptedMessage = new CreateTransactionParameters.AlreadyEncryptedMessage(encrypted, nonce, true, useCompression),
EncryptedMessageToSelf = new CreateTransactionParameters.AlreadyEncryptedMessageToSelf(encryptedToSelf, nonceToSelf, true, useCompression)
};
var unsigned = messageService.SendMessage(parameters, Recipient).Result;
// Verify the unsigned transaction bytes from the node (only needed if you cannot trust the node)
localTransactionService.VerifySendMessageTransactionBytes(unsigned, parameters, Recipient);
// Sign and broadcast
var signed = localTransactionService.SignTransaction(unsigned, SecretPhrase);
var result = transactionService.BroadcastTransaction(new TransactionParameter(signed.ToString())).Result;
var transactionId = result.TransactionId;
Console.WriteLine($"Sent transaction: {transactionId}");
Console.ReadLine();
}
private void TestSendMessage()
{
using (Logger = new TestsessionLogger(_logger))
{
var parameters = new CreateTransactionByPublicKey(1440, Amount.OneNxt, TestSettings.Account1.PublicKey);
parameters.Message = new CreateTransactionParameters.UnencryptedMessage("hello world!");
var sendMessageReply = _messageService.SendMessage(parameters, null).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, null);
parameters.Message = new CreateTransactionParameters.UnencryptedMessage(new byte[] { 1, 2, 3, 4, 5, 6, 7 });
sendMessageReply = _messageService.SendMessage(parameters, null).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, null);
parameters.Message = new CreateTransactionParameters.UnencryptedMessage("hello world!", true);
sendMessageReply = _messageService.SendMessage(parameters, null).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, null);
parameters.Message = new CreateTransactionParameters.UnencryptedMessage(new byte[] { 1, 2, 3, 4, 5, 6, 7 }, true);
sendMessageReply = _messageService.SendMessage(parameters, null).Result;
_localTransactionService.VerifySendMessageTransactionBytes(sendMessageReply, parameters, null);
}
}
private static Transaction VerifyCommonProperties(TransactionCreatedReply transactionCreatedReply, CreateTransactionByPublicKey parameters,
Account recipient, Amount amount, TransactionSubType transactionType)
{
var byteArray = transactionCreatedReply.UnsignedTransactionBytes.ToBytes().ToArray();
using (var stream = new MemoryStream(byteArray))
using (var reader = new BinaryReader(stream))
{
var transaction = new Transaction();
var type = reader.ReadByte(); // 1
var subtype = reader.ReadByte(); // 2
transaction.SubType = TransactionTypeMapper.GetSubType(type, (byte)(subtype & 0x0F));
transaction.Version = (subtype & 0xF0) >> 4;
transaction.Timestamp = new DateTimeConverter().GetFromNxtTime(reader.ReadInt32()); // 6
transaction.Deadline = reader.ReadInt16(); // 8
transaction.SenderPublicKey = new BinaryHexString(reader.ReadBytes(32)); // 40
transaction.Recipient = reader.ReadUInt64(); // 48
transaction.Amount = Amount.CreateAmountFromNqt(reader.ReadInt64()); // 56
transaction.Fee = Amount.CreateAmountFromNqt(reader.ReadInt64()); // 64
transaction.ReferencedTransactionFullHash = new BinaryHexString(reader.ReadBytes(32)); // 96
if (transaction.ReferencedTransactionFullHash.ToBytes().All(b => b == 0))
{
transaction.ReferencedTransactionFullHash = "";
}
reader.ReadBytes(64); // signature, 160
var flags = 0;
if (transaction.Version > 0)
{
flags = reader.ReadInt32(); // 164
transaction.EcBlockHeight = reader.ReadInt32(); // 168
transaction.EcBlockId = reader.ReadUInt64(); // 176
}
if (!transaction.SenderPublicKey.Equals(parameters.PublicKey))
{
throw new ValidationException(nameof(transaction.SenderPublicKey), parameters.PublicKey, transaction.SenderPublicKey);
}
if (parameters.Deadline != transaction.Deadline)
{
throw new ValidationException(nameof(transaction.Deadline), parameters.Deadline, transaction.Deadline);
}
if ((recipient?.AccountId ?? 0) != (transaction?.Recipient ?? 0))
{
throw new ValidationException(nameof(transaction.Recipient), recipient?.AccountId, transaction.Recipient);
}
if (!amount.Equals(transaction.Amount))
{
throw new ValidationException(nameof(transaction.Amount), amount, transaction.Amount);
}
if (parameters.ReferencedTransactionFullHash != null)
{
if (!parameters.ReferencedTransactionFullHash.Equals(transaction.ReferencedTransactionFullHash))
{
throw new ValidationException(nameof(transaction.ReferencedTransactionFullHash), parameters.ReferencedTransactionFullHash, transaction.ReferencedTransactionFullHash);
}
}
else if (transaction.ReferencedTransactionFullHash.ToHexString() != "")
{
throw new ValidationException(nameof(transaction.ReferencedTransactionFullHash), parameters.ReferencedTransactionFullHash, transaction.ReferencedTransactionFullHash);
}
var attachmentConverter = new AttachmentConverter(reader, (byte)transaction.Version);
transaction.Attachment = attachmentConverter.GetAttachment(transactionType);
var position = 1;
if ((flags & position) != 0 || (transaction.Version == 0 && transactionType == TransactionSubType.MessagingArbitraryMessage))
{
transaction.Message = new Message(reader, (byte)transaction.Version);
if (parameters.Message.MessageIsText != transaction.Message.IsText)
{
throw new ValidationException(nameof(transaction.Message.IsText), parameters.Message.MessageIsText, transaction.Message.IsText);
}
if (parameters.Message.MessageIsText && parameters.Message.Message != transaction.Message.MessageText)
{
throw new ValidationException(nameof(transaction.Message.MessageText), parameters.Message.Message, transaction.Message.MessageText);
}
if (!parameters.Message.MessageIsText && !transaction.Message.Data.Equals(parameters.Message.Message))
{
throw new ValidationException(nameof(transaction.Message.Data), parameters.Message.Message, transaction.Message.Data);
}
}
else if (parameters.Message != null && !parameters.Message.IsPrunable)
{
throw new ValidationException("Expected a message, but got null");
}
position <<= 1;
if ((flags & position) != 0)
{
transaction.EncryptedMessage = new EncryptedMessage(reader, (byte)transaction.Version);
var encryptedMessage = parameters.EncryptedMessage;
if (encryptedMessage.MessageIsText != transaction.EncryptedMessage.IsText)
{
throw new ValidationException(nameof(transaction.EncryptedMessage.IsText), encryptedMessage.MessageIsText, transaction.EncryptedMessage.IsText);
}
if (encryptedMessage.CompressMessage != transaction.EncryptedMessage.IsCompressed)
{
throw new ValidationException(nameof(transaction.EncryptedMessage.IsCompressed), encryptedMessage.CompressMessage, transaction.EncryptedMessage.IsCompressed);
}
if (!encryptedMessage.Message.Equals(transaction.EncryptedMessage.Data))
{
throw new ValidationException(nameof(transaction.EncryptedMessage.MessageToEncrypt), encryptedMessage.Message, transaction.EncryptedMessage.MessageToEncrypt);
}
if (encryptedMessage is AlreadyEncryptedMessage)
{
var alreadyEncryptedMessage = (AlreadyEncryptedMessage)parameters.EncryptedMessage;
if (!alreadyEncryptedMessage.Nonce.Equals(transaction.EncryptedMessage.Nonce))
{
throw new ValidationException(nameof(transaction.EncryptedMessage.Nonce), alreadyEncryptedMessage.Nonce, transaction.EncryptedMessage.Nonce);
}
}
}
else if (parameters.EncryptedMessage != null && !parameters.EncryptedMessage.IsPrunable)
{
throw new ValidationException("Expected an encrypted message, but got null");
}
position <<= 1;
if ((flags & position) != 0)
{
transaction.PublicKeyAnnouncement = new PublicKeyAnnouncement(reader, (byte)transaction.Version);
if (parameters.RecipientPublicKey != null && !parameters.RecipientPublicKey.Equals(transaction.PublicKeyAnnouncement.RecipientPublicKey))
{
throw new ValidationException(nameof(transaction.PublicKeyAnnouncement.RecipientPublicKey), parameters.RecipientPublicKey, transaction.PublicKeyAnnouncement.RecipientPublicKey);
}
}
position <<= 1;
if ((flags & position) != 0)
{
transaction.EncryptToSelfMessage = new EncryptToSelfMessage(reader, (byte)transaction.Version);
var encryptedMessage = parameters.EncryptedMessageToSelf;
if (encryptedMessage.MessageIsText != transaction.EncryptToSelfMessage.IsText)
{
throw new ValidationException(nameof(transaction.EncryptToSelfMessage.IsText), encryptedMessage.MessageIsText, transaction.EncryptToSelfMessage.IsText);
}
if (encryptedMessage.CompressMessage != transaction.EncryptToSelfMessage.IsCompressed)
{
throw new ValidationException(nameof(transaction.EncryptToSelfMessage.IsCompressed), encryptedMessage.CompressMessage, transaction.EncryptToSelfMessage.IsCompressed);
}
if (!encryptedMessage.Message.Equals(transaction.EncryptToSelfMessage.Data))
{
throw new ValidationException(nameof(transaction.EncryptToSelfMessage.MessageToEncrypt), encryptedMessage.Message, transaction.EncryptToSelfMessage.MessageToEncrypt);
}
if (encryptedMessage is AlreadyEncryptedMessageToSelf)
{
var alreadyEncryptedMessage = (AlreadyEncryptedMessageToSelf)parameters.EncryptedMessageToSelf;
if (!alreadyEncryptedMessage.Nonce.Equals(transaction.EncryptToSelfMessage.Nonce))
{
throw new ValidationException(nameof(transaction.EncryptToSelfMessage.Nonce), alreadyEncryptedMessage.Nonce, transaction.EncryptToSelfMessage.Nonce);
}
}
}
else if (parameters.EncryptedMessageToSelf != null)
{
throw new ValidationException("Expected an encrypted to self message, but got null");
}
position <<= 1;
if ((flags & position) != 0)
{
transaction.Phasing = new TransactionPhasing(reader, (byte)transaction.Version);
if (parameters.Phasing.FinishHeight != transaction.Phasing.FinishHeight)
{
throw new ValidationException(nameof(transaction.Phasing.FinishHeight), parameters.Phasing.FinishHeight, transaction.Phasing.FinishHeight);
}
if (parameters.Phasing.HashedSecret != null && !parameters.Phasing.HashedSecret.Equals(transaction.Phasing.HashedSecret))
{
throw new ValidationException(nameof(transaction.Phasing.HashedSecret), parameters.Phasing.HashedSecret, transaction.Phasing.HashedSecret);
}
if (parameters.Phasing.HashedSecretAlgorithm != transaction.Phasing.HashedSecretAlgorithm)
{
throw new ValidationException(nameof(transaction.Phasing.HashedSecretAlgorithm), parameters.Phasing.HashedSecretAlgorithm, transaction.Phasing.HashedSecretAlgorithm);
}
if (parameters.Phasing.HoldingId != transaction.Phasing.HoldingId)
{
throw new ValidationException(nameof(transaction.Phasing.HoldingId), parameters.Phasing.HoldingId, transaction.Phasing.HoldingId);
}
if (!Enumerable.SequenceEqual(parameters.Phasing.LinkedFullHash, transaction.Phasing.LinkedFullHashes))
{
throw new ValidationException(nameof(transaction.Phasing.LinkedFullHashes), parameters.Phasing.LinkedFullHash, transaction.Phasing.LinkedFullHashes);
}
if (parameters.Phasing.MinBalance != transaction.Phasing.MinBalance)
{
throw new ValidationException(nameof(transaction.Phasing.MinBalance), parameters.Phasing.MinBalance, transaction.Phasing.MinBalance);
}
if (parameters.Phasing.MinBalanceModel != transaction.Phasing.MinBalanceModel)
{
throw new ValidationException(nameof(transaction.Phasing.MinBalanceModel), parameters.Phasing.MinBalanceModel, transaction.Phasing.MinBalanceModel);
}
//if (parameters.Phasing.Phased != transaction.Phased)
//{
// throw new ValidationException(nameof(transaction.Phased), parameters.Phasing.Phased, transaction.Phased);
//}
if (parameters.Phasing.Quorum != transaction.Phasing.Quorum)
{
throw new ValidationException(nameof(transaction.Phasing.Quorum), parameters.Phasing.Quorum, transaction.Phasing.Quorum);
}
if (parameters.Phasing.VotingModel != transaction.Phasing.VotingModel)
{
throw new ValidationException(nameof(transaction.Phasing.VotingModel), parameters.Phasing.VotingModel, transaction.Phasing.VotingModel);
}
if (!Enumerable.SequenceEqual(parameters.Phasing.WhiteListed, transaction.Phasing.WhiteList))
{
throw new ValidationException(nameof(transaction.Phasing.WhiteList), parameters.Phasing.WhiteListed, transaction.Phasing.WhiteList);
}
}
else if (parameters.Phasing != null)
{
throw new ValidationException("Expected phasing, but got null");
}
position <<= 1;
if ((flags & position) != 0)
{
transaction.Message = new Message(reader, (byte)transaction.Version, true);
var expectedHash = HashPrunableMessage(parameters.Message.MessageIsText, parameters.Message.Message);
if (!expectedHash.Equals(transaction.Message.MessageHash))
{
throw new ValidationException(nameof(transaction.Message.MessageHash), expectedHash, transaction.Message.MessageHash);
}
}
else if (parameters.Message != null && parameters.Message.IsPrunable)
{
throw new ValidationException("Expected prunable message, but got null");
}
position <<= 1;
if ((flags & position) != 0)
{
var alreadyEncrypted = (AlreadyEncryptedMessage)parameters.EncryptedMessage;
transaction.EncryptedMessage = new EncryptedMessage(reader, (byte)transaction.Version, true);
var isText = new byte[] { (byte)(alreadyEncrypted.MessageIsText ? 1 : 0) };
var isCompressed = new byte[] { (byte)(alreadyEncrypted.CompressMessage ? 1 : 0) };
var messageBytes = alreadyEncrypted.Message.ToBytes().ToArray();
var nonceBytes = alreadyEncrypted.Nonce.ToBytes().ToArray();
var expectedHash = HashPrunableMessage(isText, isCompressed, messageBytes, nonceBytes);
if (!expectedHash.Equals(transaction.EncryptedMessage.EncryptedMessageHash))
{
throw new ValidationException(nameof(transaction.EncryptedMessage.EncryptedMessageHash), expectedHash, transaction.EncryptedMessage.EncryptedMessageHash);
}
}
else if (parameters.EncryptedMessage != null && parameters.EncryptedMessage.IsPrunable)
{
throw new ValidationException("Expected encrypted prunable message, but got null");
}
if (transaction.SubType != transactionType)
{
throw new ValidationException(nameof(transaction.SubType), transactionType, transaction.SubType);
}
return(transaction);
}
}
public void VerifyTransferAssetTransactionBytes(TransactionCreatedReply transactionCreatedReply, CreateTransactionByPublicKey parameters,
Account recipient, ulong assetId, long quantityQnt)
{
var transaction = VerifyCommonProperties(transactionCreatedReply, parameters, recipient, Amount.Zero, TransactionSubType.ColoredCoinsAssetTransfer);
var attachment = (ColoredCoinsAssetTransferAttachment)transaction.Attachment;
if (attachment.AssetId != assetId)
{
throw new ValidationException(nameof(attachment.AssetId), assetId, attachment.AssetId);
}
if (attachment.QuantityQnt != quantityQnt)
{
throw new ValidationException(nameof(attachment.QuantityQnt), quantityQnt, attachment.QuantityQnt);
}
}
public void VerifyTransferCurrencyTransactionBytes(TransactionCreatedReply transactionCreatedReply, CreateTransactionByPublicKey parameters,
Account recipient, ulong currencyId, long units)
{
var transaction = VerifyCommonProperties(transactionCreatedReply, parameters, recipient, Amount.Zero, TransactionSubType.MonetarySystemCurrencyTransfer);
var attachment = (MonetarySystemCurrencyTransferAttachment)transaction.Attachment;
if (attachment.CurrencyId != currencyId)
{
throw new ValidationException(nameof(attachment.CurrencyId), currencyId, attachment.CurrencyId);
}
if (attachment.Units != units)
{
throw new ValidationException(nameof(attachment.Units), units, attachment.Units);
}
}
public void VerifySendMessageTransactionBytes(TransactionCreatedReply transactionCreatedReply, CreateTransactionByPublicKey parameters,
Account recipient)
{
VerifyCommonProperties(transactionCreatedReply, parameters, recipient, Amount.Zero, TransactionSubType.MessagingArbitraryMessage);
}
public void VerifySendMoneyTransactionBytes(TransactionCreatedReply transactionCreatedReply, CreateTransactionByPublicKey parameters,
Account recipient, Amount amount)
{
VerifyCommonProperties(transactionCreatedReply, parameters, recipient, amount, TransactionSubType.PaymentOrdinaryPayment);
}
