public async Task ShouldFailSubNamespaceExists()
{
var signer =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = RegisterNamespaceTransaction.CreateSubNamespace(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
"happy",
"yooo")
.SignWith(signer);
listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST))
.Subscribe(
e =>
{
Assert.Fail("Success");
});
await new TransactionHttp(host).Announce(transaction);
var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == transaction.Hash).Take(1);
Assert.AreEqual("Failure_Namespace_Already_Exists", status.Status);
}
public async Task AggregateNamespaceRentalExtensionShouldSucceed()
{
var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = RegisterNamespaceTransaction.CreateRootNamespace(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
"happy",
10000)
.ToAggregate(PublicAccount.CreateFromPublicKey("B974668ABED344BE9C35EE257ACC246117EFFED939EAF42391AE995912F985FE", NetworkType.Types.MIJIN_TEST));
var agg = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>()
{
transaction
})
.SignWith(signer);
await new TransactionHttp(host).Announce(agg);
listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Subscribe(
e =>
{
Console.WriteLine(e.Status);
});
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == agg.Hash).Take(1);
Assert.AreEqual(signer.PublicKeyString, status.Signer.PublicKey);
}
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);
}
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);
}
private void ValidateNamespaceCreationTx(RegisterNamespaceTransaction transaction, string transactionDTO)
{
var tx = JsonConvert.DeserializeObject <NamespaceTransactionInfoDTO>(transactionDTO);
Assert.IsTrue(tx.Transaction.NamespaceType == transaction.NamespaceType.GetValue());
Assert.AreEqual(tx.Transaction.Name, transaction.NamespaceId.Name);
Assert.AreEqual(tx.Transaction.Name, transaction.NamespaceId.Name);
if (transaction.NamespaceType == NamespaceTypes.Types.RootNamespace)
{
Assert.AreEqual(tx.Transaction.Duration, transaction.Duration);
}
else
{
Assert.AreEqual(tx.Transaction.ParentId, transaction.ParentId.Id);
}
}
public async Task AggregateTransactionWithMissingCosignatures()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var keyPair2 = KeyPair.CreateFromPrivateKey(Config.PrivateKeySecond);
var aggregateTransaction = AggregateTransaction.CreateBonded(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
RegisterNamespaceTransaction.CreateRootNamespace(NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), "happy23", 10000)
.ToAggregate(PublicAccount.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem")
.ToAggregate(PublicAccount.CreateFromPublicKey(keyPair2.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
},
null
).SignWith(keyPair);
WatchForFailure(aggregateTransaction);
var hashLock = LockFundsTransaction.Create(NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), 0, new Mosaic(new MosaicId("nem:xem"), 10000000), 10000, aggregateTransaction)
.SignWith(KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain));
WatchForFailure(hashLock);
await new TransactionHttp(host).Announce(hashLock);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(hashLock.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == hashLock.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
await new TransactionHttp(host).AnnounceAggregateBonded(aggregateTransaction);
var status2 = await listener.AggregateBondedAdded(Address.CreateFromPublicKey(aggregateTransaction.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateTransaction.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status2.Signer.PublicKey);
}
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
}
public async Task Should_Add_Metadata_To_Namespace()
{
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}");
var rootNs = "namespace_metadata_test";
var rootId = new NamespaceId(rootNs);
var registerRootTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
rootNs,
3650,
Fixture.NetworkType);
var aggregateTransactiontx = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
registerRootTransaction.ToAggregate(account.PublicAccount),
},
Fixture.NetworkType);
var aggregateTransactionsigned = account.Sign(aggregateTransactiontx, Fixture.GenerationHash);
await Fixture.SiriusWebSocketClient.Listener.Open();
Log.WriteLine($"Going to announce aggregate transaction: {aggregateTransactionsigned.Hash}");
await Fixture.SiriusClient.TransactionHttp.Announce(aggregateTransactionsigned);
/*var aggregateTransactiontxs = Fixture.SiriusWebSocketClient.Listener
* .ConfirmedTransactionsGiven(account.Address).Take(1)
* .Timeout(TimeSpan.FromSeconds(500));
*
* var aggregateTransactionConfirmed = await aggregateTransactiontxs;
* Log.WriteLine($" Request confirmed with aggregate transaction {aggregateTransactionConfirmed.TransactionInfo.Hash}");*/
var metadatatrx = NamespaceMetadataTransaction.Create(
Deadline.Create(),
account.PublicAccount,
rootId,
"test_Namespace",
"1",
"",
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateBonded(
Deadline.Create(),
new List <Transaction>
{
metadatatrx.ToAggregate(account.PublicAccount),
},
Fixture.NetworkType);
var aggregateTrxsigned = account.Sign(aggregateTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(aggregateTrxsigned);
/* Log.WriteLine($" {aggregateTransactionConfirmed.TransactionType}Request confirmed with aggregate transaction {aggregateTransactionConfirmed.TransactionInfo.Hash}");*/
var hashLockTransaction = HashLockTransaction.Create(
Deadline.Create(),
//new Mosaic(new MosaicId("0BB1469B94E6FEF8"), 10),
NetworkCurrencyMosaic.CreateRelative(10),
(ulong)3650,
aggregateTrxsigned,
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}");
Log.WriteLine($"Going to announce aggregate transaction {aggregateTrxsigned.Hash}");
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(aggregateTrxsigned);
Fixture.WatchForFailure(aggregateTrxsigned);
var aggregateTrntx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(500));
var aggregateTrxConfirmed = await aggregateTrntx;
Log.WriteLine($"Request confirmed with aggregate transaction {aggregateTrxConfirmed.TransactionInfo.Hash}");
}
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
}
