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
}
