public async Task CanCreateMosaicWithLevy() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = MosaicDefinitionTransaction.CreateWithLevy( NetworkType.Types.TEST_NET, Deadline.CreateHours(1), new MosaicProperties(4, 1000000000, true, true), MosaicId.CreateFromMosaicIdentifier("myspace:subspacewithlevy"), new MosaicLevy(Mosaic.CreateFromIdentifier("myspace:subspace", 100), 1, Address.CreateFromEncoded("TCTUIF-557ZCQ-OQPW2M-6GH4TC-DPM2ZY-BBL54K-GNHR")), PublicAccount.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.TEST_NET), "new mosaic test" ).SignWith(keyPair); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(transaction); Assert.AreEqual("FAILURE_MOSAIC_MODIFICATION_NOT_ALLOWED", response.Message); }
public Task <(string hash, string signedTransaction)> SignTransactionAsync( string transactionContext, IReadOnlyList <string> privateKeys) { if (privateKeys.Count != 1) { throw new ArgumentException("Only single private key is allowed"); } var key = KeyPair.CreateFromPrivateKey(privateKeys[0]); var signedTransaction = TransferTransaction.FromJson(transactionContext).SignWith(key); var result = ( signedTransaction.Hash, signedTransaction.ToJson() ); return(Task.FromResult(result)); }
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 AnnounceTransferTransactionWithMosaicWithSecureMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TAVPDJ-DR3R3X-4FJUKN-PY2IQB-NNRFV2-QR5NJZ-J3WR"), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 10) }, SecureMessage.Create("hello2", Config.PrivateKeyMain, "4cc7409929a72019240065c9e53aa339f87ba889238ff9fbe978251fdbb05d9f") ).SignWith(keyPair); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(transaction); Assert.AreEqual("SUCCESS", response.Message); }
public async Task MutableMosaicCreationTransaction() { var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = MosaicDefinitionTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(1), "happy", "test2", new MosaicProperties(true, true, false, 0x04, 100000)) .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_Mosaic_Modification_No_Changes", status.Status); }
public async Task MosaicSupplyIncreaseTransction() { var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = MosaicSupplyChangeTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), new MosaicId("happy:test2"), MosaicSupplyType.Type.INCREASE, (ulong)new Random().Next(100000000, 1100000000) ).SignWith(signer); await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction); var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1); Assert.AreEqual(signer.PublicKeyString, status.Signer.PublicKey); }
public async Task MosaicSupplyIncreaseShouldFailImmutableSupply() { var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = MosaicSupplyChangeTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), new MosaicId("happy:test3"), MosaicSupplyType.Type.INCREASE, 10000) .SignWith(signer); await new TransactionHttp(host).Announce(transaction); listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Subscribe(e => Console.WriteLine(e.TransactionInfo.Hash)); var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == transaction.Hash).Take(1); Assert.AreEqual("Failure_Mosaic_Supply_Immutable", status.Status); }
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithoutMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"), new List <Mosaic>() { Mosaic.CreateFromIdentifier("nem:xem", 10) }, EmptyMessage.Create() ).SignWith(keyPair); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(transaction); Assert.AreEqual("SUCCESS", response.Message); }
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 AnnounceTransferTransactionWithMultipleMosaicsWithSecureMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"), new List <Mosaic>() { Mosaic.CreateFromIdentifier("nem:xem", 1000), //Mosaic.CreateFromIdentifier("nis1porttest:test", 10), TODO: fix multiple mosaic transfer }, SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068") ).SignWith(keyPair); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(transaction); Assert.AreEqual("SUCCESS", response.Message); }
public async Task CanModifyMultisigAccount() { var keyPair = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256"); var transaction = MultisigAggregateModificationTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(1), 1, new List <MultisigModification>() { new MultisigModification(PublicAccount.CreateFromPublicKey("eb100d6b2da10fc5359ab35a5801b0e6f0b6cc18d849c0aa78ba1aab2b945dea", NetworkType.Types.TEST_NET), CosignatoryModificationType.Types.Add) }); var multisigTransaction = MultisigTransaction.Create(NetworkType.Types.TEST_NET, Deadline.CreateHours(1), transaction) .SignWith(keyPair, PublicAccount.CreateFromPublicKey("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET)); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(multisigTransaction); Assert.AreEqual("FAILURE_MULTISIG_ALREADY_A_COSIGNER", response.Message); }
public async Task MosaicSupplyDecreaseTransction() { var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = MosaicSupplyChangeTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), new MosaicId("happy:test2"), MosaicSupplyType.Type.DECREASE, 10000) .SignWith(signer); await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction); listener.TransactionStatus(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)) .Subscribe(e => Console.WriteLine(e.Status)); var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1); Assert.AreEqual("B974668ABED344BE9C35EE257ACC246117EFFED939EAF42391AE995912F985FE", status.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 AnnounceTransferTransactionWithMosaicWithMessage() { KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); TransferTransaction transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TACOPE-XRLZTU-WBQA3U-XV66R4-55L76E-NWK6OY-ITBJ"), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 1) }, EmptyMessage.Create() ); SignedTransaction signedTransaction = transaction.SignWith(keyPair); Console.WriteLine(signedTransaction.Hash); Console.WriteLine(transaction.Fee); TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction); Assert.AreEqual("SUCCESS", response.Message); }
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 static async void CreateTransaction(Account receiverAcc, String message) { KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded(receiverAcc.Address.Plain), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 2000000) }, SecureMessage.Create(message, Config.PrivateKeyMain, receiverAcc.PublicKey) ); TransactionHttp transactionHttp = new TransactionHttp("http://" + Config.Domain + ":7890"); SignedTransaction signedTransaction = transaction.SignWith(keyPair); Thread.Sleep(2000); await transactionHttp.Announce(signedTransaction); Console.WriteLine(signedTransaction.Hash); Console.WriteLine(receiverAcc.Address.Plain + " recve something from : " + Config.Address); Thread.Sleep(2000); }
public void Should_Sign_Data_And_Verify_Signature_SHA3_256() { var pk = "A574ECE8F79DE11A39C6BADF0EF87C2C88730A5EA4CF2C0BD7E27103390BC4F4"; var pubKey = "2B0FF0CADE0D945A23D1AF7AF266A0BAB7E07B163756F5F16CC75F24A4EEF23B"; var keyPair = KeyPair.CreateFromPrivateKey(pk); var message = "This is a test data"; var data = Encoding.UTF8.GetBytes(message); var encryptedData = CryptoUtils.Sha3_256(data); var encryptedHex = CryptoBytes.ToHexStringUpper(encryptedData); var signature = keyPair.Sign(encryptedData); var sigHex = CryptoBytes.ToHexStringUpper(signature); var sig2 = CryptoBytes.FromHexString(sigHex); var publicAccount = PublicAccount.CreateFromPublicKey(pubKey, NetworkType.MIJIN_TEST); var isValid = publicAccount.VerifySignature(encryptedData, sig2); isValid.Should().BeTrue(); }
public async Task AnnounceTransferTransactionWithMosaicWithSecureMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 10) }, SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068") ).SignWith(keyPair); await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction); listener.TransactionStatus(Address.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.MIJIN_TEST)) .Subscribe(e => Console.WriteLine(e.Status)); var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1); Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey); }
public static async Task <bool> TransferTest() { KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); TransferTransaction transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TBZQXJ-N7JNQL-N7ZAMC-HFFZAU-WBMPB4-4RMIZU-XKNQ"), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 1000000) }, PlainMessage.Create("Sr Alejo") ); SignedTransaction signedTransaction = transaction.SignWith(keyPair); Console.WriteLine(signedTransaction.Hash); Console.WriteLine(transaction.Fee); TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction); return(true); }
public async Task SecretLockTransactionTest() { var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var secretHash = new byte[64]; var digest = new Sha3Digest(512); digest.BlockUpdate("5D8BEBBE80D7EA3B0088E59308D8671099781429".FromHex(), 0, "5D8BEBBE80D7EA3B0088E59308D8671099781429".FromHex().Length); digest.DoFinal(secretHash, 0); var transaction = SecretLockTransaction.Create( NetworkType.Types.MIJIN_TEST, 3, Deadline.CreateHours(2), 0, new Mosaic(new MosaicId("nem:xem"), 10000000), 10000, HashType.Types.SHA3_512, secretHash.ToHexLower(), Address.CreateFromPublicKey("5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068", NetworkType.Types.MIJIN_TEST) ) .SignWith(signer); listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)) .Subscribe( e => { Assert.Fail("Success"); }); await new TransactionHttp(host).Announce(transaction); var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == transaction.Hash).Take(1); Assert.AreEqual("Failure_Lock_Hash_Exists", status.Status); }
//[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 string GetMessagePayload(TransferTransaction transferTransaction, string accountPrivateKey) { CheckParameter(transferTransaction != null, "transferTransaction is required"); switch (transferTransaction.Message) { case PlainMessage plainMessage: return(plainMessage.GetStringPayload()); case SecureMessage secureMessage: if (accountPrivateKey == null) { throw new MissingPrivateKeyOnDownloadException( "accountPrivateKey is required to download a secure message"); } var retrieverKeyPair = KeyPair.CreateFromPrivateKey(accountPrivateKey); return(secureMessage.GetDecodedPayload(accountPrivateKey, GetTransactionOtherPartyPublicKey(retrieverKeyPair, transferTransaction))); default: throw new NotSupportedException( $"Download of message type {transferTransaction.Message} is not supported"); } }
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithSecureMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), Address.CreateFromEncoded("SAOV4Y5W627UXLIYS5O43SVU23DD6VNRCFP222P2"), new List <Mosaic>() { Mosaic.CreateFromIdentifier("nem:xem", 1000000000000), //Mosaic.CreateFromIdentifier("happy:test2", 10), }, SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068") ).SignWith(keyPair); await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction); var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1); Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey); }
public async Task CanSignMultisigTransaction() { var cosignatory = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256"); var secondCosig = KeyPair.CreateFromPrivateKey("cfe47dd9801a5d4fe37183e8f6ca49fff532a2fe6fe099436df93b3d62fe17d5"); var multisigAccount = PublicAccount.CreateFromPublicKey("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET); var recipient = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.TEST_NET); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), recipient.Address, new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 1000000) }, PlainMessage.Create("hello") ); var multisigTransaction = MultisigTransaction .Create(NetworkType.Types.TEST_NET, Deadline.CreateHours(1), transaction) .SignWith(cosignatory, multisigAccount); var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(multisigTransaction); Assert.AreEqual("SUCCESS", response.Message); var signatureTransaction = CosignatureTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(1), "59f5f7cbbdaa996b8d3c45ce814280aab3b5d322a98fe95c00ae516cf436172d", multisigAccount.Address ).SignWith(secondCosig); var response2 = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signatureTransaction); Assert.AreEqual("FAILURE_MULTISIG_NO_MATCHING_MULTISIG", response2.Message); }
public static async Task <bool> CreateTransaction() { KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TCPCAZ-7XJ2X4-SWR6AG-6BUEKS-6DQ7DL-Z2D6QB-5M2V"), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 10) }, SecureMessage.Create("hello", Config.PrivateKeyMain, "d72f89db8d0a3655168c9d2abe8de2910aaf4506a47d46e22ca48c7e0442e8ef") ); TransactionHttp transactionHttp = new TransactionHttp("http://" + Config.Domain + ":7890"); SignedTransaction signedTransaction = transaction.SignWith(keyPair); Thread.Sleep(2000); await transactionHttp.Announce(signedTransaction); Console.WriteLine(signedTransaction.Hash); Thread.Sleep(2000); return(true); }
public async Task GetMultisigGraphInfo() { var response = await new AccountHttp(host).GetMultisigAccountGraphInfo(new PublicAccount(KeyPair.CreateFromPrivateKey("9abcd1bd50b994799f8a2e27f7ffd952831ef16a443a48241f1f78942322d5c6").PublicKeyString, NetworkType.Types.MIJIN_TEST)); Assert.AreEqual(2, response.MultisigAccounts[0][0].MinApproval); Assert.AreEqual(2, response.MultisigAccounts[0][0].MinRemoval); Assert.AreEqual("A8FCF4371B9C4B26CE19A407BA803D3813647608D57ABC1550925A54AEE2C9EA", response.MultisigAccounts[0][0].Account.PublicKey); }