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 void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction() { var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.TEST_NET); var generationHash = "AC87FDA8FD94B72F3D0790A7D62F248111BD5E37B95B16E4216DA99C212530A5"; var network = NetworkType.TEST_NET; var coginatory1 = Account.GenerateNewAccount(network); var coginatory2 = Account.GenerateNewAccount(network); var coginatories = new List <MultisigCosignatoryModification> { new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory1.PublicAccount), new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory2.PublicAccount), }; var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 1, coginatories, network); var signedTransaction = convertIntoMultisigTransaction.SignWith(account, generationHash); signedTransaction.Payload.Should().NotBeNullOrEmpty(); signedTransaction.Hash.Should().NotBeNullOrEmpty(); }
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 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 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 void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction() { var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.MIJIN_TEST); var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7"; var network = NetworkType.MIJIN_TEST; var coginatory1 = Account.GenerateNewAccount(network); var coginatory2 = Account.GenerateNewAccount(network); var coginatories = new List <MultisigCosignatoryModification> { new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory1.PublicAccount), new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory2.PublicAccount), }; var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 1, coginatories, network); var signedTransaction = convertIntoMultisigTransaction.SignWith(account, generationHash); signedTransaction.Payload.Should().NotBeNullOrEmpty(); signedTransaction.Hash.Should().NotBeNullOrEmpty(); }
public async Task Should_Add_Metadata_To_Namespace() { var namespaceName = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6); var namespaceId = new NamespaceId(namespaceName); var account = Fixture.SeedAccount; await Fixture.SiriusWebSocketClient.Listener.Open(); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1).Timeout(TimeSpan.FromSeconds(1000)); Log.WriteLine($"Going to generate namespace {namespaceId}"); var registerRootTransaction = RegisterNamespaceTransaction.CreateRootNamespace( Deadline.Create(), namespaceName, 100, Fixture.NetworkType ); var signedTransaction = account.Sign(registerRootTransaction, Fixture.GenerationHash); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; Log.WriteLine($"Request register namespace confirmed with transaction {result.TransactionInfo.Hash}"); var modifications = new List <MetadataModification> { MetadataModification.Add("company", "ProximaX"), MetadataModification.Add("department", "IT") }; var modifyMetadataTransaction = ModifyMetadataTransaction.CreateForNamespace( Deadline.Create(), namespaceId, modifications, Fixture.NetworkType); signedTransaction = account.Sign(modifyMetadataTransaction, Fixture.GenerationHash); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); result = await tx; Log.WriteLine($"Request add metadata to namespace confirmed with transaction {result.TransactionInfo.Hash}"); var metaInfo = await Fixture.SiriusClient.MetadataHttp.GetMetadataFromNamespace(namespaceId); metaInfo.Fields.Should().HaveCount(2); metaInfo.Type.Should().BeEquivalentTo(MetadataType.NAMESPACE); }
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_Convert_Account_To_2to2_MultiSig() { //account = Account.CreateFromPrivateKey("6681DC3BBEEEDF213160A27DDCA551B7AC8DC3BB79B8BDC059DD2CEA7B2E9C42", NetworkType); //cosignatory1 = Account.CreateFromPrivateKey("3B2B0AE238CF78E65E0F0B7110F7B4E73B8C56AB0282F98D22A39BB67D127609", NetworkType); Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}"); Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}"); // Define a modify multisig account transaction to increase the minAprovalDelta in one unit var modifyMultisigAccountTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 0, new List <MultisigCosignatoryModification> { }, Fixture.NetworkType); // Wrap the modify multisig account transaction in an aggregate transaction, // attaching the multisig public key as the signer var aggregateTransaction = AggregateTransaction.CreateComplete( Deadline.Create(), new List <Transaction> { modifyMultisigAccountTransaction.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 completed transaction {signedTransaction.Hash}"); // Announce the hash lock transaction await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); Thread.Sleep(2000); var confirmedTx = await cosignatory1ConfirmedTx; // verify the account is multisig var multiSigAcc = await Fixture.SiriusClient.AccountHttp.GetMultisigAccountInfo(Fixture.MultiSigAccount.Address); Log.WriteLine($"Multisig account {multiSigAcc}"); multiSigAcc.IsMultisig.Should().BeTrue(); multiSigAcc.MinApproval.Should().Be(2); multiSigAcc.MinRemoval.Should().Be(1); multiSigAcc.Cosignatories.Should().HaveCount(2); }
public async Task Should_Add_Metadata_To_Account() { var account = await Fixture.GenerateAccountWithCurrency(10000); Log.WriteLine($"Company Account {account.Address.Plain} \r\n Private Key: {account.PrivateKey} \r\n Public Key {account.PublicKey}"); // await Fixture.SiriusWebSocketClient.Listener.Open(); var metadatatrx = AccountMetadataTransaction.Create(Deadline.Create(), account.PublicAccount, "test", "test", "", Fixture.NetworkType); var aggregateTransaction = AggregateTransaction.CreateBonded( Deadline.Create(), new List <Transaction> { metadatatrx.ToAggregate(account.PublicAccount), }, Fixture.NetworkType); var aggregateTransactionsigned = account.Sign(aggregateTransaction, Fixture.GenerationHash); var hashLockTransaction = HashLockTransaction.Create( Deadline.Create(), //new Mosaic(new MosaicId("0BB1469B94E6FEF8"), 10), NetworkCurrencyMosaic.CreateRelative(10), (ulong)3650, aggregateTransactionsigned, Fixture.NetworkType); var hashLockTransactionSigned = account.Sign(hashLockTransaction, Fixture.GenerationHash); Log.WriteLine($"Going to announce hashlock transaction: {hashLockTransactionSigned.Hash}"); await Fixture.SiriusClient.TransactionHttp.Announce(hashLockTransactionSigned); var hashLocktx = Fixture.SiriusWebSocketClient.Listener .ConfirmedTransactionsGiven(account.Address).Take(1) .Timeout(TimeSpan.FromSeconds(500)); Fixture.WatchForFailure(hashLockTransactionSigned); var hashLockConfirmed = await hashLocktx; Log.WriteLine($"Request confirmed with hash lock transaction {hashLockConfirmed.TransactionInfo.Hash}"); Thread.Sleep(4000); Log.WriteLine($"Going to announce aggregate transaction {aggregateTransactionsigned.Hash}"); await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(aggregateTransactionsigned); Fixture.WatchForFailure(aggregateTransactionsigned); var aggregateTransactiontx = Fixture.SiriusWebSocketClient.Listener .ConfirmedTransactionsGiven(account.Address).Take(1) .Timeout(TimeSpan.FromSeconds(500)); //var aggregateTransactionConfirmed = await aggregateTransactiontx; //Log.WriteLine($" Request confirmed with aggregate transaction {aggregateTransactionConfirmed.TransactionInfo.Hash}"); }
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 Should_Add_Account_Filter_With_Block_Address() { var company = Account.GenerateNewAccount(Fixture.NetworkType); var blocked = Account.GenerateNewAccount(Fixture.NetworkType); var addressFilter = ModifyAccountPropertyTransaction <Address> .CreateForAddress( Deadline.Create(), (ulong)0, PropertyType.BLOCK_ADDRESS, new List <AccountPropertyModification <Address> >() { new AccountPropertyModification <Address>(PropertyModificationType.ADD, blocked.Address) }, Fixture.NetworkType); Log.WriteLine($"Going to filter the address {company.Address} "); await Fixture.SiriusWebSocketClient.Listener.Open(); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1) .Timeout(TimeSpan.FromSeconds(1000)); var signedTransaction = addressFilter.SignWith(company, Fixture.GenerationHash); Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}"); var accountProperties = await Fixture.SiriusClient.AccountHttp.GetAccountProperty(company.PublicAccount); accountProperties.Should().NotBeNull(); var blockAddressProperty = accountProperties.AccountProperties.Properties.Single(ap => ap.PropertyType == PropertyType.BLOCK_ADDRESS); blockAddressProperty.Should().NotBeNull(); var blockedAddress = blockAddressProperty.Values.Single(a => Address.CreateFromHex(a.ToString()).Plain == blocked.Address.Plain); blockedAddress.Should().NotBeNull(); }
public async Task Should_Convert_Account_To_2to2_MultiSig() { Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}"); Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}"); // Define a modify multisig account transaction to increase the minAprovalDelta in one unit var modifyMultisigAccountTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 0, new List <MultisigCosignatoryModification> { }, Fixture.NetworkType); // Wrap the modify multisig account transaction in an aggregate transaction, // attaching the multisig public key as the signer var aggregateTransaction = AggregateTransaction.CreateComplete( Deadline.Create(), new List <Transaction> { modifyMultisigAccountTransaction.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(8000)); var result = await cosignatory1ConfirmedTx; Log.WriteLine($"Going to announce aggregate completed transaction {result.TransactionInfo.Hash}"); // Announce the hash lock transaction await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); Thread.Sleep(5000); // verify the account is multisig var multiSigAcc = await Fixture.SiriusClient.AccountHttp.GetMultisigAccountInfo(Fixture.MultiSigAccount.Address); Log.WriteLine($"Multisig account {multiSigAcc}"); multiSigAcc.IsMultisig.Should().BeTrue(); multiSigAcc.MinApproval.Should().Be(2); multiSigAcc.MinRemoval.Should().Be(1); multiSigAcc.Cosignatories.Should().HaveCount(2); }
public async Task <MosaicId> CreateMosaic(Account account) { var nonce = MosaicNonce.CreateRandom(); var mosaicId = MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey); var mosaicDefinitionTransaction = MosaicDefinitionTransaction.Create( nonce, mosaicId, Deadline.Create(), MosaicProperties.Create( supplyMutable: true, transferable: true, levyMutable: false, divisibility: 0, duration: 1000 ), NetworkType); var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create( Deadline.Create(), mosaicDefinitionTransaction.MosaicId, MosaicSupplyType.INCREASE, 1000000, NetworkType); var aggregateTransaction = AggregateTransaction.CreateComplete( Deadline.Create(), new List <Transaction> { mosaicDefinitionTransaction.ToAggregate(account.PublicAccount), mosaicSupplyChangeTransaction.ToAggregate(account.PublicAccount) }, NetworkType); var signedTransaction = account.Sign(aggregateTransaction, GenerationHash); WatchForFailure(signedTransaction); var tx = SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1) .Timeout(TimeSpan.FromSeconds(3000)); await SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; return(mosaicId); }
public void Should_Serialize_And_Sign_LockFundTransaction() { var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.MIJIN_TEST); var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7"; var network = NetworkType.MIJIN_TEST; var multiSigAccount = Account.GenerateNewAccount(network); var coginatory1 = Account.GenerateNewAccount(network); var coginatory2 = Account.GenerateNewAccount(network); var coginatories = new List <MultisigCosignatoryModification> { new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory1.PublicAccount), new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory2.PublicAccount), }; var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 1, coginatories, network); var aggregateTransaction = AggregateTransaction.CreateBonded( Deadline.Create(), new List <Transaction> { convertIntoMultisigTransaction.ToAggregate(multiSigAccount.PublicAccount) }, network); var signedTransaction = multiSigAccount.Sign(aggregateTransaction, generationHash); var builder = new LockFundsTransactionBuilder(); builder.SetDeadline(Deadline.Create()) .SetDuration((ulong)700) .SetMosaic(NetworkCurrencyMosaic.CreateRelative(10)) .SetSignedTransaction(signedTransaction) .SetNetworkType(network); var hashLockTransaction = builder.Build(); var hashLockTransactionSigned = multiSigAccount.Sign(hashLockTransaction, generationHash); hashLockTransactionSigned.Payload.Should().NotBeNullOrEmpty(); hashLockTransactionSigned.Hash.Should().NotBeNullOrEmpty(); }
public void Should_Serialize_And_Sign_LockFundTransaction() { var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.TEST_NET); var generationHash = "AC87FDA8FD94B72F3D0790A7D62F248111BD5E37B95B16E4216DA99C212530A5"; var network = NetworkType.TEST_NET; var multiSigAccount = Account.GenerateNewAccount(network); var coginatory1 = Account.GenerateNewAccount(network); var coginatory2 = Account.GenerateNewAccount(network); var coginatories = new List <MultisigCosignatoryModification> { new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory1.PublicAccount), new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, coginatory2.PublicAccount), }; var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create( Deadline.Create(), 1, 1, coginatories, network); var aggregateTransaction = AggregateTransaction.CreateBonded( Deadline.Create(), new List <Transaction> { convertIntoMultisigTransaction.ToAggregate(multiSigAccount.PublicAccount) }, network); var signedTransaction = multiSigAccount.Sign(aggregateTransaction, generationHash); var builder = new LockFundsTransactionBuilder(); builder.SetDeadline(Deadline.Create()) .SetDuration((ulong)700) .SetMosaic(NetworkCurrencyMosaic.CreateRelative(10)) .SetSignedTransaction(signedTransaction) .SetNetworkType(network); var hashLockTransaction = builder.Build(); var hashLockTransactionSigned = multiSigAccount.Sign(hashLockTransaction, generationHash); hashLockTransactionSigned.Payload.Should().NotBeNullOrEmpty(); hashLockTransactionSigned.Hash.Should().NotBeNullOrEmpty(); }
private async Task <NamespaceInfo> GenerateNamespace(Account account, string namespaceName, NamespaceId parentId) { RegisterNamespaceTransaction registerNamespaceTransaction; if (parentId == null) { registerNamespaceTransaction = RegisterNamespaceTransaction.CreateRootNamespace( Deadline.Create(), namespaceName, 100, Fixture.NetworkType ); } else { registerNamespaceTransaction = RegisterNamespaceTransaction.CreateSubNamespace( Deadline.Create(), namespaceName, parentId, Fixture.NetworkType ); } var signedTransaction = account.Sign(registerNamespaceTransaction, Fixture.GenerationHash); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1) .Timeout(TimeSpan.FromSeconds(3000)); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); Log.WriteLine( $"Registered namespace {namespaceName} for account {account.Address.Plain} with transaction {signedTransaction.Hash}"); var result = await tx; Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}"); var expectedId = parentId != null?NamespaceId.CreateFromParent(namespaceName, parentId) : new NamespaceId(namespaceName); var namespaceInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId); Log.WriteLine( $"Retrieved namespace {namespaceName} successfully. The namespace HexId {namespaceInfo.Id.HexId}"); return(namespaceInfo); }
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_Add_Account_Filter_With_Allow_Entity_Type() { var company = Account.GenerateNewAccount(Fixture.NetworkType); var allowedTransType = EntityType.MODIFY_ACCOUNT_PROPERTY_ENTITY_TYPE; var accountFilter = ModifyAccountPropertyTransaction <EntityType> .CreateForEntityType( Deadline.Create(), (ulong)0, PropertyType.ALLOW_TRANSACTION, new List <AccountPropertyModification <EntityType> >() { new AccountPropertyModification <EntityType>(PropertyModificationType.ADD, allowedTransType) }, Fixture.NetworkType); Log.WriteLine($"Going to filter the address {company.Address} "); await Fixture.SiriusWebSocketClient.Listener.Open(); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1) .Timeout(TimeSpan.FromSeconds(1000)); var signedTransaction = accountFilter.SignWith(company, Fixture.GenerationHash); Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}"); var accountProperties = await Fixture.SiriusClient.AccountHttp.GetAccountProperty(company.PublicAccount); accountProperties.Should().NotBeNull(); var allowedTransactionProperty = accountProperties.AccountProperties.Properties.Single(ap => ap.PropertyType == PropertyType.ALLOW_TRANSACTION); var allowedTxType = allowedTransactionProperty.Values.Select(p => EntityTypeExtension.GetRawValue((int)p) == allowedTransType); allowedTxType.Should().NotBeNull(); }
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 Should_Add_Account_Filter_With_Allow_Entity_Type() { // var company = await Fixture.GenerateAccountWithCurrency(10000); var company = Account.CreateFromPrivateKey("101a4dfcffe3d5abddee535c0c7fa7bb386b99eb7c19f0c73cdc3837c5844477", Fixture.NetworkType); Log.WriteLine($"Company Account {company.Address.Plain} \r\n Private Key: {company.PrivateKey} \r\n Public Key {company.PublicKey}"); // var allowedMosaic = await Fixture.CreateMosaic(company); var allowedTransType = EntityType.TRANSFER; var accountFilter = ModifyAccountPropertyTransaction <EntityType> .CreateForEntityType( Deadline.Create(), (ulong)0, PropertyType.BLOCK_TRANSACTION, new List <AccountPropertyModification <EntityType> >() { new AccountPropertyModification <EntityType>(PropertyModificationType.ADD, allowedTransType) }, Fixture.NetworkType); Log.WriteLine($"Going to filter the address {company.Address} "); // await Fixture.SiriusWebSocketClient.Listener.Open(); // var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(company.Address).Take(1).Timeout(TimeSpan.FromSeconds(5000)); var signedTransaction = accountFilter.SignWith(Fixture.SeedAccount, Fixture.GenerationHash); Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); Log.WriteLine($"Transaction Payload {signedTransaction.Payload}"); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); // var result = await tx; // Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}"); var accountProperties = await Fixture.SiriusClient.AccountHttp.GetAccountProperty(company.Address); accountProperties.Should().NotBeNull(); var allowedTransactionProperty = accountProperties.AccountProperties.Properties.Single(ap => ap.PropertyType == PropertyType.BLOCK_TRANSACTION); var allowedTxType = allowedTransactionProperty.Values.Select(p => EntityTypeExtension.GetRawValue((int)p) == allowedTransType); allowedTxType.Should().NotBeNull(); }
public void ShouldUploadWithTransactionDeadlinesProvided() { var param = UploadParameter .CreateForStringUpload(TestString, AccountPrivateKey1) .WithTransactionDeadline(2) .Build(); var result = UnitUnderTest.Upload(param); Assert.IsNotNull(result); Assert.IsNotNull(result.TransactionHash); var transaction = WaitForTransactionConfirmation(AccountPrivateKey1, result.TransactionHash); Assert.IsTrue(transaction is TransferTransaction); Assert.IsTrue((transaction as TransferTransaction).Deadline.Ticks <= Deadline.Create(2).Ticks); LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithTransactionDeadlinesProvided"); }
public async Task Should_Add_Metadata_To_Address() { var account = Account.GenerateNewAccount(Fixture.NetworkType); await Fixture.SiriusWebSocketClient.Listener.Open(); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1) .Timeout(TimeSpan.FromSeconds(1000)); Log.WriteLine($"Generated account {account}"); var modifications = new List <MetadataModification> { MetadataModification.Add("productId", "123"), MetadataModification.Add("productName", "TestProduct") }; var modifyMetadataTransaction = ModifyMetadataTransaction.CreateForAddress( Deadline.Create(), account.Address, modifications, Fixture.NetworkType); var signedTransaction = account.Sign(modifyMetadataTransaction, Fixture.GenerationHash); Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}"); var metaInfo = await Fixture.SiriusClient.MetadataHttp.GetMetadataFromAddress(account.Address); metaInfo.Fields.Should().HaveCount(2); metaInfo.Type.Should().BeEquivalentTo(MetadataType.ADDRESS); }
private TransferTransaction CreateTransaction(Address recipientAddress, int transactionDeadline, List <Mosaic> transactionMosaics, IMessage message) { var mosaics = (transactionMosaics == null || transactionMosaics.Count <= 0) ? new List <Mosaic> { NetworkCurrencyMosaic.CreateRelative(0) } : transactionMosaics; var recipient = Recipient.From(recipientAddress); var builder = new TransferTransactionBuilder(); var transferTransaction = builder .SetNetworkType(BlockchainNetworkConnection.NetworkType) .SetDeadline(Deadline.Create(transactionDeadline)) .SetMosaics(mosaics) .SetRecipient(recipient) .SetMessage(message) .SetFeeCalculationStrategy(BlockchainNetworkConnection.FeeCalculationStrategy) .Build(); return(transferTransaction); }
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 async Task Should_UnLink_Account_From_Remote_Account() { var localAccount = Account.GenerateNewAccount(Fixture.NetworkType); var remoteAccount = Account.GenerateNewAccount(Fixture.NetworkType); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(localAccount.Address).Take(1); Log.WriteLine($"Local Account {localAccount.Address.Plain} \r\n Private Key: {localAccount.PrivateKey} \r\n Public Key {localAccount.PublicKey}"); Log.WriteLine($"Remote Account {remoteAccount.Address.Plain} \r\n Private Key: {remoteAccount.PrivateKey} \r\n Public Key {localAccount.PublicKey}"); var accountLinkTransaction = AccountLinkTransaction.Create(remoteAccount.PublicAccount, AccountLinkAction.LINK, Deadline.Create(), (ulong)0, Fixture.NetworkType); var signedTransaction = localAccount.Sign(accountLinkTransaction, Fixture.GenerationHash); Log.WriteLine($"Going to announce account link transaction {signedTransaction} with hash {signedTransaction.Hash}"); Fixture.WatchForFailure(signedTransaction); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; Log.WriteLine($"Transaction confirmed with public key {result.Signer.PublicKey}"); var localAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(localAccount.Address); var remoteAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(remoteAccount.Address); localAccountInfo.PublicKey.Should().BeEquivalentTo(remoteAccountInfo.LinkedAccountKey); remoteAccountInfo.PublicKey.Should().BeEquivalentTo(localAccountInfo.LinkedAccountKey); var accountUnLinkTransaction = AccountLinkTransaction.Create(remoteAccount.PublicAccount, AccountLinkAction.UNLINK, Deadline.Create(), (ulong)0, Fixture.NetworkType); var signedTransaction2 = localAccount.Sign(accountUnLinkTransaction, Fixture.GenerationHash); Log.WriteLine($"Going to announce account link transaction {signedTransaction2} with hash {signedTransaction2.Hash}"); Fixture.WatchForFailure(signedTransaction2); await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction2); var result2 = await tx; Log.WriteLine($"Request confirmed with public key {result2.Signer.PublicKey}"); var localAccountInfo2 = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(localAccount.Address); var remoteAccountInfo2 = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(remoteAccount.Address); localAccountInfo2.LinkedAccountKey.Should().BeEquivalentTo("0000000000000000000000000000000000000000000000000000000000000000"); remoteAccountInfo2.LinkedAccountKey.Should().BeEquivalentTo("0000000000000000000000000000000000000000000000000000000000000000"); }
public void Should_Throw_Exception_If_Deadline_Smaller_Than_Timestamp() { Action act = () => Deadline.Create(-2); act.Should().Throw <Exception>().WithMessage("Deadline should be greater than 0"); }
public async Task Should_Create_Aggregate_Root_And_SubNamespace() { var bobAccount = await Fixture.GenerateAccountWithCurrency(500); var rootNs = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6); var subNs = "subnp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6); var rootId = new NamespaceId(rootNs); var childId = new NamespaceId(rootNs + "." + subNs); Log.WriteLine($"Going to create aggregate root {rootId} and child namespace {childId}"); var registerRootTransaction = RegisterNamespaceTransaction.CreateRootNamespace( Deadline.Create(), rootNs, 100, Fixture.NetworkType ); var registerChildTransaction = RegisterNamespaceTransaction.CreateSubNamespace( Deadline.Create(), subNs, rootId, Fixture.NetworkType ); var aggregateTransaction = AggregateTransaction.CreateComplete( Deadline.Create(), new List <Transaction> { registerRootTransaction.ToAggregate(bobAccount.PublicAccount), registerChildTransaction.ToAggregate(bobAccount.PublicAccount) }, Fixture.NetworkType); var signedTransaction = bobAccount.Sign(aggregateTransaction, Fixture.GenerationHash); Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(bobAccount.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}"); result.TransactionType.Should().BeEquivalentTo(EntityType.AGGREGATE_COMPLETE); /* * var rootNsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(rootId).Timeout(_fixture.DefaultTimeout); * rootNsInfo.Should().NotBeNull(); * rootNsInfo.IsRoot.Should().BeTrue(); * * var subNsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(childId).Timeout(_fixture.DefaultTimeout); * subNsInfo.Should().NotBeNull(); * subNsInfo.IsSubNamespace.Should().BeTrue(); */ //Verify the root namespace and sub namespace owned by the account var nsInfos = await Fixture.SiriusClient.NamespaceHttp.GetNamespacesFromAccount(bobAccount.Address, null); nsInfos.Should().HaveCount(2); nsInfos.Single(ns => ns.Id.HexId == rootId.HexId).Should().NotBeNull(); nsInfos.Single(ns => ns.Id.HexId == childId.HexId).Should().NotBeNull(); //Verify the name of the namespaces var nsNames = await Fixture.SiriusClient.NamespaceHttp.GetNamespacesNames(new List <NamespaceId> { rootId, childId }); nsNames.Should().HaveCount(2); nsNames.Select(ns => ns.Name == rootId.Name).Should().NotBeNull(); nsNames.Select(ns => ns.Name == childId.Name).Should().NotBeNull(); }
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 }