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 async Task <Account> GenerateAccountWithCurrency(ulong amount)
{
var account = Account.GenerateNewAccount(NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(amount);
var message = PlainMessage.Create("Send some money");
var tx = await Transfer(SeedAccount, account.Address, mosaic, message, GenerationHash);
return(account);
}
public async Task Should_Announce_Aggregate_Transaction_Signed_Aggregate_Transaction()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateAbsolute(1);
var message = PlainMessage.Create("c#__ SDK plain message test");
var result = await Fixture.AggregateTransfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
result.TransactionType.Should().Be(EntityType.AGGREGATE_COMPLETE);
}
public async Task <Account> GenerateAccountAndSendSomeMoney(int amount)
{
var networkType = Client.NetworkHttp.GetNetworkType().Wait();
var account = Account.GenerateNewAccount(networkType);
var money = (ulong)amount;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(money);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
account.Address,
new List <Mosaic>()
{
// mosaicToTransfer
},
PlainMessage.Create("transferTest"),
networkType);
var signedTransaction = SeedAccount.Sign(transferTransaction, Environment.GenerationHash);
WatchForFailure(signedTransaction);
try
{
await WebSocket.Listener.Open();
var tx = WebSocket.Listener.ConfirmedTransactionsGiven(account.Address).Take(1).Timeout(TimeSpan.FromSeconds(100));
await Client.TransactionHttp.Announce(signedTransaction);
var result = await tx;
if (result.IsConfirmed())
{
return(account);
}
else
{
throw new Exception($"Unable to send money to account {account.Address.Plain}");
}
}
finally
{
try
{
// WebSocket.Listener.Close();
}
catch (Exception)
{
//do nothing
}
}
}
public async Task Should_Announce_Transfer_Transaction_With_NetworkCurrencyMosaic_PlainMessage()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(10);
var message = PlainMessage.Create("Test message");
var result = await Fixture.Transfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
//result.TransactionType.Should().Be(EntityType.TRANSFER);
((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.PLAIN_MESSAGE.GetValueInByte());
}
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 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();
}
public async Task Should_Announce_Transfer_Transaction_With_NetworkCurrencyMosaic_SecureMessage()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
Log.WriteLine($"Reciever private key {account.KeyPair.PrivateKeyString}, reciever public key {account.PublicAccount.PublicKey}");
var mosaic = NetworkCurrencyMosaic.CreateRelative(10);
Log.WriteLine($"Sender private key {Fixture.SeedAccount.KeyPair.PrivateKeyString}, sender public key {Fixture.SeedAccount.PublicAccount.PublicKey}");
var message = SecureMessage.Create("Test secure message", Fixture.SeedAccount.KeyPair.PrivateKeyString, account.PublicAccount.PublicKey);
var result = await Fixture.Transfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
//result.TransactionType.Should().Be(EntityType.TRANSFER);
((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.SECURED_MESSAGE.GetValueInByte());
}
public async Task Should_Send_Money_From_Multsi_From_1To2_Cosignatory()
{
var recipient = Account.GenerateNewAccount(Fixture.NetworkType);
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
Log.WriteLine($"Recipient account {recipient}");
Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}");
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(recipient.Address),
new List <Mosaic> {
NetworkCurrencyMosaic.CreateAbsolute(10)
},
PlainMessage.Create("sending 10 prx.xpx"),
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction> {
transferTransaction.ToAggregate(Fixture.MultiSigAccount.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = Fixture.Cosignatory1.Sign(aggregateTransaction, Fixture.GenerationHash);
var cosignatory1ConfirmedTx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(Fixture.Cosignatory1.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(2000));
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await cosignatory1ConfirmedTx;
Thread.Sleep(5000);
if (result.IsConfirmed())
{
var recipientAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(recipient.Address);
Log.WriteLine($"Recipient info {recipientAccountInfo.Address}");
recipientAccountInfo.Mosaics.Should().HaveCount(1);
recipientAccountInfo.Mosaics[0].Amount.Should().Be(10);
}
}
public async Task Should_Send_Some_Money_To_New_Account()
{
// var aliceAccount = await Fixture.GenerateAccountWithCurrency(100000);
var aliceAccount = Account.CreateFromPrivateKey("101a4dfcffe3d5abddee535c0c7fa7bb386b99eb7c19f0c73cdc3837c5844477", Fixture.NetworkType);
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(aliceAccount.Address).Take(1);
Log.WriteLine($"Alice Account {aliceAccount.Address.Plain} \r\n Private Key: {aliceAccount.PrivateKey} \r\n Public Key {aliceAccount.PublicKey}");
const ulong amount = (ulong)1000;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(amount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
aliceAccount.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("transferTest"),
Fixture.NetworkType);
var signedTransaction = Fixture.SeedAccount.Sign(transferTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to send {amount} XPP to {aliceAccount.Address.Pretty} with transaction {signedTransaction.Hash}");
Fixture.WatchForFailure(signedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with public key {result.Signer.PublicKey}");
var aliceAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(aliceAccount.Address);
Log.WriteLine($"Alice Account Info: {aliceAccountInfo.Mosaics[0]}");
aliceAccountInfo.Mosaics[0]?.Amount.Should().BeGreaterThan(0);
var outgoingTxs = Fixture.SiriusClient.AccountHttp.OutgoingTransactions(PublicAccount.CreateFromPublicKey(result.Signer.PublicKey, Fixture.NetworkType)).Wait();
outgoingTxs.Transactions.Count().Should().BeGreaterThan(0);
Log.WriteLine($"Complete");
}
public void ShouldUploadWithTransactionMosaicsProvided()
{
var param = UploadParameter
.CreateForStringUpload(TestString, AccountPrivateKey1)
.WithTransactionMosaics(new List <Mosaic> {
NetworkCurrencyMosaic.CreateAbsolute(2)
})
.Build();
var result = UnitUnderTest.Upload(param);
var transaction = WaitForTransactionConfirmation(AccountPrivateKey1, result.TransactionHash);
Assert.IsTrue(transaction is TransferTransaction);
Assert.AreEqual((transaction as TransferTransaction).Mosaics.Count, 1);
Assert.AreEqual((transaction as TransferTransaction).Mosaics[0].HexId, new MosaicId("0dc67fbe1cad29e3").HexId);
Assert.AreEqual((transaction as TransferTransaction).Mosaics[0].Amount, (ulong)2);
LogAndSaveResult(result, GetType().Name + ".ShouldUploadWithTransactionMosaicsProvided");
}
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 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_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_Mosaic()
{
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 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: 6,
duration: 0
),
Fixture.NetworkType);
Log.WriteLine($"Going to create mosaic {mosaicDefinitionTransaction.MosaicId.HexId}");
var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
Deadline.Create(),
mosaicDefinitionTransaction.MosaicId,
MosaicSupplyType.INCREASE,
1000,
Fixture.NetworkType);
var aggregateTransactiontx = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
mosaicDefinitionTransaction.ToAggregate(account.PublicAccount),
mosaicSupplyChangeTransaction.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 metadatatrx = MosaicMetadataTransaction.Create(
Deadline.Create(),
account.PublicAccount,
mosaicDefinitionTransaction.MosaicId,
"test_mosaic",
"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(aggregateTransactionsigned);
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 {aggregateTransactionsigned.Hash}");
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(aggregateTransactionsigned);
Fixture.WatchForFailure(aggregateTransactionsigned);
var aggregateTrntx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(500));
var MosaicMetadataDetail = await Fixture.SiriusClient.MetadataHttp.SearchMetadata(new MetadataQueryParams(1, Order.ASC, 1, Address.CreateFromRawAddress(account.Address.ToString()), null, null, null));
Log.WriteLine($"Metadata mosaic {MosaicMetadataDetail}");
}
public async Task Should_Add_Cosignatory()
{
//account = Account.CreateFromPrivateKey("EC2A2026948C28BAA8CDF061D7768397E0080E8E7913DE2ABF3066D2D4DCA0A6", NetworkType);
//cosignatory1 = Account.CreateFromPrivateKey("39E80B97D7528E59997AA11DD499B42EFEE2E85BE372179CE88E622541F5DEDB", NetworkType);
//cosignatory2 = Account.CreateFromPrivateKey("38296AE980C69D24D018D119C40A00D3894713F3A2F7BB27E495671D3D8C2E6D", NetworkType);
// cosignatory3 = Account.CreateFromPrivateKey("748EFC97BBB2EC5A304DAD9B712B6540A8AD6A3EC2C60BDB03D20F6DB34513AD", NetworkType);
Thread.Sleep(4000);
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}");
Log.WriteLine($"Cosignatory3 account {Fixture.Cosignatory3}");
var multisigCosignatoryModification = new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD, Fixture.Cosignatory3.PublicAccount);
// Define a modify multisig account transaction to increase the minAprovalDelta in one unit
var modifyMultisigAccountTransaction = ModifyMultisigAccountTransaction.Create(
Deadline.Create(),
0,
0,
new List <MultisigCosignatoryModification>
{
multisigCosignatoryModification
},
Fixture.NetworkType);
// Wrap the modify multisig account transaction in an aggregate transaction,
// attaching the multisig public key as the signer
var aggregateTransaction = AggregateTransaction.CreateBonded(
Deadline.Create(),
new List <Transaction>
{
modifyMultisigAccountTransaction.ToAggregate(Fixture.MultiSigAccount.PublicAccount)
},
Fixture.NetworkType
);
var signedTransaction = Fixture.Cosignatory1.Sign(aggregateTransaction, Fixture.GenerationHash);
// Before sending an aggregate bonded transaction,
// the future multisig account needs to lock at least 10 cat.currency.
// This transaction is required to prevent network spamming and ensure that
// the inner transactions are cosigned
var hashLockTransaction = HashLockTransaction.Create(
Deadline.Create(),
NetworkCurrencyMosaic.CreateRelative(10),
(ulong)700,
signedTransaction,
Fixture.NetworkType);
var hashLockTransactionSigned = Fixture.Cosignatory1.Sign(hashLockTransaction, Fixture.GenerationHash);
/*var hashLocktx =SiriusWebSocketClient.Listener
* .ConfirmedTransactionsGiven(cosignatory1.Address).Take(1)
* .Timeout(TimeSpan.FromSeconds(500));*/
Fixture.WatchForFailure(hashLockTransactionSigned);
Log.WriteLine($"Going to announce hash lock transaction {hashLockTransactionSigned.Hash}");
// Announce the hash lock transaction
await Fixture.SiriusClient.TransactionHttp.Announce(hashLockTransactionSigned);
Thread.Sleep(8000);
// Wait for the hash lock transaction to be confirmed
//var hashLockConfirmed = await hashLocktx;
// if (hashLockConfirmed.TransactionInfo.Hash == hashLockTransactionSigned.Hash)
// {
Fixture.WatchForFailure(signedTransaction);
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
// Announce the AnnounceAggregateBonded transaction
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(signedTransaction);
// sleep for await
Thread.Sleep(8000);
/*var cosignatory3Cosigned =SiriusWebSocketClient.Listener
* .CosignatureAdded(cosignatory3.Address).Take(1)
* .Timeout(TimeSpan.FromSeconds(2000));*/
Thread.Sleep(2000);
var cosignatory3AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory3.PublicAccount);
foreach (AggregateTransaction tx in cosignatory3AggTxs)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory3.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory3);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
//var resultTx = await cosignatory1Cosigned;
//Log.WriteLine($"Completed Cosign 1 {resultTx}");
}
}
/*var cosignatory2Cosigned =SiriusWebSocketClient.Listener
* .CosignatureAdded(cosignatory2.Address).Take(1)
* .Timeout(TimeSpan.FromSeconds(2000));*/
Thread.Sleep(2000);
var cosignatory2AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory2.PublicAccount);
foreach (AggregateTransaction tx in cosignatory2AggTxs)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory2.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory2);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
//var resultTx = await cosignatory1Cosigned;
//Log.WriteLine($"Completed Cosign 1 {resultTx}");
}
}
Thread.Sleep(10000);
// 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.Cosignatories.Should().HaveCount(2);
Log.WriteLine($"Completed");
// }
}
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_Add_Cosignatory()
{
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
Log.WriteLine($"Cosignatory1 account {Fixture.Cosignatory1}");
Log.WriteLine($"Cosignatory3 account {Fixture.Cosignatory3}");
// Define a modify multisig account transaction to increase the minAprovalDelta in one unit
var modifyMultisigAccountTransaction = ModifyMultisigAccountTransaction.Create(
Deadline.Create(),
0,
0,
new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory1.PublicAccount),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory3.PublicAccount),
},
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.MultiSigAccount.Sign(aggregateTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(signedTransaction);
// Before sending an aggregate bonded transaction,
// the future multisig account needs to lock at least 10 cat.currency.
// This transaction is required to prevent network spamming and ensure that
// the inner transactions are cosigned
var hashLockTransaction = HashLockTransaction.Create(
Deadline.Create(),
NetworkCurrencyMosaic.CreateRelative(10),
(ulong)700,
signedTransaction,
Fixture.NetworkType);
var hashLockTransactionSigned = Fixture.SeedAccount.Sign(hashLockTransaction, Fixture.GenerationHash);
try
{
var hashLocktx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(Fixture.Cosignatory1.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(500));
Fixture.WatchForFailure(hashLockTransactionSigned);
// Announce the hash lock transaction
Log.WriteLine($"Going to announce hash lock transaction {hashLockTransactionSigned.Hash}");
await Fixture.SiriusClient.TransactionHttp.Announce(hashLockTransactionSigned);
var hashLockConfirmed = await hashLocktx;
if (hashLockConfirmed.TransactionInfo.Hash == hashLockTransactionSigned.Hash)
{
// Announce the AnnounceAggregateBonded transaction
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(signedTransaction);
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
// sleep for await
Thread.Sleep(8000);
Fixture.WatchForFailure(signedTransaction);
var cosignatory3AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory3.PublicAccount);
foreach (AggregateTransaction tx in cosignatory3AggTxs.Transactions)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory3.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory3);
Fixture.WatchForFailure(cosignatureSignedTransaction);
Log.WriteLine($"Going to announce cosign aggregate bonded transaction {cosignatureSignedTransaction.ParentHash}");
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
}
}
var cosignatory2AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory2.PublicAccount);
foreach (AggregateTransaction tx in cosignatory2AggTxs.Transactions)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory2.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory2);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
}
}
Log.WriteLine($"Completed");
}
}
catch (Exception e)
{
Log.WriteLine(e.Message);
}
}
public async Task Should_Convert_Account_To_1to2_MultiSig()
{
// Get current network type
// Create an account to be converted to multisig with some money
// var account = await GenerateAccountAndSendSomeMoney(100);
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
// var cosignatory1 = await GenerateAccountAndSendSomeMoney(100);
// var cosignatory2 = await GenerateAccountAndSendSomeMoney(100);
//var account = GetAccountFromKey("F40DAD4B22DAFBBAA6BD33531E14C51810AFEF5BDDBFFE5E2ACB1C1D77EF0D93", NetworkType);
// var cosignatory2 = GetAccountFromKey("574D23DEF92D1C89DD50750DF303EA2A4C26ADBC9B966546B6BACAB827761088", NetworkType);
// var cosignatory1 = GetAccountFromKey("5F558CE1B471980D76BE8C716334E098DEDDCACA71736620BA7B48436C5972D2", NetworkType);
// Create two other accounts
// var cosignatory1 = Account.GenerateNewAccount(NetworkType);
Log.WriteLine($"MultiSig cosignatory1 {Fixture.Cosignatory1}");
// var cosignatory2 = Account.GenerateNewAccount(NetworkType);
Log.WriteLine($"MultiSig cosignatory2 {Fixture.Cosignatory2}");
// Create a modify multisig account transaction to convert the shared account into a multisig account
// 1 to 2 multisig
var multiSigBuilder = new ModifyMultisigAccountTransactionBuilder();
multiSigBuilder.SetDeadline(Deadline.Create())
.SetMinApprovalDelta(1)
.SetMinRemovalDelta(1)
.SetModifications(new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory1.PublicAccount),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory2.PublicAccount),
})
.SetNetworkType(Fixture.NetworkType);
var convertIntoMultisigTransaction = multiSigBuilder.Build();
/*
* var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create(
* Deadline.Create(),
* 1,
* 1,
* new List<MultisigCosignatoryModification>
* {
* new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
* Fixture.Cosignatory1.PublicAccount),
* new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
* Fixture.Cosignatory2.PublicAccount),
* },
* Fixture.NetworkType);
*/
// Create an aggregate bonded transaction, wrapping the modify multisig account transaction
var aggregateTransaction = AggregateTransaction.CreateBonded(
Deadline.Create(),
new List <Transaction>
{
convertIntoMultisigTransaction.ToAggregate(Fixture.MultiSigAccount.PublicAccount)
},
Fixture.NetworkType);
// Sign the aggregate transaction using the private key of the multisig account
var signedTransaction = Fixture.MultiSigAccount.Sign(aggregateTransaction, Fixture.GenerationHash);
// Before sending an aggregate bonded transaction,
// the future multisig account needs to lock at least 10 cat.currency.
// This transaction is required to prevent network spamming and ensure that
// the inner transactions are cosigned
var builder = new LockFundsTransactionBuilder();
builder.SetDeadline(Deadline.Create())
.SetDuration((ulong)700)
.SetMosaic(NetworkCurrencyMosaic.CreateRelative(10))
.SetSignedTransaction(signedTransaction)
.SetNetworkType(Fixture.NetworkType);
var hashLockTransaction = builder.Build();
/*
* var hashLockTransaction = HashLockTransaction.Create(
* Deadline.Create(),
* NetworkCurrencyMosaic.CreateRelative(10),
* (ulong)700,
* signedTransaction,
* Fixture.NetworkType);
*/
var hashLockTransactionSigned = Fixture.SeedAccount.Sign(hashLockTransaction, Fixture.GenerationHash);
// register transaction with web socket
try
{
// awaitSiriusWebSocketClient.Listener.Open();
var hashLocktx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(Fixture.SeedAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(500));
Fixture.WatchForFailure(hashLockTransactionSigned);
Log.WriteLine($"Going to announce hash lock transaction {hashLockTransactionSigned.Hash}");
// Announce the hash lock transaction
await Fixture.SiriusClient.TransactionHttp.Announce(hashLockTransactionSigned);
// Wait for the hash lock transaction to be confirmed
var hashLockConfirmed = await hashLocktx;
// After the hash lock transaction has been confirmed,
// announce the aggregate transaction.
if (hashLockConfirmed.TransactionInfo.Hash == hashLockTransactionSigned.Hash)
{
//var aggBonded = Fixture.SiriusWebSocketClient.Listener
// .AggregateBondedAdded(Fixture.SeedAccount.Address).Take(1)
// .Timeout(TimeSpan.FromSeconds(2000));
// var aggBondedConfirmed = Fixture.SiriusWebSocketClient.Listener
// .ConfirmedTransactionsGiven(Fixture.MultiSigAccount.Address).Take(1)
// .Timeout(TimeSpan.FromSeconds(2000));
Fixture.WatchForFailure(signedTransaction);
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
// Announce the hash lock transaction
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(signedTransaction);
// sleep for await
Thread.Sleep(5000);
//var aggBondedTx = await aggBondedConfirmed;
//if(aggBondedTx.IsConfirmed())
// {
// Cosign the aggregate transaction with cosignatory1
var cosignatory1Cosigned = Fixture.SiriusWebSocketClient.Listener
.CosignatureAdded(Fixture.Cosignatory1.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(2000));
var cosignatory1AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory1.PublicAccount);
foreach (AggregateTransaction tx in cosignatory1AggTxs)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory1.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory1);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
//var resultTx = await cosignatory1Cosigned;
//Log.WriteLine($"Completed Cosign 1 {resultTx}");
}
}
// Cosign the aggregate transaction with cosignatory2
var cosignatory2Cosigned = Fixture.SiriusWebSocketClient.Listener
.CosignatureAdded(Fixture.Cosignatory2.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(2000));
var cosignatory2AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory2.PublicAccount);
foreach (AggregateTransaction tx in cosignatory2AggTxs)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory2.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory2);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
//var resultTx = await cosignatory2Cosigned;
//Log.WriteLine($"Completed Cosign 2 {resultTx}");
}
}
// }
Thread.Sleep(10000);
// 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(1);
multiSigAcc.MinRemoval.Should().Be(1);
multiSigAcc.Cosignatories.Should().HaveCount(2);
Log.WriteLine($"Completed");
}
}
catch (Exception e)
{
Log.WriteLine(e.Message);
}
finally
{
try
{
//SiriusWebSocketClient.Listener.Close();
}
catch (Exception)
{
//do nothing
}
}
}
public async Task Should_Convert_Account_To_1to2_MultiSig()
{
// Get current network type
// Create an account to be converted to multisig with some money
// var account = await GenerateAccountAndSendSomeMoney(100);
Log.WriteLine($"MultiSig account {Fixture.MultiSigAccount}");
// Create two other accounts
// var cosignatory1 = Account.GenerateNewAccount(NetworkType);
Log.WriteLine($"MultiSig cosignatory1 {Fixture.Cosignatory1}");
// var cosignatory2 = Account.GenerateNewAccount(NetworkType);
Log.WriteLine($"MultiSig cosignatory2 {Fixture.Cosignatory2}");
// Create a modify multisig account transaction to convert the shared account into a multisig account
// 1 to 2 multisig
var multiSigBuilder = new ModifyMultisigAccountTransactionBuilder();
multiSigBuilder.SetDeadline(Deadline.Create())
.SetMinApprovalDelta(1)
.SetMinRemovalDelta(1)
.SetModifications(new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory1.PublicAccount),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
Fixture.Cosignatory2.PublicAccount),
})
.SetNetworkType(Fixture.NetworkType);
var convertIntoMultisigTransaction = multiSigBuilder.Build();
// Create an aggregate bonded transaction, wrapping the modify multisig account transaction
var aggregateTransaction = AggregateTransaction.CreateBonded(
Deadline.Create(),
new List <Transaction>
{
convertIntoMultisigTransaction.ToAggregate(Fixture.MultiSigAccount.PublicAccount)
},
Fixture.NetworkType);
// Sign the aggregate transaction using the private key of the multisig account
var signedTransaction = Fixture.MultiSigAccount.Sign(aggregateTransaction, Fixture.GenerationHash);
// Before sending an aggregate bonded transaction,
// the future multisig account needs to lock at least 10 cat.currency.
// This transaction is required to prevent network spamming and ensure that
// the inner transactions are cosigned
var builder = new LockFundsTransactionBuilder();
builder.SetDeadline(Deadline.Create())
.SetDuration((ulong)700)
.SetMosaic(NetworkCurrencyMosaic.CreateRelative(10))
.SetSignedTransaction(signedTransaction)
.SetNetworkType(Fixture.NetworkType);
var hashLockTransaction = builder.Build();
var hashLockTransactionSigned = Fixture.SeedAccount.Sign(hashLockTransaction, Fixture.GenerationHash);
// register transaction with web socket
try
{
var hashLocktx = Fixture.SiriusWebSocketClient.Listener
.ConfirmedTransactionsGiven(Fixture.SeedAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(500));
Fixture.WatchForFailure(hashLockTransactionSigned);
Log.WriteLine($"Going to announce hash lock transaction {hashLockTransactionSigned.Hash}");
// Announce the hash lock transaction
await Fixture.SiriusClient.TransactionHttp.Announce(hashLockTransactionSigned);
// Wait for the hash lock transaction to be confirmed
var hashLockConfirmed = await hashLocktx;
// After the hash lock transaction has been confirmed,
// announce the aggregate transaction.
if (hashLockConfirmed.TransactionInfo.Hash == hashLockTransactionSigned.Hash)
{
Fixture.WatchForFailure(signedTransaction);
Log.WriteLine($"Going to announce aggregate bonded transaction {signedTransaction.Hash}");
// Announce the hash lock transaction
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBonded(signedTransaction);
// sleep for await
Thread.Sleep(5000);
// Cosign the aggregate transaction with cosignatory1
var cosignatory1Cosigned = Fixture.SiriusWebSocketClient.Listener.CosignatureAdded(Fixture.Cosignatory1.Address).Take(1).Timeout(TimeSpan.FromSeconds(2000));
var cosignatory1AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory1.PublicAccount);
foreach (AggregateTransaction tx in cosignatory1AggTxs.Transactions)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory1.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory1);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(8000);
}
}
// Cosign the aggregate transaction with cosignatory2
var cosignatory2Cosigned = Fixture.SiriusWebSocketClient.Listener
.CosignatureAdded(Fixture.Cosignatory2.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(2000));
var cosignatory2AggTxs = await Fixture.SiriusClient.AccountHttp.AggregateBondedTransactions(Fixture.Cosignatory2.PublicAccount);
foreach (AggregateTransaction tx in cosignatory2AggTxs.Transactions)
{
if (!tx.IsSignedByAccount(Fixture.Cosignatory2.PublicAccount))
{
var cosignatureSignedTransaction = CosignAggregateBondedTransaction(tx, Fixture.Cosignatory2);
Fixture.WatchForFailure(cosignatureSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.AnnounceAggregateBondedCosignatureAsync(cosignatureSignedTransaction);
Thread.Sleep(2000);
}
}
Thread.Sleep(10000);
// 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(1);
multiSigAcc.MinRemoval.Should().Be(1);
multiSigAcc.Cosignatories.Should().HaveCount(2);
Log.WriteLine($"Completed");
}
}
catch (Exception e)
{
Log.WriteLine(e.Message);
}
/* finally
* {
* try
* {
* //SiriusWebSocketClient.Listener.Close();
* }
* catch (Exception)
* {
* //do nothing
* }
* }*/
}
private Task Transfer(object seedAccount, Address address, NetworkCurrencyMosaic mosaic, PlainMessage message, object generationHash)
{
throw new NotImplementedException();
}
