public async Task AggregateNamespaceRentalExtensionShouldSucceed()
{
var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var transaction = RegisterNamespaceTransaction.CreateRootNamespace(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
"happy",
10000)
.ToAggregate(PublicAccount.CreateFromPublicKey("B974668ABED344BE9C35EE257ACC246117EFFED939EAF42391AE995912F985FE", NetworkType.Types.MIJIN_TEST));
var agg = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>()
{
transaction
})
.SignWith(signer);
await new TransactionHttp(host).Announce(agg);
listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Subscribe(
e =>
{
Console.WriteLine(e.Status);
});
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == agg.Hash).Take(1);
Assert.AreEqual(signer.PublicKeyString, status.Signer.PublicKey);
}
public async Task <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 SignAggregateTransactionComplete()
{
var signerKey =
KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var account = new Account(Config.PrivateKeySecond,
NetworkType.Types.MIJIN_TEST);
var aggregateTransaction = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem")
.ToAggregate(PublicAccount.CreateFromPublicKey(signerKey.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem")
.ToAggregate(PublicAccount.CreateFromPublicKey(account.PublicKey, NetworkType.Types.MIJIN_TEST))
})
.SignWithAggregateCosigners(signerKey, new List <Account>()
{
Account.CreateFromPrivateKey(Config.PrivateKeySecond,
NetworkType.Types.MIJIN_TEST)
}
);
WatchForFailure(aggregateTransaction);
await new TransactionHttp(host).Announce(aggregateTransaction);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(account.PublicKey, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateTransaction.Hash).Take(1);
Assert.AreEqual(signerKey.PublicKeyString, status.Signer.PublicKey);
}
public void ShouldCreateAggregateTransactionAndSignWithMultipleCosignatories()
{
TransferTransaction transferTx = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new Address("SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC", NetworkType.Types.MIJIN_TEST),
new List <Mosaic>(),
PlainMessage.Create("test-message")
);
AggregateTransaction aggregateTx = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new List <Transaction>()
{
transferTx.ToAggregate(new PublicAccount("B694186EE4AB0558CA4AFCFDD43B42114AE71094F5A1FC4A913FE9971CACD21D", NetworkType.Types.MIJIN_TEST))
});
Account cosignatoryAccount = new Account("2a2b1f5d366a5dd5dc56c3c757cf4fe6c66e2787087692cf329d7a49a594658b", NetworkType.Types.MIJIN_TEST);
Account cosignatoryAccount2 = new Account("b8afae6f4ad13a1b8aad047b488e0738a437c7389d4ff30c359ac068910c1d59", NetworkType.Types.MIJIN_TEST);
SignedTransaction signedTransaction = cosignatoryAccount.SignTransactionWithCosignatories(aggregateTx, new List <Account>()
{
cosignatoryAccount2
});
Assert.AreEqual("2D010000", signedTransaction.Payload.Substring(0, 8));
Assert.AreEqual("5100000051000000", signedTransaction.Payload.Substring(240, 16));
}
public async Task 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}");
}
private void ValidateAggregateTransaction(AggregateTransaction aggregateTransaction, string aggregateTransactionDTO)
{
var tx = JsonConvert.DeserializeObject <AggregateTransactionInfoDTO>(aggregateTransactionDTO);
Assert.AreEqual(tx.Meta.Height, aggregateTransaction.TransactionInfo.Height);
if (aggregateTransaction.TransactionInfo.Hash != null)
{
Assert.AreEqual(tx.Meta.Hash, aggregateTransaction.TransactionInfo.Hash);
}
if (aggregateTransaction.TransactionInfo.MerkleComponentHash != null)
{
Assert.AreEqual(tx.Meta.MerkleComponentHash, aggregateTransaction.TransactionInfo.MerkleComponentHash);
}
if (aggregateTransaction.TransactionInfo.Index != null)
{
Assert.AreEqual(tx.Meta.Index, aggregateTransaction.TransactionInfo.Index);
}
if (aggregateTransaction.TransactionInfo.Id != null)
{
Assert.AreEqual(tx.Meta.Id, aggregateTransaction.TransactionInfo.Id);
}
if (aggregateTransaction.TransactionInfo.AggregateHash != null)
{
Assert.AreEqual(tx.Transaction.InnerTransactions[0].Meta.AggregateHash, aggregateTransaction.InnerTransactions[0].TransactionInfo.AggregateHash);
}
if (aggregateTransaction.TransactionInfo.AggregateId != null)
{
Assert.AreEqual(tx.Transaction.InnerTransactions[0].Meta.AggregateId, aggregateTransaction.TransactionInfo.AggregateId);
}
Assert.AreEqual(tx.Transaction.Signature, aggregateTransaction.Signature);
Assert.AreEqual(tx.Transaction.Signer, aggregateTransaction.Signer.PublicKey);
int version = (int)Convert.ToInt64(tx.Transaction.Version.ToString("X").Substring(2, 2), 16);
Assert.IsTrue(version == aggregateTransaction.Version);
int type = (int)Convert.ToInt64(tx.Transaction.Version.ToString("X").Substring(0, 2), 16);
Assert.IsTrue((byte)type == aggregateTransaction.NetworkType.GetNetworkByte());
Assert.AreEqual(tx.Transaction.Fee, aggregateTransaction.Fee);
Assert.IsNotNull(aggregateTransaction.Deadline);
if (tx.Transaction.Cosignatures.Count > 0)
{
Assert.AreEqual(tx.Transaction.Cosignatures[0].Signature, aggregateTransaction.Cosignatures[0].Signature);
Assert.AreEqual(tx.Transaction.Cosignatures[0].Signer, aggregateTransaction.Cosignatures[0].Signer.PublicKey);
}
for (var index = 0; index < aggregateTransaction.InnerTransactions.Count; index++)
{
ValidateStandaloneTransaction(aggregateTransaction.InnerTransactions[index], JObject.Parse(aggregateTransactionDTO)["transaction"]["transactions"].ToObject <List <JObject> >()[index].ToString());
}
}
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 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 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_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 PartialTransactionWithMissingCosigner()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var keyPair2 = KeyPair.CreateFromPrivateKey("14A239D2ADB96753CFC160BB262F27B01BCCC8C74599F51771BC6BD39980F4E7");
var aggregateBonded = AggregateTransaction.CreateBonded(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
TransferTransactionTests.CreateInnerTransferTransaction(
"nem:xem").ToAggregate(PublicAccount.CreateFromPublicKey(keyPair2.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
TransferTransactionTests.CreateInnerTransferTransaction(
"nem:xem").ToAggregate(PublicAccount.CreateFromPublicKey(keyPair2.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
},
null)
.SignWith(keyPair);
WatchForFailure(aggregateBonded);
var hashLock = LockFundsTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
0,
new Mosaic(new MosaicId("nem:xem"), 10000000),
10000,
aggregateBonded
)
.SignWith(KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain));
WatchForFailure(hashLock);
await new TransactionHttp(host).Announce(hashLock);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(hashLock.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == hashLock.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
await new TransactionHttp(host).AnnounceAggregateBonded(aggregateBonded);
var status2 = await listener.AggregateBondedAdded(Address.CreateFromPublicKey(aggregateBonded.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateBonded.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status2.Signer.PublicKey);
}
public async Task AggregateTransactionWithOnlyInitiator()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var aggregateTransaction = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem")
.ToAggregate(PublicAccount.CreateFromPublicKey("B974668ABED344BE9C35EE257ACC246117EFFED939EAF42391AE995912F985FE", NetworkType.Types.MIJIN_TEST)),
}
).SignWith(keyPair);
await new TransactionHttp(host).Announce(aggregateTransaction);
var status2 = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(aggregateTransaction.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateTransaction.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status2.Signer.PublicKey);
}
public async Task LockFundsTransactionTest()
{
var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var aggregateTransaction = AggregateTransaction.CreateBonded(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
TransferTransactionTests.CreateInnerTransferTransaction(
"nem:xem").ToAggregate(PublicAccount.CreateFromPublicKey("10CC07742437C205D9A0BC0434DC5B4879E002114753DE70CDC4C4BD0D93A64A", NetworkType.Types.MIJIN_TEST)),
TransferTransactionTests.CreateInnerTransferTransaction(
"nem:xem").ToAggregate(PublicAccount.CreateFromPublicKey("A8FCF4371B9C4B26CE19A407BA803D3813647608D57ABC1550925A54AEE2C9EA", NetworkType.Types.MIJIN_TEST))
},
null)
.SignWith(signer);
var hashLock = LockFundsTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
0,
new Mosaic(new MosaicId("nem:xem"), 10000000),
10000,
aggregateTransaction)
.SignWith(KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain));
WatchForFailure(hashLock);
await new TransactionHttp(host).Announce(hashLock);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(hashLock.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == hashLock.Hash).Take(1);
Assert.AreEqual(signer.PublicKeyString, status.Signer.PublicKey);
await new TransactionHttp(host).AnnounceAggregateBonded(aggregateTransaction);
var status2 = await listener.AggregateBondedAdded(Address.CreateFromPublicKey(aggregateTransaction.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateTransaction.Hash).Take(1);
Assert.AreEqual(signer.PublicKeyString, status2.Signer.PublicKey);
}
public async Task AggregateTransactionWithMissingCosignatures()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var keyPair2 = KeyPair.CreateFromPrivateKey(Config.PrivateKeySecond);
var aggregateTransaction = AggregateTransaction.CreateBonded(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
RegisterNamespaceTransaction.CreateRootNamespace(NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), "happy23", 10000)
.ToAggregate(PublicAccount.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem")
.ToAggregate(PublicAccount.CreateFromPublicKey(keyPair2.PublicKeyString, NetworkType.Types.MIJIN_TEST)),
},
null
).SignWith(keyPair);
WatchForFailure(aggregateTransaction);
var hashLock = LockFundsTransaction.Create(NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), 0, new Mosaic(new MosaicId("nem:xem"), 10000000), 10000, aggregateTransaction)
.SignWith(KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain));
WatchForFailure(hashLock);
await new TransactionHttp(host).Announce(hashLock);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(hashLock.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == hashLock.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
await new TransactionHttp(host).AnnounceAggregateBonded(aggregateTransaction);
var status2 = await listener.AggregateBondedAdded(Address.CreateFromPublicKey(aggregateTransaction.Signer, NetworkType.Types.MIJIN_TEST)).Where(e => e.TransactionInfo.Hash == aggregateTransaction.Hash).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status2.Signer.PublicKey);
}
public void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction_AggregateBonded()
{
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);
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
//[TestMethod, Timeout(20000)]
public async Task ListenForPartialTransactionAdded()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var aggregateTransaction = AggregateTransaction.CreateBonded(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>
{
TransferTransactionTests.CreateInnerTransferTransaction("nem:xem"),
},
null
).SignWith(keyPair);
var hashLock = LockFundsTransaction.Create(NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), 0, duration: 10000, mosaic: new Mosaic(new MosaicId("nem:xem"), 10000000), transaction: aggregateTransaction)
.SignWith(KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain));
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(hashLock);
var listener = new Listener(Config.Domain);
await listener.Open();
await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(
keyPair.PublicKeyString,
NetworkType.Types.MIJIN_TEST)
).Take(1);
await new TransactionHttp("http://" + Config.Domain + ":3000").AnnounceAggregateBonded(aggregateTransaction);
var result = await listener.AggregateBondedAdded(Address.CreateFromPublicKey(
keyPair.PublicKeyString,
NetworkType.Types.MIJIN_TEST)
).Take(1);
Assert.AreEqual("10CC07742437C205D9A0BC0434DC5B4879E002114753DE70CDC4C4BD0D93A64A", result.Signer);
}
public void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction_AggregateBonded()
{
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);
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
public void CreateAAggregateTransactionViaStaticConstructor()
{
TransferTransaction transferTx = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new Address("SDGLFW-DSHILT-IUHGIB-H5UGX2-VYF5VN-JEKCCD-BR26", NetworkType.Types.MIJIN_TEST),
new List <Mosaic>(),
EmptyMessage.Create()
);
AggregateTransaction aggregateTx = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
new List <Transaction>()
{
transferTx.ToAggregate(new PublicAccount("9A49366406ACA952B88BADF5F1E9BE6CE4968141035A60BE503273EA65456B24", NetworkType.Types.MIJIN_TEST))
});
Assert.AreEqual(NetworkType.Types.MIJIN_TEST, aggregateTx.NetworkType);
Assert.IsTrue(144 == aggregateTx.NetworkType.GetNetworkByte());
Assert.IsTrue(DateTime.Now > aggregateTx.Deadline.GetLocalDateTime());
Assert.AreEqual((ulong)0, aggregateTx.Fee);
Assert.AreEqual(1, aggregateTx.InnerTransactions.Count);
}
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
* }
* }*/
}
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_Create_Mosaic_With_Builder()
{
var account = Fixture.SeedAccount;
var nonce = MosaicNonce.CreateRandom();
var mosaicId = MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey);
var builder = new MosaicDefinitionTransactionBuilder();
builder.SetNonce(nonce)
.SetMosaicId(mosaicId)
.SetMosaicProperties(MosaicProperties.Create(
supplyMutable: true,
transferable: true,
levyMutable: false,
divisibility: 0,
duration: 1000
))
.SetDeadline(Deadline.Create())
.SetNetworkType(Fixture.NetworkType);
/*
* var mosaicDefinitionTransaction = MosaicDefinitionTransaction.Create(
* nonce,
* mosaicId,
* Deadline.Create(),
* MosaicProperties.Create(
* supplyMutable: true,
* transferable: true,
* levyMutable: false,
* divisibility: 0,
* duration: 1000
* ),
* Fixture.NetworkType);
*/
var mosaicDefinitionTransaction = builder.Build();
Log.WriteLine($"Going to create mosaic {mosaicId}");
var supplyBuilder = new MosaicSupplyChangeTransactionBuilder();
supplyBuilder
.SetDeadline(Deadline.Create())
.SetNetworkType(Fixture.NetworkType)
.IncreaseSupplyFor(mosaicDefinitionTransaction.MosaicId)
.SetDelta(1000000);
var mosaicSupplyChangeTransaction = supplyBuilder.Build();
/*
* var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
* Deadline.Create(),
* mosaicDefinitionTransaction.MosaicId,
* MosaicSupplyType.INCREASE,
* 1000000,
* Fixture.NetworkType);
*/
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
mosaicDefinitionTransaction.ToAggregate(account.PublicAccount),
mosaicSupplyChangeTransaction.ToAggregate(account.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = account.Sign(aggregateTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(signedTransaction);
Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var mosaicInfo = await Fixture.SiriusClient.MosaicHttp.GetMosaic(mosaicDefinitionTransaction.MosaicId);
Log.WriteLine($"Mosaic created {mosaicInfo}");
mosaicInfo.Should().NotBeNull();
mosaicInfo.Divisibility.Should().Be(0);
mosaicInfo.Duration.Should().Be(1000);
mosaicInfo.IsLevyMutable.Should().BeFalse();
mosaicInfo.IsSupplyMutable.Should().BeTrue();
mosaicInfo.IsTransferable.Should().BeTrue();
mosaicInfo.Supply.Should().Be(1000000);
}
public async Task Should_Link_Namespace_To_Mosaic()
{
#region Create mosaic
var account = await Fixture.GenerateAccountWithCurrency(1500);
var nonce = MosaicNonce.CreateRandom();
var mosaicDefinitionTransaction = MosaicDefinitionTransaction.Create(
nonce,
MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey),
Deadline.Create(),
MosaicProperties.Create(
supplyMutable: true,
transferable: true,
levyMutable: false,
divisibility: 0,
duration: 1000
),
Fixture.NetworkType);
var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
Deadline.Create(),
mosaicDefinitionTransaction.MosaicId,
MosaicSupplyType.INCREASE,
1000000,
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
mosaicDefinitionTransaction.ToAggregate(account.PublicAccount),
mosaicSupplyChangeTransaction.ToAggregate(account.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = account.Sign(aggregateTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var mosaicInfo = await Fixture.SiriusClient.MosaicHttp.GetMosaic(mosaicDefinitionTransaction.MosaicId);
mosaicInfo.Should().NotBeNull();
mosaicInfo.Divisibility.Should().Be(0);
mosaicInfo.Duration.Should().Be(1000);
mosaicInfo.IsLevyMutable.Should().BeFalse();
mosaicInfo.IsSupplyMutable.Should().BeTrue();
mosaicInfo.IsTransferable.Should().BeTrue();
mosaicInfo.Supply.Should().Be(1000000);
#endregion
#region register new namespace
var namespaceName = "nsp" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 6);
var registerNamespaceTransaction = RegisterNamespaceTransaction.CreateRootNamespace(
Deadline.Create(),
namespaceName,
100,
Fixture.NetworkType
);
var registeredNsSignedTransaction = account.Sign(registerNamespaceTransaction, Fixture.GenerationHash);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(registeredNsSignedTransaction);
Log.WriteLine(
$"Registered namespace {namespaceName} for account {account.Address.Plain} with transaction {registeredNsSignedTransaction.Hash}");
result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var expectedId = new NamespaceId(namespaceName);
var nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
Log.WriteLine(
$"Retrieved namespace {namespaceName} successfully. The namespace HexId {nsInfo.Id.HexId}");
nsInfo.Should().NotBeNull();
#endregion
#region Link namespace to the mosaic
var mosaicAliasTransaction = AliasTransaction.CreateForMosaic(
mosaicInfo.MosaicId,
nsInfo.Id,
AliasActionType.LINK,
Deadline.Create(),
Fixture.NetworkType
);
tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1);
var aliasSignedTransaction = account.Sign(mosaicAliasTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(aliasSignedTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(aliasSignedTransaction);
result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
nsInfo = await Fixture.SiriusClient.NamespaceHttp.GetNamespace(expectedId);
nsInfo.Should().NotBeNull();
nsInfo.HasAlias.Should().BeTrue();
nsInfo.Alias.Type.Should().BeEquivalentTo(AliasType.MOSAIC_ID);
nsInfo.Alias.MosaicId.HexId.Should().BeEquivalentTo(mosaicInfo.MosaicId.HexId);
#endregion
#region Send mosaic using namespace alias to recipient
var newAccount = Account.GenerateNewAccount(Fixture.NetworkType);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
Recipient.From(newAccount.Address),
new List <Mosaic>()
{
new Mosaic(nsInfo.Id, 10)
},
PlainMessage.Create("Send some mosaic to new address"),
Fixture.NetworkType);
var tx2 = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(newAccount.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
var nsSignedTransferTransaction = account.Sign(transferTransaction, Fixture.GenerationHash);
Fixture.WatchForFailure(nsSignedTransferTransaction);
await Fixture.SiriusClient.TransactionHttp.Announce(nsSignedTransferTransaction);
var result2 = await tx2;
Log.WriteLine($"Request confirmed with transaction {result2.TransactionInfo.Hash}");
var newAccountInfo = await Fixture.SiriusClient.AccountHttp.GetAccountInfo(newAccount.Address);
Log.WriteLine($"Account {newAccountInfo.Address.Plain} with mosaic {newAccountInfo.Mosaics[0]} after transfer to the namespace alias");
var expectedMosaicAmount = Convert.ToUInt64(10);
newAccountInfo.Mosaics[0].Id.Id.Should().Be(mosaicInfo.MosaicId.Id);
newAccountInfo.Mosaics[0]?.Amount.Should().Be(expectedMosaicAmount);
#endregion
}
public async Task Should_Increase_Mosaic_Supply()
{
var account = Fixture.SeedAccount;
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: 3,
duration: 1000
),
Fixture.NetworkType);
Log.WriteLine($"Going to create mosaic {mosaicId}");
var mosaicSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
Deadline.Create(),
mosaicDefinitionTransaction.MosaicId,
MosaicSupplyType.INCREASE,
1000000,
Fixture.NetworkType);
var aggregateTransaction = AggregateTransaction.CreateComplete(
Deadline.Create(),
new List <Transaction>
{
mosaicDefinitionTransaction.ToAggregate(account.PublicAccount),
mosaicSupplyChangeTransaction.ToAggregate(account.PublicAccount)
},
Fixture.NetworkType);
var signedTransaction = account.Sign(aggregateTransaction, Fixture.GenerationHash);
Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}");
var tx = Fixture.SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(account.Address).Take(1)
.Timeout(TimeSpan.FromSeconds(3000));
await Fixture.SiriusClient.TransactionHttp.Announce(signedTransaction);
var result = await tx;
Log.WriteLine($"Request confirmed with transaction {result.TransactionInfo.Hash}");
var mosaicDecreaseSupplyChangeTransaction = MosaicSupplyChangeTransaction.Create(
Deadline.Create(),
mosaicDefinitionTransaction.MosaicId,
MosaicSupplyType.INCREASE,
500000,
Fixture.NetworkType);
const ulong expectedAmount = 1000000 + 500000;
var signedDecreaseTransaction = account.Sign(mosaicDecreaseSupplyChangeTransaction, Fixture.GenerationHash);
await Fixture.SiriusClient.TransactionHttp.Announce(signedDecreaseTransaction);
var result2 = await tx;
Log.WriteLine($"Request confirmed with transaction {result2.TransactionInfo.Hash}");
var mosaicInfo = await Fixture.SiriusClient.MosaicHttp.GetMosaic(mosaicDefinitionTransaction.MosaicId);
mosaicInfo.Should().NotBeNull();
mosaicInfo.Divisibility.Should().Be(3);
mosaicInfo.Duration.Should().Be(1000);
mosaicInfo.IsLevyMutable.Should().BeFalse();
mosaicInfo.IsSupplyMutable.Should().BeTrue();
mosaicInfo.IsTransferable.Should().BeTrue();
mosaicInfo.Supply.Should().Be(expectedAmount);
}
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}");
}
/// <summary>
/// Signs the transaction with cosignatories.
/// </summary>
/// <param name="transaction">The transaction.</param>
/// <param name="cosignatories">The cosignatories.</param>
/// <returns>SignedTransaction.</returns>
public SignedTransaction SignTransactionWithCosignatories(AggregateTransaction transaction, List <Account> cosignatories)
{
return(transaction.SignWithAggregateCosigners(KeyPair, cosignatories));
}
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();
}
private CosignatureSignedTransaction CosignAggregateBondedTransaction(AggregateTransaction transaction, Account account)
{
var cosignatureTransaction = CosignatureTransaction.Create(transaction);
return(account.SignCosignatureTransaction(cosignatureTransaction));
}
