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 static async Task <bool> SendFromNewAccount(String message, Account newAcc)
{
KeyPair keyPair = KeyPair.CreateFromPrivateKey(newAcc.PrivateKey);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded(Config.Address),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
SecureMessage.Create(message, newAcc.PrivateKey, Config.PublicKey)
);
TransactionHttp transactionHttp = new TransactionHttp("http://" + Config.Domain + ":7890");
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
Thread.Sleep(2000);
await transactionHttp.Announce(signedTransaction);
Thread.Sleep(2000);
Console.WriteLine(signedTransaction.Hash);
Console.WriteLine(Config.Address + " recve something from : " + newAcc.Address.Plain);
return(true);
}
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 <Transaction> AggregateTransfer(Account from, Address to, Mosaic mosaic, IMessage message, string GenerationHash)
{
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(to),
new List <Mosaic>()
{
mosaic
},
message,
NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
transferTransaction.ToAggregate(from.PublicAccount)
}, NetworkType);
var signedTransaction = from.Sign(aggregateTransaction, GenerationHash);
WatchForFailure(signedTransaction);
var tx = SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(from.Address).Take(1);
await SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
return(result);
}
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 <Transaction> Transfer(Account from, Address to, Mosaic mosaic, IMessage message, string generationHash)
{
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(to),
new List <Mosaic>()
{
mosaic
},
message,
NetworkType);
var signedTransaction = from.Sign(transferTransaction, generationHash);
WatchForFailure(signedTransaction);
//Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(from.Address).Take(1);
await SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
return(result);
}
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);
}
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 async Task AnnounceTransferTransactionWithMultipleMosaicsWithoutMessage()
{
var keyPair =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"),
new List <Mosaic>()
{
Mosaic.CreateFromIdentifier("happy:test2", 10),
Mosaic.CreateFromIdentifier("nem:xem", 10),
},
EmptyMessage.Create()
).SignWith(keyPair);
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);
listener.TransactionStatus(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST))
.Subscribe(e => Console.WriteLine(e.Status));
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 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 static async Task getResponse()
{
try
{
Account sender = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair1 = sender.KeyPair;
Account reciever = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair2 = reciever.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(1)
},
SecureMessage.Create("Well shit. W/ mosaic", sender.PrivateKey, reciever.PublicKey)
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair1);
TransactionResponse response = await new TransactionHttp(host).Announce(signedTransaction);
Console.WriteLine(response.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
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 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
}
}
}
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")));
}
private TransferTransaction CreateTransaction(Address recipientAddress, int transactionDeadline,
List <Mosaic> transactionMosaics, IMessage message)
{
return(TransferTransaction.Create(
BlockchainNetworkConnection.NetworkType,
Deadline.CreateHours(transactionDeadline),
recipientAddress,
transactionMosaics ?? new List <Mosaic> {
new Mosaic(new MosaicId("prx:xpx"), 1)
},
message));
}
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()}");
}
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_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 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 async Task AnnounceTransferTransactionWithMosaicWithSecureMessage()
{
var keyPair = new KeyPair(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
new Address("TAVPDJ-DR3R3X-4FJUKN-PY2IQB-NNRFV2-QR5NJZ-J3WR"),
new List <MosaicAmount> {
new MosaicAmount("nem:xem", 10)
},
SecureMessage.Create("hello2", Config.PrivateKeyMain, "4cc7409929a72019240065c9e53aa339f87ba889238ff9fbe978251fdbb05d9f")
).SignWith(keyPair);
var response = await new TransactionHttp(host).Announce(transaction);
Assert.AreEqual("SUCCESS", response.Message);
}
// [TestMethod]
public void ShouldSignTransaction()
{
Account account = new Account("787225aaff3d2c71f4ffa32d4f19ec4922f3cd869747f267378f81f8e3fcb12d", NetworkType.Types.MIJIN_TEST);
TransferTransaction transferTransaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(0),
Address.CreateFromEncoded("SDUP5PLHDXKBX3UU5Q52LAY4WYEKGEWC6IB3VBFM"),
new List <Mosaic>()
{
new Mosaic(new MosaicId("nem:xem"), 100)
},
EmptyMessage.Create()
);
SignedTransaction signedTransaction = account.Sign(transferTransaction);
Assert.AreEqual("A50000003400097BF12505E4138374A1B5AFB01E183F53F5EF1416C0D1E84BBE8CA29819722063922E8006B7738080DF1BDA819BF4D937765E941D025BE1C61B345975061026D70E1954775749C6811084D6450A3184D977383F0E4282CD47118AF37755039054410000000000000000000000000000000090E8FEBD671DD41BEE94EC3BA5831CB608A312C2F203BA84AC0100010029CF5FD941AD25D56400000000000000", signedTransaction.Payload);
Assert.AreEqual("4877AFCC92D1CCA47FDB65F1E7B70BB25D196287E8C9177BCF46F644887B7BA3", signedTransaction.Hash);
}
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithoutMessage()
{
var keyPair =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"),
new List <Mosaic>()
{
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
EmptyMessage.Create()
).SignWith(keyPair);
var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(transaction);
Assert.AreEqual("SUCCESS", response.Message);
}
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithoutMessage()
{
var keyPair =
new KeyPair(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
new Address("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"),
new List <MosaicAmount>()
{
new MosaicAmount("nem:xem", 10)
},
EmptyMessage.Create()
).SignWith(keyPair);
var response = await new TransactionHttp(host).Announce(transaction);
Assert.AreEqual("SUCCESS", response.Message);
}
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithSecureMessage()
{
var keyPair =
new KeyPair(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
new Address("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"),
new List <MosaicAmount>()
{
new MosaicAmount("nem:xem", 1000),
//Mosaic.CreateFromIdentifier("nis1porttest:test", 10), TODO: fix multiple mosaic transfer
},
SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068")
).SignWith(keyPair);
var response = await new TransactionHttp(host).Announce(transaction);
Assert.AreEqual("SUCCESS", response.Message);
}
public async Task AnnounceTransferTransactionWithMosaicWithMessage()
{
KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
TransferTransaction transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded("TACOPE-XRLZTU-WBQA3U-XV66R4-55L76E-NWK6OY-ITBJ"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 1)
},
EmptyMessage.Create()
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
Console.WriteLine(signedTransaction.Hash);
Console.WriteLine(transaction.Fee);
TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction);
Assert.AreEqual("SUCCESS", response.Message);
}
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 AnnounceTransferTransactionWithMosaicWithMessage()
{
KeyPair keyPair = new KeyPair(Config.PrivateKeyMain);
TransferTransaction transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
new Address("TACOPE-XRLZTU-WBQA3U-XV66R4-55L76E-NWK6OY-ITBJ"),
new List <MosaicAmount> {
new MosaicAmount("nem:xem", 1)
},
EmptyMessage.Create()
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
Console.WriteLine(signedTransaction.Hash);
Console.WriteLine(transaction.Fee);
TransactionResponse response = await new TransactionHttp(host).Announce(signedTransaction);
Assert.AreEqual("SUCCESS", response.Message);
}
public async Task AnnounceTransferTransactionWithMosaicWithSecureMessage()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068")
).SignWith(keyPair);
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);
listener.TransactionStatus(Address.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.MIJIN_TEST))
.Subscribe(e => Console.WriteLine(e.Status));
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
}
