public async Task AnnounceTransferTransactionWithMosaicWithMessage()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var account = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.MIJIN_TEST);
var transaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
account.Address,
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 100000000000)
},
PlainMessage.Create("hello")
).SignWith(keyPair);
listener.TransactionStatus(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST))
.Subscribe(e =>
{
Console.WriteLine(e.Status);
});
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
}
public static async Task getResponse()
{
try
{
Account account = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair = account.KeyPair;
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded("TB2Z7J-R2K3BZ-2TRS6D-H5747F-Y3XKUM-BNWCI4-BPDJ"),
new List <Mosaic> {
Xem.CreateRelative(10)
},
PlainMessage.Create("Well shit. W/ mosaic")
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction);
Console.WriteLine(response.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
public async Task AnnounceMultisigTransaction()
{
var cosignatory = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256");
var multisigAccount = PublicAccount.CreateFromPublicKey("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET);
var recipient = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.TEST_NET);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
recipient.Address,
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 1000000)
},
PlainMessage.Create("hello")
);
var multisigTransaction = MultisigTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(1),
transaction
).SignWith(cosignatory, multisigAccount);
var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(multisigTransaction);
Assert.AreEqual("SUCCESS", response.Message);
}
private static IMessage GetMessage(JObject msg)
{
try
{
var msgType = msg["type"].ToObject <int>();
var payload = msg["payload"].ToObject <string>().FromHex();
switch (MessageTypeExtension.GetRawValue(msgType))
{
case MessageType.PLAIN_MESSAGE:
if (payload.Length <= 0)
{
return(EmptyMessage.Create());
}
return(PlainMessage.Create(Encoding.UTF8.GetString(payload)));
case MessageType.SECURED_MESSAGE:
return(SecureMessage.CreateFromEncodedPayload(payload));
default:
return(EmptyMessage.Create());
}
}
catch (Exception)
{
return(EmptyMessage.Create());
}
}
public async Task <object> TestingTransfer(string from, string privateKey, string to, IAsset asset, decimal amount)
{
var nodeHttp = new NodeHttp(_nemUrl);
var networkType = await nodeHttp.GetNetworkType();
var networkTime = (int)(await nodeHttp.GetExtendedNodeInfo()).NisInfo.CurrentTime;
var toAddressParts = to.Split(AddressSeparator);
var message = toAddressParts.Length > 1
? PlainMessage.Create(toAddressParts[1]) as IMessage
: EmptyMessage.Create();
var mosaic = Mosaic.CreateFromIdentifier(asset.AssetId, (ulong)asset.ToBaseUnit(amount));
var fee = await TransferTransaction.CalculateFee(networkType, message, new[] { mosaic }, new NamespaceMosaicHttp(_nemUrl));
var tx = TransferTransaction.Create(
networkType,
new Deadline(networkTime + _expiresInSeconds),
fee.fee,
Address.CreateFromEncoded(toAddressParts[0]),
new List <Mosaic> {
mosaic
},
message,
networkTime);
var signed = tx.SignWith(KeyPair.CreateFromPrivateKey(privateKey));
var result = await new TransactionHttp(_nemUrl).Announce(signed);
return(result);
}
public static async System.Threading.Tasks.Task CreateTransactionAsync(int xpxAmount, List <Account> recipients)
{
foreach (var recipient in recipients)
{
var client = new SiriusClient("http://bctestnet1.brimstone.xpxsirius.io:3000");
var networkType = client.NetworkHttp.GetNetworkType().Wait();
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative((ulong)xpxAmount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
recipient.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("Transfered " + xpxAmount.ToString() + " successfully."),
NetworkType.TEST_NET
);
var generationHash = await client.BlockHttp.GetGenerationHash();
var signedTransaction = senderAccount.Sign(transferTransaction, generationHash);
await client.TransactionHttp.Announce(signedTransaction);
var newAccountInfo = await client.AccountHttp.GetAccountInfo(senderAccount.Address);
Console.WriteLine("Sent " + Convert.ToInt32(xpxAmount) + " XPX to: \n");
Console.WriteLine($"{nameof(newAccountInfo)} : {newAccountInfo}");
}
}
public async Task Should_Serialize_And_Sign_TransactionAsync()
{
var account2 = Account.CreateFromPrivateKey("D54AC0CB0FF50FB44233782B3A6B5FDE2F1C83B9AE2F1352119F93713F3AB923", NetworkType.TEST_NET);
// var nonce = MosaicNonce.CreateRandom();
var account = Account.CreateFromPrivateKey("feab2970d23c9a6f0170adf9b846575831c63084bcf1f0d7e70644818c546017", NetworkType.TEST_NET);
// var mosaicId = MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey);
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(1000);
var transferTransaction = TransferTransaction.Create(Deadline.Create(),
Recipient.From(Address.CreateFromRawAddress("VDVLDGVUEZ2X2CB5AZLOVHV6UK4DPCQHHWHCV75T")),
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("test-message"),
NetworkType.TEST_NET
);
var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7";
var signedTransaction = account.Sign(transferTransaction, generationHash);
//var payload = signedTransaction.Payload;
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
public void ShouldCreateAggregateTransactionAndSignWithMultipleCosignatories()
{
TransferTransaction transferTx = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new Address("SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC", NetworkType.Types.MIJIN_TEST),
new List <Mosaic>(),
PlainMessage.Create("test-message")
);
AggregateTransaction aggregateTx = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new List <Transaction>()
{
transferTx.ToAggregate(new PublicAccount("B694186EE4AB0558CA4AFCFDD43B42114AE71094F5A1FC4A913FE9971CACD21D", NetworkType.Types.MIJIN_TEST))
});
Account cosignatoryAccount = new Account("2a2b1f5d366a5dd5dc56c3c757cf4fe6c66e2787087692cf329d7a49a594658b", NetworkType.Types.MIJIN_TEST);
Account cosignatoryAccount2 = new Account("b8afae6f4ad13a1b8aad047b488e0738a437c7389d4ff30c359ac068910c1d59", NetworkType.Types.MIJIN_TEST);
SignedTransaction signedTransaction = cosignatoryAccount.SignTransactionWithCosignatories(aggregateTx, new List <Account>()
{
cosignatoryAccount2
});
Assert.AreEqual("2D010000", signedTransaction.Payload.Substring(0, 8));
Assert.AreEqual("5100000051000000", signedTransaction.Payload.Substring(240, 16));
}
public async Task <Account> GenerateAccountWithCurrency(ulong amount)
{
var account = Account.GenerateNewAccount(NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(amount);
var message = PlainMessage.Create("Send some money");
var tx = await Transfer(SeedAccount, account.Address, mosaic, message, GenerationHash);
return(account);
}
public async Task Should_Announce_Aggregate_Transaction_Signed_Aggregate_Transaction()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateAbsolute(1);
var message = PlainMessage.Create("c#__ SDK plain message test");
var result = await Fixture.AggregateTransfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
result.TransactionType.Should().Be(EntityType.AGGREGATE_COMPLETE);
}
internal static TransferTransaction CreateInnerTransferTransaction(String signer)
{
return(TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57DREOPYKUFX4OG7IQXKITMBWKD6KXTVBBQP"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
PlainMessage.Create("hey")));
}
public async Task <Account> GenerateAccountAndSendSomeMoney(int amount)
{
var networkType = Client.NetworkHttp.GetNetworkType().Wait();
var account = Account.GenerateNewAccount(networkType);
var money = (ulong)amount;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(money);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
account.Address,
new List <Mosaic>()
{
// mosaicToTransfer
},
PlainMessage.Create("transferTest"),
networkType);
var signedTransaction = SeedAccount.Sign(transferTransaction, Environment.GenerationHash);
WatchForFailure(signedTransaction);
try
{
await WebSocket.Listener.Open();
var tx = WebSocket.Listener.ConfirmedTransactionsGiven(account.Address).Take(1).Timeout(TimeSpan.FromSeconds(100));
await Client.TransactionHttp.Announce(signedTransaction);
var result = await tx;
if (result.IsConfirmed())
{
return(account);
}
else
{
throw new Exception($"Unable to send money to account {account.Address.Plain}");
}
}
finally
{
try
{
// WebSocket.Listener.Close();
}
catch (Exception)
{
//do nothing
}
}
}
public async Task Should_Announce_Transfer_Transaction_With_NetworkCurrencyMosaic_PlainMessage()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(10);
var message = PlainMessage.Create("Test message");
var result = await Fixture.Transfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
//result.TransactionType.Should().Be(EntityType.TRANSFER);
((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.PLAIN_MESSAGE.GetValueInByte());
}
internal static TransferTransaction CreateInnerTransferTransaction(string mosaic, ulong amount = 10)
{
return(TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier(mosaic, amount)
},
PlainMessage.Create("hey")
));
}
public async Task <TransactionResponse> Send(object data)
{
var cosignatory = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256");
var secondCosig = KeyPair.CreateFromPrivateKey("cfe47dd9801a5d4fe37183e8f6ca49fff532a2fe6fe099436df93b3d62fe17d5");
var multisigAccount = PublicAccount.CreateFromPublicKey("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET);
var recipient = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.TEST_NET);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
recipient.Address,
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 1000000)
},
PlainMessage.Create("hello")
);
var multisigTransaction = MultisigTransaction
.Create(NetworkType.Types.TEST_NET, Deadline.CreateHours(1), transaction)
.SignWith(cosignatory, multisigAccount);
TransactionResponse response = await new TransactionHttp(host).Announce(multisigTransaction);
var signatureTransaction = CosignatureTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(1),
"59f5f7cbbdaa996b8d3c45ce814280aab3b5d322a98fe95c00ae516cf436172d",
multisigAccount.Address
).SignWith(secondCosig);
TransactionResponse response2 = await new TransactionHttp(host).Announce(signatureTransaction);
//var localVarPath = "/transaction/announce";
//var client = new RestClient(host);
//var request = new RestRequest(localVarPath, Method.POST);
//request.AddParameter("application/json", data, ParameterType.RequestBody);
//var resp = client.Execute(request);
if (response.Status == "1")
{
TransactionInfo transactionInfo = new TransactionInfo
{
Id = 1, Hash = response.Hash, InnerHash = response.InnerHash
};
_transactionInfoRepository.AddTransaction(transactionInfo);
}
return(null);
}
public async Task Should_Send_Some_Money_To_New_Account()
{
var aliceAccount = await Fixture.GenerateAccountWithCurrency(500);
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(aliceAccount.Address).Take(1);
Log.WriteLine($"Alice Account {aliceAccount.Address.Plain} \r\n Private Key: {aliceAccount.PrivateKey} \r\n Public Key {aliceAccount.PublicKey}");
const ulong amount = (ulong)10;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(amount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
aliceAccount.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("transferTest"),
Fixture.NetworkType);
var signedTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to send {amount} XPP to {aliceAccount.Address.Pretty} with transaction {signedTransaction.Hash}");
Fixture.WatchForFailure(signedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with public key {result.Signer.PublicKey}");
var aliceAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(aliceAccount.Address);
aliceAccountInfo.Mosaics[0]?.Amount.Should().BeGreaterThan(0);
var outgoingTxs = Fixture.SiriusClient.AccountHttp.OutgoingTransactions(aliceAccountInfo.PublicAccount).Wait();
var recipientAddress = "VDG4WG-FS7EQJ-KFQKXM-4IUCQG-PXUW5H-DJVIJB-OXJG";
var address = Address.CreateFromRawAddress(recipientAddress);
var mosaicAmounts = (from TransferTransaction t in outgoingTxs
where t.TransactionType == EntityType.TRANSFER &&
t.Recipient.Address.Plain == address.Plain &&
t.Mosaics.Count == 1 &&
t.Mosaics[0].HexId == NetworkCurrencyMosaic.Id.HexId
select(long) t.Mosaics[0].Amount).ToList();
Console.WriteLine($"Total xpx send to account {address.Plain} is {mosaicAmounts.Sum()}");
}
protected IMessage RetrieveMessage(JObject msg)
{
if (msg["payload"].ToString().Substring(0, 2) == "fe" && Regex.IsMatch(msg["payload"].ToString(), @"\A\b[0-9a-fA-F]+\b\Z"))
{
return(new HexMessage(msg["payload"].ToString().FromHex()));
}
if (int.Parse(msg["type"].ToString()) == 1)
{
return(PlainMessage.Create(Encoding.UTF8.GetString(msg["payload"].ToString().FromHex())));
}
if (int.Parse(msg["type"].ToString()) == 2)
{
return(new SecureMessage(msg["payload"].ToString().FromHex()));
}
throw new Exception("invalid message type");
}
public async Task Should_Send_Money_From_Multsi_From_1To2_Cosignatory()
{
var recipient = Account.GenerateNewAccount(Fixture.NetworkType);
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
Log.WriteLine($"Recipient account {recipient}");
Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}");
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(recipient.Address),
new List <Mosaic> {
NetworkCurrencyMosaic.CreateAbsolute(10)
},
PlainMessage.Create("sending 10 prx.xpx"),
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction> {
transferTransaction.ToAggregate(Fixture.MultiSigAccount.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = Fixture.Cosignatory1.Sign(aggregateTransaction, Fixture.GenerationHash);
var cosignatory1ConfirmedTx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(Fixture.Cosignatory1.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(2000));
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await cosignatory1ConfirmedTx;
Thread.Sleep(5000);
if (result.IsConfirmed())
{
var recipientAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(recipient.Address);
Log.WriteLine($"Recipient info {recipientAccountInfo.Address}");
recipientAccountInfo.Mosaics.Should().HaveCount(1);
recipientAccountInfo.Mosaics[0].Amount.Should().Be(10);
}
}
public async Task AnnounceTransaction(ulong amount = 10)
{
var keyPair =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SCEYFB35CYFF2U7UZ32RYXXZ5JTPCSKU4P6BRXZR"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", amount)
},
PlainMessage.Create("hello")
).SignWith(keyPair);
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);
}
public async Task Should_Send_Some_Money_To_New_Account()
{
// var aliceAccount = await Fixture.GenerateAccountWithCurrency(100000);
var aliceAccount = Account.CreateFromPrivateKey("101a4dfcffe3d5abddee535c0c7fa7bb386b99eb7c19f0c73cdc3837c5844477", Fixture.NetworkType);
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(aliceAccount.Address).Take(1);
Log.WriteLine($"Alice Account {aliceAccount.Address.Plain} \r\n Private Key: {aliceAccount.PrivateKey} \r\n Public Key {aliceAccount.PublicKey}");
const ulong amount = (ulong)1000;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(amount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
aliceAccount.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("transferTest"),
Fixture.NetworkType);
var signedTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to send {amount} XPP to {aliceAccount.Address.Pretty} with transaction {signedTransaction.Hash}");
Fixture.WatchForFailure(signedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with public key {result.Signer.PublicKey}");
var aliceAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(aliceAccount.Address);
Log.WriteLine($"Alice Account Info: {aliceAccountInfo.Mosaics[0]}");
aliceAccountInfo.Mosaics[0]?.Amount.Should().BeGreaterThan(0);
var outgoingTxs = Fixture.SiriusClient.AccountHttp.OutgoingTransactions(PublicAccount.CreateFromPublicKey(result.Signer.PublicKey, Fixture.NetworkType)).Wait();
outgoingTxs.Transactions.Count().Should().BeGreaterThan(0);
Log.WriteLine($"Complete");
}
public IMessage CreateMessage(ProximaxMessagePayloadModel messagePayload, string senderPrivateKey,
string recipientPublicKeyRaw,
string recipientAddress, bool useBlockchainSecureMessage)
{
CheckParameter(messagePayload != null, "messagePayload is required");
var jsonPayload = messagePayload.ToJson();
if (useBlockchainSecureMessage)
{
var recipientPublicKey =
this.GetRecipientPublicKey(senderPrivateKey, recipientPublicKeyRaw, recipientAddress);
return(SecureMessage.Create(jsonPayload, senderPrivateKey, recipientPublicKey));
}
else
{
return(PlainMessage.Create(jsonPayload));
}
}
internal new TransferTransaction Apply(string input)
{
var tx = JsonConvert.DeserializeObject <TransferTransactionInfoDTO>(input);
var txInfo = TransactionInfo.Create(tx.Meta.Height, tx.Meta.Index, tx.Meta.Id, tx.Meta.Hash, tx.Meta.MerkleComponentHash);
var deadline = new Deadline(tx.Transaction.Deadline);
var mosaics = tx.Transaction.Mosaics.Select(m => new Mosaic(new MosaicId(BitConverter.ToUInt64(m.MosaicId.FromHex(), 0)), m.Amount)).ToList();
IMessage message;
try
{
message = PlainMessage.Create(Encoding.UTF8.GetString(tx.Transaction.Message.Payload.FromHex()));
}
catch (Exception)
{
try
{
message = PlainMessage.Create(tx.Transaction.Message.Payload);
}
catch (Exception)
{
message = EmptyMessage.Create();
}
}
return(new TransferTransaction(
ExtractNetworkType(tx.Transaction.Version),
ExtractTransactionVersion(tx.Transaction.Version),
deadline,
tx.Transaction.Fee,
Address.CreateFromEncoded(tx.Transaction.Recipient),
mosaics,
message,
tx.Transaction.Signature,
new PublicAccount(tx.Transaction.Signer, ExtractNetworkType(tx.Transaction.Version)),
txInfo
));
}
public void Should_Serialize_And_Sign_Transaction()
{
var mosaics = new List <Mosaic>()
{
new Mosaic((new MosaicId(992621222383397347)), 20)
};
var transferTransaction = TransferTransaction.Create(Deadline.Create(1),
Recipient.From(new Address("SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC", NetworkType.MIJIN_TEST)),
mosaics,
PlainMessage.Create("test-message"),
NetworkType.MIJIN_TEST,
0
);
var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.MIJIN_TEST);
var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7";
var signedTransaction = transferTransaction.SignWith(account, generationHash);
// var payload = signedTransaction.Payload;
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
public async Task Should_Announce_Transfer_Transaction_With_Default_Fee()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(10);
var message = PlainMessage.Create("Test message");
var builder = new TransferTransactionBuilder();
var transferTransaction = builder
.SetNetworkType(Fixture.NetworkType)
.SetDeadline(Deadline.Create())
.SetMosaics(new List <Mosaic>()
{
mosaic
})
.SetRecipient(Recipient.From(account.Address))
.SetMessage(message)
.SetFeeCalculationStrategy(FeeCalculationStrategyType.LOW)
.Build();
var signedTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(signedTransaction);
//Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(Fixture.SeedAccount.Address).Take(1);
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
//result.TransactionType.Should().Be(EntityType.TRANSFER);
((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.PLAIN_MESSAGE.GetValueInByte());
}
public static async Task <bool> TransferTest()
{
KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
TransferTransaction transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded("TBZQXJ-N7JNQL-N7ZAMC-HFFZAU-WBMPB4-4RMIZU-XKNQ"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 1000000)
},
PlainMessage.Create("Sr Alejo")
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
Console.WriteLine(signedTransaction.Hash);
Console.WriteLine(transaction.Fee);
TransactionResponse response = await
new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction);
return(true);
}
public async Task CanSignMultisigTransaction()
{
var cosignatory = new KeyPair("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256");
var secondCosig = new KeyPair("cfe47dd9801a5d4fe37183e8f6ca49fff532a2fe6fe099436df93b3d62fe17d5");
var multisigAccount = new PublicAccount("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET);
var recipient = new PrivateAccount("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.TEST_NET);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
recipient.Address,
new List <MosaicAmount> {
new MosaicAmount("nem:xem", 1000000)
},
PlainMessage.Create("hello")
);
var multisigTransaction = MultisigTransaction
.Create(NetworkType.Types.TEST_NET, Deadline.CreateHours(1), transaction)
.SignWith(cosignatory, multisigAccount);
var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(multisigTransaction);
Assert.AreEqual("SUCCESS", response.Message);
var signatureTransaction = CosignatureTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(1),
"59f5f7cbbdaa996b8d3c45ce814280aab3b5d322a98fe95c00ae516cf436172d",
multisigAccount.Address
).SignWith(secondCosig);
var response2 = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signatureTransaction);
Assert.AreEqual("FAILURE_MULTISIG_NO_MATCHING_MULTISIG", response2.Message);
}
public async Task <(string transactionContext, decimal fee, long expiration)> BuildTransactionAsync(Guid operationId,
IAsset asset, IReadOnlyList <IOperationAction> actions, bool includeFee)
{
// from one side NEM supports single sender and single receiver per transaction,
// from the other side we support single asset per transaction,
// finally only single transfers are allowed
if (actions.Count != 1)
{
throw new ArgumentException("Transaction must contain a single transfer only");
}
var nodeHttp = new NodeHttp(_nemUrl);
var networkType = await nodeHttp.GetNetworkType();
var action = actions[0];
var toAddressParts = action.To.Split(AddressSeparator);
var toAddress = toAddressParts[0];
var memo = toAddressParts.Length > 1
? toAddressParts[1]
: "";
var message = !string.IsNullOrEmpty(memo)
? PlainMessage.Create(memo) as IMessage
: EmptyMessage.Create();
var mosaic = Mosaic.CreateFromIdentifier(asset.AssetId, (ulong)asset.ToBaseUnit(action.Amount));
var fee = await TransferTransaction.CalculateFee(networkType, message, new[] { mosaic }, new NamespaceMosaicHttp(_nemUrl));
if (includeFee)
{
try
{
checked
{
if (mosaic.NamespaceName == Xem.NamespaceName &&
mosaic.MosaicName == Xem.MosaicName)
{
mosaic.Amount -= fee.fee;
}
// only single transfers are supported,
// so there must be single levy
var levy = fee.levies.SingleOrDefault();
if (levy != null &&
mosaic.NamespaceName == levy.NamespaceName &&
mosaic.MosaicName == levy.MosaicName)
{
mosaic.Amount -= levy.Amount;
}
}
}
catch (OverflowException)
{
throw new BlockchainException(BlockchainErrorCode.AmountIsTooSmall, "Amount is less than fee");
}
}
// check balances of FromAddress for all required assets
var fromAddress = action.From.Split(AddressSeparator)[0];
var owned = await new AccountHttp(_nemUrl).MosaicsOwned(Address.CreateFromEncoded(fromAddress));
var required = fee.levies
.Append(Xem.CreateAbsolute(fee.fee))
.Append(mosaic)
.GroupBy(m => new { m.NamespaceName, m.MosaicName })
.Select(g => new Mosaic(g.Key.NamespaceName, g.Key.MosaicName, g.Aggregate(0UL, (v, m) => v += m.Amount)))
.ToList();
foreach (var req in required)
{
var own = owned.FirstOrDefault(m => m.NamespaceName == req.NamespaceName && m.MosaicName == req.MosaicName)?.Amount ?? 0UL;
if (own < req.Amount)
{
throw new BlockchainException(BlockchainErrorCode.NotEnoughBalance,
$"Not enough {req.NamespaceName}:{req.MosaicName}");
}
}
var networkTime = (int)(await nodeHttp.GetExtendedNodeInfo()).NisInfo.CurrentTime;
var tx = TransferTransaction.Create(
networkType,
new Deadline(networkTime + _expiresInSeconds),
fee.fee,
Address.CreateFromEncoded(toAddress),
new List <Mosaic> {
mosaic
},
message,
networkTime);
return(
tx.ToJson(),
Convert.ToDecimal(fee.fee * 1e-6),
tx.Deadline.GetInstant()
);
}
public async Task Should_Link_Namespace_To_An_Account()
{
var company = Account.GenerateNewAccount(Fixture.NetworkType);
await Fixture.SiriusWebSocketClient.Listener.Open();
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1);
#region Create account and send some money to it
Log.WriteLine($"Alice Account {company.Address.Plain} \r\n Private Key: {company.PrivateKey} \r\n Public Key {company.PublicKey}");
const ulong amount = (ulong)150;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(amount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
company.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("transferTest"),
Fixture.NetworkType);
var signedTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to send {amount} XPP to {company.Address.Pretty} with transaction {signedTransaction.Hash}");
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with public key {result.Signer.PublicKey}");
var companyAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(company.Address);
Log.WriteLine($"Account {companyAccountInfo.Address.Plain} with initial mosaic {companyAccountInfo.Mosaics[0]}");
companyAccountInfo.Mosaics[0]?.Amount.Should().BeGreaterThan(0);
#endregion Create account and send some money to it
#region register new namespace
var namespaceName = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6);
var registerNamespaceTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
namespaceName,
10000,
Fixture.NetworkType
);
var registeredNsSignedTransaction = company.Sign(registerNamespaceTransaction, Fixture.GenerationHash);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(registeredNsSignedTransaction);
Log.WriteLine(
$"Registered namespace {namespaceName} for account {company.Address.Plain} with transaction {registeredNsSignedTransaction.Hash}");
result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var expectedId = new NamespaceId(namespaceName);
var nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
Log.WriteLine(
$"Retrieved namespace {namespaceName} successfully. The namespace HexId {nsInfo.Id.HexId}");
nsInfo.Should().NotBeNull();
companyAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(company.Address);
Log.WriteLine($"Account {companyAccountInfo.Address.Plain} with mosaic {companyAccountInfo.Mosaics[0]} after registered namespace");
#endregion register new namespace
#region Link namespace to the address
/*var addressAliasTransaction = AliasTransaction.CreateForAddress(
* company.Address,
* nsInfo.Id,
* AliasActionType.LINK,
* Deadline.Create(),
* Fixture.NetworkType
* );*/
var builder = AliasTransactionBuilder.CreateForAddress();
var addressAliasTransaction = builder
.SetNamespaceId(nsInfo.Id)
.SetDeadline(Deadline.Create())
.SetNetworkType(Fixture.NetworkType)
.SetFeeCalculationStrategy(FeeCalculationStrategyType.LOW)
.Link(company.Address)
.Build();
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1);
var aliasSignedTransaction = company.Sign(addressAliasTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(aliasSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(aliasSignedTransaction);
result = await tx;
Log.WriteLine($"Request confirmed with aliasSignedTransaction transaction {aliasSignedTransaction.Hash}");
nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
nsInfo.Should().NotBeNull();
nsInfo.HasAlias.Should().BeTrue();
nsInfo.Alias.Address.Plain.Should().BeEquivalentTo(company.Address.Plain);
#endregion Link namespace to the address
#region Send mosaic to namespace instead of address
transferTransaction = TransferTransaction.Create(
Deadline.Create(),
nsInfo.Id,
new List <Mosaic>()
{
NetworkCurrencyMosaic.CreateRelative(10)
},
PlainMessage.Create("Send to namespace"),
Fixture.NetworkType);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(Fixture.SeedAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
var nsSignedTransferTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(nsSignedTransferTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(nsSignedTransferTransaction);
var result2 = await tx;
Log.WriteLine($"Request confirmed with transaction {result2.TransactionInfo.Hash}");
companyAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(company.Address);
Log.WriteLine($"Account {companyAccountInfo.Address.Plain} with mosaic {companyAccountInfo.Mosaics[0]} after transfer to the alias");
//var expectedMosaicAmount = Convert.ToUInt64(Math.Pow(10, 6)) * (150 - 100 + 10);
companyAccountInfo.Mosaics[0]?.Amount.Should().BeGreaterThan(0);
#endregion Send mosaic to namespace instead of address
}
public async Task Should_Link_Namespace_To_Mosaic()
{
#region Create mosaic
var account = await Fixture.GenerateAccountWithCurrency(1500);
var nonce = MosaicNonce.CreateRandom();
var mosaicDefinitionTransaction = MosaicDefinitionTransaction.Create(
nonce,
MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey),
Deadline.Create(),
MosaicProperties.Create(
supplyMutable: true,
transferable: true,
levyMutable: false,
divisibility: 0,
duration: 1000
),
Fixture.NetworkType);
var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
Deadline.Create(),
mosaicDefinitionTransaction.MosaicId,
MosaicSupplyType.INCREASE,
1000000,
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
mosaicDefinitionTransaction.ToAggregate(account.PublicAccount),
mosaicSupplyChangeTransaction.ToAggregate(account.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = account.Sign(aggregateTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var mosaicInfo = await Fixture.SiriusClient.MosaicHttp.GetMosaic(mosaicDefinitionTransaction.MosaicId);
mosaicInfo.Should().NotBeNull();
mosaicInfo.Divisibility.Should().Be(0);
mosaicInfo.Duration.Should().Be(1000);
mosaicInfo.IsLevyMutable.Should().BeFalse();
mosaicInfo.IsSupplyMutable.Should().BeTrue();
mosaicInfo.IsTransferable.Should().BeTrue();
mosaicInfo.Supply.Should().Be(1000000);
#endregion
#region register new namespace
var namespaceName = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6);
var registerNamespaceTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
namespaceName,
100,
Fixture.NetworkType
);
var registeredNsSignedTransaction = account.Sign(registerNamespaceTransaction, Fixture.GenerationHash);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(registeredNsSignedTransaction);
Log.WriteLine(
$"Registered namespace {namespaceName} for account {account.Address.Plain} with transaction {registeredNsSignedTransaction.Hash}");
result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var expectedId = new NamespaceId(namespaceName);
var nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
Log.WriteLine(
$"Retrieved namespace {namespaceName} successfully. The namespace HexId {nsInfo.Id.HexId}");
nsInfo.Should().NotBeNull();
#endregion
#region Link namespace to the mosaic
var mosaicAliasTransaction = AliasTransaction.CreateForMosaic(
mosaicInfo.MosaicId,
nsInfo.Id,
AliasActionType.LINK,
Deadline.Create(),
Fixture.NetworkType
);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1);
var aliasSignedTransaction = account.Sign(mosaicAliasTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(aliasSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(aliasSignedTransaction);
result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
nsInfo.Should().NotBeNull();
nsInfo.HasAlias.Should().BeTrue();
nsInfo.Alias.Type.Should().BeEquivalentTo(AliasType.MOSAIC_ID);
nsInfo.Alias.MosaicId.HexId.Should().BeEquivalentTo(mosaicInfo.MosaicId.HexId);
#endregion
#region Send mosaic using namespace alias to recipient
var newAccount = Account.GenerateNewAccount(Fixture.NetworkType);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(newAccount.Address),
new List <Mosaic>()
{
new Mosaic(nsInfo.Id, 10)
},
PlainMessage.Create("Send some mosaic to new address"),
Fixture.NetworkType);
var tx2 = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(newAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
var nsSignedTransferTransaction = account.Sign(transferTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(nsSignedTransferTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(nsSignedTransferTransaction);
var result2 = await tx2;
Log.WriteLine($"Request confirmed with transaction {result2.TransactionInfo.Hash}");
var newAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(newAccount.Address);
Log.WriteLine($"Account {newAccountInfo.Address.Plain} with mosaic {newAccountInfo.Mosaics[0]} after transfer to the namespace alias");
var expectedMosaicAmount = Convert.ToUInt64(10);
newAccountInfo.Mosaics[0].Id.Id.Should().Be(mosaicInfo.MosaicId.Id);
newAccountInfo.Mosaics[0]?.Amount.Should().Be(expectedMosaicAmount);
#endregion
}
public void CanCreateMessage()
{
var plainMessage = PlainMessage.Create("Hello");
Assert.AreEqual("Hello", plainMessage.GetStringPayload());
}