public void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction()
{
var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.TEST_NET);
var generationHash = "AC87FDA8FD94B72F3D0790A7D62F248111BD5E37B95B16E4216DA99C212530A5";
var network = NetworkType.TEST_NET;
var coginatory1 = Account.GenerateNewAccount(network);
var coginatory2 = Account.GenerateNewAccount(network);
var coginatories = new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
coginatory1.PublicAccount),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
coginatory2.PublicAccount),
};
var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create(
Deadline.Create(),
1,
1,
coginatories,
network);
var signedTransaction = convertIntoMultisigTransaction.SignWith(account, generationHash);
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
public void Should_Serialize_And_Sign_TransactionModifyMultisigAccountTransaction()
{
var account = Account.CreateFromPrivateKey("26b64cb10f005e5988a36744ca19e20d835ccc7c105aaa5f3b212da593180930", NetworkType.MIJIN_TEST);
var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7";
var network = NetworkType.MIJIN_TEST;
var coginatory1 = Account.GenerateNewAccount(network);
var coginatory2 = Account.GenerateNewAccount(network);
var coginatories = new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
coginatory1.PublicAccount),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.ADD,
coginatory2.PublicAccount),
};
var convertIntoMultisigTransaction = ModifyMultisigAccountTransaction.Create(
Deadline.Create(),
1,
1,
coginatories,
network);
var signedTransaction = convertIntoMultisigTransaction.SignWith(account, generationHash);
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
public async Task MultisigModificationTransaction()
{
var signer =
KeyPair.CreateFromPrivateKey("9abcd1bd50b994799f8a2e27f7ffd952831ef16a443a48241f1f78942322d5c6");
var mods = new List <MultisigCosignatoryModification>
{
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.Type.Add, new PublicAccount("10cc07742437c205d9a0bc0434dc5b4879e002114753de70cdc4c4bd0d93a64a", NetworkType.Types.MIJIN_TEST)),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.Type.Add, new PublicAccount("31bd180037ba8a8cc5a55a6256390592d6326e55753f3b6e6074dec86a39eea6", NetworkType.Types.MIJIN_TEST)),
new MultisigCosignatoryModification(MultisigCosignatoryModificationType.Type.Add, new PublicAccount("2ecf1decef6818bd9c38985afd6efc1c981e64e9a1ecc1e7b6b25eb30454cce0", NetworkType.Types.MIJIN_TEST))
};
var transaction = ModifyMultisigAccountTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
2,
2,
mods)
.SignWith(signer);
await new TransactionHttp(host).Announce(transaction);
var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == transaction.Hash).Take(1);
Assert.AreEqual("Failure_Multisig_Operation_Not_Permitted_By_Account", status.Status);
}
void ValidateMultisigModificationTx(ModifyMultisigAccountTransaction transaction, string transactionDTO)
{
var tx = JsonConvert.DeserializeObject <MultisigModificationTransactionInfoDTO>(transactionDTO);
Assert.IsTrue(tx.Transaction.MinApprovalDelta == transaction.MinApprovalDelta);
Assert.IsTrue(tx.Transaction.MinRemovalDelta == transaction.MinRemovalDelta);
Assert.AreEqual(transaction.Modifications[0].PublicAccount.PublicKey,
tx.Transaction.Modifications[0].CosignatoryPublicKey);
Assert.IsTrue(tx.Transaction.Modifications[0].Type ==
transaction.Modifications[0].Type.GetValue());
}
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 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_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_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");
// }
}