public void Transfer(int amount, int amountReceiver) { balance += amount; TransferTransaction newTransaction = new TransferTransaction(transferAmount, transferToId, owner); transactions.Add(newTransaction); }
public static async System.Threading.Tasks.Task CreateTransactionAsync(int xpxAmount, List <Account> recipients) { foreach (var recipient in recipients) { var client = new SiriusClient("http://bctestnet1.brimstone.xpxsirius.io:3000"); var networkType = client.NetworkHttp.GetNetworkType().Wait(); var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative((ulong)xpxAmount); var transferTransaction = TransferTransaction.Create( Deadline.Create(), recipient.Address, new List <Mosaic>() { mosaicToTransfer }, PlainMessage.Create("Transfered " + xpxAmount.ToString() + " successfully."), NetworkType.TEST_NET ); var generationHash = await client.BlockHttp.GetGenerationHash(); var signedTransaction = senderAccount.Sign(transferTransaction, generationHash); await client.TransactionHttp.Announce(signedTransaction); var newAccountInfo = await client.AccountHttp.GetAccountInfo(senderAccount.Address); Console.WriteLine("Sent " + Convert.ToInt32(xpxAmount) + " XPX to: \n"); Console.WriteLine($"{nameof(newAccountInfo)} : {newAccountInfo}"); } }
public void Transfer_Execute_WithdrawBalanceUpdatesOK() { TransferTransaction transfer = new TransferTransaction(from, to, 50); _ = transfer.Execute(); Assert.Equal(50, from.Balance); }
public static async Task getResponse() { try { Account sender = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET); KeyPair keyPair1 = sender.KeyPair; Account reciever = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET); KeyPair keyPair2 = reciever.KeyPair; var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TB2Z7J-R2K3BZ-2TRS6D-H5747F-Y3XKUM-BNWCI4-BPDJ"), new List <Mosaic> { Xem.CreateRelative(1) }, SecureMessage.Create("Well shit. W/ mosaic", sender.PrivateKey, reciever.PublicKey) ); SignedTransaction signedTransaction = transaction.SignWith(keyPair1); TransactionResponse response = await new TransactionHttp(host).Announce(signedTransaction); Console.WriteLine(response.Message); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); } }
public void Transfer_Executes_StatusComplete() { TransferTransaction transfer = new TransferTransaction(from, to, 50); _ = transfer.Execute(); Assert.Equal("Complete", transfer.Status); }
public void Transfer_Execute_DepositBalanceUpdatesOK() { TransferTransaction transfer = new TransferTransaction(from, to, 50); _ = transfer.Execute(); Assert.Equal(150, to.Balance); }
public void Transfer_Executes_ExecutedIsTrue() { TransferTransaction transfer = new TransferTransaction(from, to, 50); _ = transfer.Execute(); Assert.True(transfer.Executed); }
public void Transfer_SetId_OK() { TransferTransaction transfer = new TransferTransaction(from, to, 50); transfer.SetId(1); Assert.Equal(1, transfer.Id); }
public async Task Should_Serialize_And_Sign_TransactionAsync() { var account2 = Account.CreateFromPrivateKey("D54AC0CB0FF50FB44233782B3A6B5FDE2F1C83B9AE2F1352119F93713F3AB923", NetworkType.TEST_NET); // var nonce = MosaicNonce.CreateRandom(); var account = Account.CreateFromPrivateKey("feab2970d23c9a6f0170adf9b846575831c63084bcf1f0d7e70644818c546017", NetworkType.TEST_NET); // var mosaicId = MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey); var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(1000); var transferTransaction = TransferTransaction.Create(Deadline.Create(), Recipient.From(Address.CreateFromRawAddress("VDVLDGVUEZ2X2CB5AZLOVHV6UK4DPCQHHWHCV75T")), new List <Mosaic>() { mosaicToTransfer }, PlainMessage.Create("test-message"), NetworkType.TEST_NET ); var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7"; var signedTransaction = account.Sign(transferTransaction, generationHash); //var payload = signedTransaction.Payload; signedTransaction.Payload.Should().NotBeNullOrEmpty(); signedTransaction.Hash.Should().NotBeNullOrEmpty(); }
public static async Task <bool> SendFromNewAccount(String message, Account newAcc) { KeyPair keyPair = KeyPair.CreateFromPrivateKey(newAcc.PrivateKey); var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded(Config.Address), new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 10) }, SecureMessage.Create(message, newAcc.PrivateKey, Config.PublicKey) ); TransactionHttp transactionHttp = new TransactionHttp("http://" + Config.Domain + ":7890"); SignedTransaction signedTransaction = transaction.SignWith(keyPair); Thread.Sleep(2000); await transactionHttp.Announce(signedTransaction); Thread.Sleep(2000); Console.WriteLine(signedTransaction.Hash); Console.WriteLine(Config.Address + " recve something from : " + newAcc.Address.Plain); return(true); }
private static void DoTransfer(Bank fromBank, Bank toBank) { Account fromAccount = FindAccount(fromBank); if (fromAccount == null) { return; } Console.WriteLine($"Transferring From {fromAccount.name}"); Account toAccount = FindAccount(toBank); if (toAccount == null) { return; } Console.WriteLine($"Transferring to {toAccount.name}"); decimal amount; Console.Write($"Please enter the amount to transfer to {toAccount.name}: "); try { amount = Convert.ToDecimal(Console.ReadLine()); TransferTransaction transfer = new TransferTransaction(fromAccount, toAccount, amount); Bank.ExecuteTransaction(transfer); } catch (Exception e) { Console.WriteLine("Transfer error!"); Console.WriteLine(e.Message); } }
public ActionResult ConfirmTransfer(TransferModel paymentInfo, FormCollection collcetion) { if (paymentInfo.CardId == 0) { return(RedirectToAction("Transfer")); } if (paymentInfo.ToOwnPayments) { OwnPaymentsModule.AddTransferOwnPayment(paymentInfo, rep, WebSecurity.CurrentUserId); } TransferTransaction tt = new TransferTransaction(); tt.Amount = paymentInfo.Amount; tt.CardAccountID = paymentInfo.CardId; tt.CustomerID = WebSecurity.CurrentUserId; tt.Date = Time.GetTime(); tt.TargetCardAccountID = paymentInfo.TargetCardAccountId; tt.Number = paymentInfo.Message; tt.Type = PaymentType.Transfer; bool success = service.CreateTransferTransaction(tt); if (success) { return(View("Message", (object)"Вы перевели средства")); } else { return(View("Message", (object)"Что то пошло не так. Попробуйте еще раз")); } }
public async Task AnnounceTransferTransactionWithMosaicWithMessage() { var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain); var account = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.MIJIN_TEST); var transaction = TransferTransaction.Create( NetworkType.Types.MIJIN_TEST, Deadline.CreateHours(2), account.Address, new List <Mosaic> { Mosaic.CreateFromIdentifier("nem:xem", 100000000000) }, PlainMessage.Create("hello") ).SignWith(keyPair); listener.TransactionStatus(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)) .Subscribe(e => { Console.WriteLine(e.Status); }); 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 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.DecryptPayload(accountPrivateKey, GetTransactionOtherPartyPublicKey(retrieverKeyPair, transferTransaction))); default: throw new NotSupportedException( $"Download of message type {transferTransaction.Message} is not supported"); } }
private static void DoTransfer(Bank toBank) { Account toAccount; Account fromAccount; String input; decimal transfer = 0; Console.WriteLine("Which account do you wish to transfer from?: "); fromAccount = FindAccount(toBank); Console.WriteLine("Which account do you wish to transfer To?: "); toAccount = FindAccount(toBank); Console.WriteLine("How much would you like to transfer?: "); try { input = Console.ReadLine(); transfer = Convert.ToDecimal(input); } catch (System.FormatException) { Console.WriteLine("Not a number"); } TransferTransaction transferT = new TransferTransaction(toAccount, fromAccount, transfer); toBank.ExecuteTransaction(transferT); transferT.Print(); }
public static async Task getResponse() { try { Account account = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET); KeyPair keyPair = account.KeyPair; var transaction = TransferTransaction.Create( NetworkType.Types.TEST_NET, Deadline.CreateHours(2), Address.CreateFromEncoded("TB2Z7J-R2K3BZ-2TRS6D-H5747F-Y3XKUM-BNWCI4-BPDJ"), new List <Mosaic> { Xem.CreateRelative(10) }, PlainMessage.Create("Well shit. W/ mosaic") ); SignedTransaction signedTransaction = transaction.SignWith(keyPair); TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction); Console.WriteLine(response.Message); } catch (Exception e) { Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); } }
protected void btnComfirmToNext_Click(object sender, EventArgs e) { int customerId = 0; Int32.TryParse(((String)Session["selTransferee"]).Substring(0, 4), out customerId); TransferTransaction transaction = new TransferTransaction(Convert.ToDouble(Session["amount"])); if ((int)Session["accountTypeIndex"] == 0) { transaction.FromAccount = customers[(int)Session["selCustomerIndex"] - 1].Checking; } else { transaction.FromAccount = customers[(int)Session["selCustomerIndex"] - 1].Saving; } if ((int)Session["accountTransfereeIndex"] == 0) { transaction.ToAccount = Customer.GetCustomerById(customerId).Checking; } else { transaction.ToAccount = Customer.GetCustomerById(customerId).Saving; } TransactionResult result = transaction.Execute(); Session["result"] = result; Response.Redirect("FundTransferResult.aspx"); }
public ActionResult Transfer(TransferTransaction transferTransaction) { var applicationUserId = User.Identity.GetUserId(); var checkingAccount = db.CheckingAccounts.FirstOrDefault(x => x.ApplicationUserId == applicationUserId); if (checkingAccount.Balance < transferTransaction.Amount) { ModelState.AddModelError("Amount", "Insufficient!"); } if (ModelState.IsValid) { var transaction = new Transaction(); transaction.CheckingAccountId = checkingAccount.Id; transaction.Amount = -transferTransaction.Amount; transaction.Description = DateTime.Now.ToString("G") + ": Transfer to Account #" + transferTransaction.RecievingCheckingAccountNumber; checkingAccount.Balance += transaction.Amount; db.Transactions.Add(transaction); db.SaveChanges(); transaction.Amount = -transaction.Amount; return(PartialView("_SuccessfulTransaction", transaction)); } return(View()); }
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 TransactionDetailDto AsTransactionDetailDto(Transaction transaction) { TransactionDetailDto dto = new TransactionDetailDto(); switch (transaction.Type) { case "Deposit": DepositTransaction deposit = transaction as DepositTransaction; dto.ToAccountId = deposit.Account.Id; break; case "Withdraw": WithdrawTransaction withdraw = transaction as WithdrawTransaction; dto.FromAccountId = withdraw.Account.Id; break; case "Transfer": TransferTransaction transfer = transaction as TransferTransaction; dto.FromAccountId = transfer.From.Id; dto.ToAccountId = transfer.To.Id; break; default: break; } dto.Id = transaction.Id; dto.Type = transaction.Type; dto.Amount = transaction.Amount; dto.DateStamp = transaction.DateStamp; dto.Status = transaction.Status; return(dto); }
private void ValidateTransferTx(TransferTransaction transaction, string transactionDTO) { var tx = JsonConvert.DeserializeObject <TransferTransactionInfoDTO>(transactionDTO); Assert.AreEqual(tx.Transaction.Recipient, transaction.Address.Plain); var mosaics = tx.Transaction.Mosaics.Select(m => new Mosaic(new MosaicId(BitConverter.ToUInt64(m.MosaicId.FromHex(), 0)), m.Amount)).ToList(); if (mosaics != null && mosaics.Count > 0) { Assert.AreEqual(mosaics[0].MosaicId.Id, transaction.Mosaics[0].MosaicId.Id); Assert.AreEqual(mosaics[0].Amount, transaction.Mosaics[0].Amount); } try { Assert.AreEqual(Encoding.UTF8.GetString(tx.Transaction.Message.Payload.FromHex()), Encoding.UTF8.GetString(transaction.Message.GetPayload())); } catch (Exception e) { Console.WriteLine(e); } Assert.IsTrue(tx.Transaction.Type == transaction.TransactionType.GetValue()); }
private static void DoTransfer(Bank toBank) { decimal amount; do { try { Account toAccount = FindAccount(toBank); Account fromAccount = FindAccount(toBank); if (toAccount == null) { return; } Console.WriteLine(" Enter amount to transfer: "); amount = Convert.ToDecimal(Console.ReadLine()); TransferTransaction transfer = new TransferTransaction(fromAccount, toAccount, amount); toBank.ExecuteTransaction(transfer); } catch (System.Exception) { Console.Error.WriteLine(" You have entered an invalid value! "); amount = -1; } } while (amount < 1); }
public async Task Given_transfer_with_two_accounts_When_add_it_Then_it_is_accepted() { var target = TestClientFactory.BuildClient(out var settings); var transaction = new TransferTransaction { Description = "Test transfer transaction from Buxfer", Amount = 5.0m, FromAccountId = settings.AccountId, ToAccountId = settings.AnotherAccountId, Date = DateTime.Now }; transaction.TagNames.Add(BuxferClientAutoTestsTag); var createdTransaction = await target.AddTransaction(transaction); createdTransaction.ShouldBeLike(transaction); createdTransaction.Amount.Should().Be(transaction.Amount); createdTransaction.FromAccountId.Should().Be(transaction.FromAccountId); createdTransaction.ToAccountId.Should().Be(transaction.ToAccountId); createdTransaction.AccountId.Should().Be(0); var loadedTransaction = await Load <TransferTransaction>(target, createdTransaction.Id, transaction.TagNames.First()); loadedTransaction.ShouldBeLike(transaction); }
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 <Transaction> Transfer(Account from, Address to, Mosaic mosaic, IMessage message, string generationHash) { var transferTransaction = TransferTransaction.Create( Deadline.Create(), Recipient.From(to), new List <Mosaic>() { mosaic }, message, NetworkType); var signedTransaction = from.Sign(transferTransaction, generationHash); WatchForFailure(signedTransaction); //Log.WriteLine($"Going to announce transaction {signedTransaction.Hash}"); var tx = SiriusWebSocketClient.Listener.ConfirmedTransactionsGiven(from.Address).Take(1); await SiriusClient.TransactionHttp.Announce(signedTransaction); var result = await tx; return(result); }
public async Task AnnounceMultisigTransaction() { var cosignatory = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256"); 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); }
public async Task AnnounceTransferTransactionWithMultipleMosaicsWithoutMessage() { 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("happy:test2", 10), Mosaic.CreateFromIdentifier("nem:xem", 10), }, EmptyMessage.Create() ).SignWith(keyPair); 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(keyPair.PublicKeyString, status.Signer.PublicKey); }
WalletError CreateSpendTx(IEnumerable <WalletAddr> candidates, string to, BigInteger amount, BigInteger fee, BigInteger feeMax, out Tuple <string, TransferTransaction> signedSpendTx) { signedSpendTx = null; if (fee > feeMax) { return(WalletError.MaxFeeBreached); } foreach (var acct in candidates) { // get balance for the account var balance = GetAddrBalance(acct.Address); logger.LogDebug($"balance {balance}, amount: {amount}, amount + fee: {amount + fee}"); // if the balance is greater then the fee we can use this account if (balance >= fee + amount) { // create signed transaction var account = CreateAccount(Int32.Parse(acct.Path)); var amountDecimal = asset.BigIntToAmount(amount); var feeDecimal = asset.BigIntToAmount(fee); var tx = new TransferTransaction(ChainId(), account.PublicKey, to, asset, amountDecimal, feeDecimal, feeAsset); tx.Sign(account); signedSpendTx = new Tuple <string, TransferTransaction>(acct.Address, tx); return(WalletError.Success); } } return(WalletError.InsufficientFunds); }
private static void DoTransfer(Bank toBank) { Account toAccount = FindAccount(toBank); if (toAccount == null) { return; } Account fromAccount = FindAccount(toBank); if (fromAccount == null) { return; } Console.WriteLine("Enter amount to transfer: "); string input = Console.ReadLine(); decimal amount = Convert.ToDecimal(input); TransferTransaction transfertransac = new TransferTransaction(fromAccount, toAccount, amount); toBank.ExecuteTransaction(transfertransac); transfertransac.Print(); }
public async Task <object> TestingTransfer(string from, string privateKey, string to, IAsset asset, decimal amount) { var nodeHttp = new NodeHttp(_nemUrl); var networkType = await nodeHttp.GetNetworkType(); var networkTime = (int)(await nodeHttp.GetExtendedNodeInfo()).NisInfo.CurrentTime; var toAddressParts = to.Split(AddressSeparator); var message = toAddressParts.Length > 1 ? PlainMessage.Create(toAddressParts[1]) as IMessage : EmptyMessage.Create(); var mosaic = Mosaic.CreateFromIdentifier(asset.AssetId, (ulong)asset.ToBaseUnit(amount)); var fee = await TransferTransaction.CalculateFee(networkType, message, new[] { mosaic }, new NamespaceMosaicHttp(_nemUrl)); var tx = TransferTransaction.Create( networkType, new Deadline(networkTime + _expiresInSeconds), fee.fee, Address.CreateFromEncoded(toAddressParts[0]), new List <Mosaic> { mosaic }, message, networkTime); var signed = tx.SignWith(KeyPair.CreateFromPrivateKey(privateKey)); var result = await new TransactionHttp(_nemUrl).Announce(signed); return(result); }
public void CustomerTransfer(Customer name) { // Get the account to transfer between Console.Write("\n Select account (1 - Checkings to Savings, 2 - Savings to Checkings): "); var selection = Convert.ToInt32(Console.ReadLine()); Account sourceAccount; Account destinationAccount; switch (selection) { case 1: sourceAccount = name.GetCheckingsAccount(); destinationAccount = name.GetSavingsAccount(); break; default: sourceAccount = name.GetSavingsAccount(); destinationAccount = name.GetCheckingsAccount(); break; } // Get the transfer amount Console.Write("\n Enter Amount: "); var transferAmount = Convert.ToDouble((Console.ReadLine())); // Create a new transaction with the transfer info var transferTransaction = new TransferTransaction(sourceAccount, destinationAccount, transferAmount).FinalizeTransaction(); if (transferTransaction == TransactionResult.Success) { Console.WriteLine("\n\tTransfer Completed"); } else { Console.WriteLine("\n\tInsufficient funds, account balance $" + sourceAccount.GetAccountBalance()); } }
public TestWindow(Program.Logger _logger) { StackPanel sp1 = null; StackPanel sp2 = null; EventHandler<Program.LogData> _LoggerLogAdded = (sender, e) => ((Action)(() => { TextBlock tb = new TextBlock(); tb.Text = e.Text; tb.Foreground = e.Kind == Program.LogData.LogKind.error ? Brushes.Red : Brushes.White; tb.Margin = new Thickness(0.0, 10.0, 0.0, 10.0); sp2.Children.Add(tb); })).BeginExecuteInUIThread(); Loaded += (sender, e) => { Grid grid = new Grid(); grid.RowDefinitions.Add(new RowDefinition()); grid.RowDefinitions.Add(new RowDefinition()); grid.RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto }); grid.ColumnDefinitions.Add(new ColumnDefinition()); ScrollViewer sv1 = new ScrollViewer(); sv1.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; sv1.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; sv1.SetValue(Grid.RowProperty, 0); sv1.SetValue(Grid.ColumnProperty, 0); sp1 = new StackPanel(); sp1.Background = Brushes.Black; ScrollViewer sv2 = new ScrollViewer(); sv2.VerticalScrollBarVisibility = ScrollBarVisibility.Auto; sv2.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto; sv2.SetValue(Grid.RowProperty, 1); sv2.SetValue(Grid.ColumnProperty, 0); sp2 = new StackPanel(); sp2.Background = Brushes.Black; sv1.Content = sp1; sv2.Content = sp2; TextBox tb = new TextBox(); tb.SetValue(Grid.RowProperty, 2); tb.SetValue(Grid.ColumnProperty, 0); grid.Children.Add(sv1); grid.Children.Add(sv2); grid.Children.Add(tb); Content = grid; Console.SetOut(new TextBlockStreamWriter(sp1)); _logger.LogAdded += _LoggerLogAdded; //SimulationWindow sw = new SimulationWindow(); //sw.ShowDialog(); this.StartTask(string.Empty, string.Empty, () => { //string testPrivateRsaParameters; //using (RSACryptoServiceProvider rsacsp = new RSACryptoServiceProvider(2048)) // testPrivateRsaParameters = rsacsp.ToXmlString(true); //RealInboundChennel ric = new RealInboundChennel(7777, RsaKeySize.rsa2048, 100); //ric.Accepted += (sender2, e2) => //{ // this.StartTask("", "", () => // { // e2.WriteBytes(BitConverter.GetBytes(true)); // bool b = BitConverter.ToBoolean(e2.ReadBytes(), 0); // SessionChannel sc = e2.NewSession(); // sc.WriteBytes(BitConverter.GetBytes(true)); // sc.Close(); // //e2.Close(); // }); // //e2.Close(); // //Console.WriteLine(""); //}; //ric.RequestAcceptanceStart(); //AutoResetEvent are = new AutoResetEvent(false); //SocketChannel socketc = null; //RealOutboundChannel roc = new RealOutboundChannel(IPAddress.Loopback, 7777, RsaKeySize.rsa2048, testPrivateRsaParameters); //roc.Connected += (sender2, e2) => //{ // socketc = e2; // socketc.Sessioned += (sender3, e3) => // { // bool b3 = BitConverter.ToBoolean(e3.ReadBytes(), 0); // Console.WriteLine(""); // }; // are.Set(); // //e2.Close(); // //Console.WriteLine("connected"); //}; //roc.RequestConnection(); //are.WaitOne(); //bool b2 = BitConverter.ToBoolean(socketc.ReadBytes(), 0); //socketc.WriteBytes(BitConverter.GetBytes(true)); //socketc.Close(); //CirculatedInteger ci = new CirculatedInteger(5); //Console.WriteLine(ci.GetForward(0)); //Console.WriteLine(ci.GetForward(1)); //Console.WriteLine(ci.GetForward(2)); //Console.WriteLine(ci.GetForward(3)); //Console.WriteLine(ci.GetForward(4)); //Console.WriteLine(ci.GetForward(5)); //Console.WriteLine(ci.GetForward(6)); //Console.WriteLine(ci.GetBackward(0)); //Console.WriteLine(ci.GetBackward(1)); //Console.WriteLine(ci.GetBackward(2)); //Console.WriteLine(ci.GetBackward(3)); //Console.WriteLine(ci.GetBackward(4)); //Console.WriteLine(ci.GetBackward(5)); //Console.WriteLine(ci.GetBackward(6)); Secp256k1KeyPair<Sha256Hash> secp256k1KeyPair = new Secp256k1KeyPair<Sha256Hash>(true); Sha256Ripemd160Hash address = new Sha256Ripemd160Hash(secp256k1KeyPair.pubKey.pubKey); TransactionInput ti1 = new TransactionInput(); ti1.LoadVersion1(0, 0, 0); TransactionOutput to1 = new TransactionOutput(); to1.LoadVersion0(address, new Creacoin(50m)); CoinbaseTransaction ct1 = new CoinbaseTransaction(); ct1.LoadVersion0(new TransactionOutput[] { to1 }); byte[] ctBytes1 = ct1.ToBinary(); CoinbaseTransaction ct2 = SHAREDDATA.FromBinary<CoinbaseTransaction>(ctBytes1); TransferTransaction tt1 = new TransferTransaction(); tt1.LoadVersion1(new TransactionInput[] { ti1 }, new TransactionOutput[] { to1 }); tt1.Sign(new TransactionOutput[] { to1 }, new DSAPRIVKEYBASE[] { secp256k1KeyPair.privKey }); byte[] ttBytes1 = tt1.ToBinary(); TransferTransaction tt2 = SHAREDDATA.FromBinary<TransferTransaction>(ttBytes1); ResTransactions rt1 = new ResTransactions(new Transaction[] { ct1, tt1 }); byte[] rtBytes1 = rt1.ToBinary(); ResTransactions rt2 = SHAREDDATA.FromBinary<ResTransactions>(rtBytes1); byte[] test1 = SHAREDDATA.ToBinary<Transaction>(ct2); CoinbaseTransaction ct3 = SHAREDDATA.FromBinary<Transaction>(test1) as CoinbaseTransaction; byte[] test2 = SHAREDDATA.ToBinary<Transaction>(tt2); TransferTransaction tt3 = SHAREDDATA.FromBinary<Transaction>(test2) as TransferTransaction; //string pathBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); //New.BlockManagerDB bmdb = new New.BlockManagerDB(pathBase); //New.BlockDB blkdb = new New.BlockDB(pathBase); //New.BlockFilePointersDB bfpdb = new New.BlockFilePointersDB(pathBase); //New.BlockManager bm = new New.BlockManager(bmdb, blkdb, bfpdb); //New.TestBlock block1 = new New.TestBlock(1); //bm.AddMainBlock(block1); //bm.AddMainBlock(block1); //Test10NodesInv(); //TestDHT(); //bool isFirst = true; //int portNumber = 0; //CreaNode cnlt = null; //tb.KeyDown += (sender2, e2) => //{ // if (e2.Key != Key.Enter) // return; // if (isFirst) // { // portNumber = int.Parse(tb.Text); // FirstNodeInfosDatabase fnidb = new FirstNodeInfosDatabase(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); // cnlt = new CreaNode((ushort)portNumber, 0, "test", fnidb); // cnlt.Start(); // cnlt.ReceivedNewChat += (sender3, e3) => // { // this.ConsoleWriteLine(e3.Message); // }; // isFirst = false; // return; // } // Chat chat = new Chat(); // chat.LoadVersion0(portNumber.ToString(), tb.Text); // chat.Sign(secp256k1KeyPair.privKey); // cnlt.DiffuseNewChat(chat); //}; }); }; Closed += (sender, e) => { _logger.LogAdded -= _LoggerLogAdded; string fileText = string.Empty; foreach (var child in sp1.Children) fileText += (child as TextBlock).Text + Environment.NewLine; File.AppendAllText(Path.Combine(new FileInfo(Assembly.GetEntryAssembly().Location).DirectoryName, "LogTest.txt"), fileText); }; }
public void NewTransaction(IAccount iAccount, Sha256Ripemd160Hash address, CurrencyUnit amount, CurrencyUnit fee) { if (!isSystemStarted) throw new InvalidOperationException("core_not_started"); Account account = iAccount as Account; if (account == null) throw new ArgumentException("iaccount_type"); utxodb.Open(); List<Utxo> utxosList = blockChain.GetAllUtxos(account.Address.Hash); utxosList.Sort((a, b) => { if (a.blockIndex < b.blockIndex) return -1; else if (a.blockIndex > b.blockIndex) return 1; if (a.txIndex < b.txIndex) return -1; else if (a.txIndex > b.txIndex) return 1; if (a.txOutIndex < b.txOutIndex) return -1; else if (a.txOutIndex > b.txOutIndex) return 1; return 0; }); Utxo[] utxos = utxosList.ToArray(); utxodb.Close(); List<TransactionInput> usedTxInList = new List<TransactionInput>(); foreach (var unconfirmedTh in transactionHistories.unconfirmedTransactionHistories.ToArray()) for (int i = 0; i < unconfirmedTh.prevTxOuts.Length; i++) if (unconfirmedTh.prevTxOuts[i].Address.Equals(account.Address.Hash)) usedTxInList.Add(unconfirmedTh.transaction.TxInputs[i]); usedTxInList.Sort((a, b) => { if (a.PrevTxBlockIndex < b.PrevTxBlockIndex) return -1; else if (a.PrevTxBlockIndex > b.PrevTxBlockIndex) return 1; if (a.PrevTxIndex < b.PrevTxIndex) return -1; else if (a.PrevTxIndex > b.PrevTxIndex) return 1; if (a.PrevTxOutputIndex < b.PrevTxOutputIndex) return -1; else if (a.PrevTxOutputIndex > b.PrevTxOutputIndex) return 1; return 0; }); TransactionInput[] usedTxIns = usedTxInList.ToArray(); List<Utxo> unusedUtxosList = new List<Utxo>(); int position = -1; for (int i = 0; i < usedTxIns.Length; i++) { bool flag = false; while (position < utxos.Length) { position++; if (usedTxIns[i].PrevTxBlockIndex == utxos[position].blockIndex && usedTxIns[i].PrevTxIndex == utxos[position].txIndex && usedTxIns[i].PrevTxOutputIndex == utxos[position].txOutIndex) { flag = true; break; } else unusedUtxosList.Add(utxos[position]); } if (!flag) throw new InvalidOperationException(); } long rawFeeAndAmount = amount.rawAmount + fee.rawAmount; List<Utxo> useUtxosList = new List<Utxo>(); long rawFeeAndAmountAndChange = 0; bool flag2 = false; foreach (var utxo in unusedUtxosList) { useUtxosList.Add(utxo); if ((rawFeeAndAmountAndChange += utxo.amount.rawAmount) > rawFeeAndAmount) { flag2 = true; break; } } if (!flag2) for (int i = position + 1; i < utxos.Length; i++) { useUtxosList.Add(utxos[i]); if ((rawFeeAndAmountAndChange += utxos[i].amount.rawAmount) > rawFeeAndAmount) { flag2 = true; break; } } if (!flag2) throw new InvalidOperationException(); Utxo[] useUtxos = useUtxosList.ToArray(); TransactionInput[] txIns = new TransactionInput[useUtxos.Length]; for (int i = 0; i < txIns.Length; i++) { txIns[i] = new TransactionInput(); txIns[i].LoadVersion0(useUtxos[i].blockIndex, useUtxos[i].txIndex, useUtxos[i].txOutIndex, account.Ecdsa256KeyPair.pubKey); } long rawChange = rawFeeAndAmountAndChange - rawFeeAndAmount; TransactionOutput[] txOuts = new TransactionOutput[rawChange == 0 ? 1 : 2]; txOuts[0] = new TransactionOutput(); txOuts[0].LoadVersion0(address, amount); if (rawChange != 0) { txOuts[1] = new TransactionOutput(); txOuts[1].LoadVersion0(account.Address.Hash, new CurrencyUnit(rawChange)); } TransactionOutput[] prevTxOuts = new TransactionOutput[useUtxos.Length]; for (int i = 0; i < prevTxOuts.Length; i++) prevTxOuts[i] = blockChain.GetMainBlock(txIns[i].PrevTxBlockIndex).Transactions[txIns[i].PrevTxIndex].TxOutputs[txIns[i].PrevTxOutputIndex]; Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[useUtxos.Length]; for (int i = 0; i < privKeys.Length; i++) privKeys[i] = account.Ecdsa256KeyPair.privKey; TransferTransaction ttx = new TransferTransaction(); ttx.LoadVersion0(txIns, txOuts); ttx.Sign(prevTxOuts, privKeys); creaNodeTest.DiffuseNewTransaction(ttx); }
//TransactionOutput、TransactionInput、CoinbaseTransaction、TransferTransactionのテスト public static void Test10() { Ecdsa256KeyPair keypair1 = new Ecdsa256KeyPair(true); Ecdsa256KeyPair keypair2 = new Ecdsa256KeyPair(true); Ecdsa256KeyPair keypair3 = new Ecdsa256KeyPair(true); Sha256Ripemd160Hash address1 = new Sha256Ripemd160Hash(keypair1.pubKey.pubKey); CurrencyUnit amount1 = new Creacoin(50.0m); Sha256Ripemd160Hash address2 = new Sha256Ripemd160Hash(keypair2.pubKey.pubKey); CurrencyUnit amount2 = new Creacoin(25.0m); Sha256Ripemd160Hash address3 = new Sha256Ripemd160Hash(keypair3.pubKey.pubKey); CurrencyUnit amount3 = new Yumina(0.01m); TransactionOutput txOut1 = new TransactionOutput(); txOut1.LoadVersion0(address1, amount1); TransactionOutput txOut2 = new TransactionOutput(); txOut2.LoadVersion0(address2, amount2); TransactionOutput txOut3 = new TransactionOutput(); txOut3.LoadVersion0(address3, amount3); if (txOut1.Address != address1) throw new Exception("test10_1"); if (txOut1.Amount != amount1) throw new Exception("test10_2"); byte[] txOutBytes = txOut1.ToBinary(); if (txOutBytes.Length != 29) throw new Exception("test10_3"); TransactionOutput txOutRestore = SHAREDDATA.FromBinary<TransactionOutput>(txOutBytes, 0); if (!txOut1.Address.Equals(txOutRestore.Address)) throw new Exception("test10_4"); if (txOut1.Amount.rawAmount != txOutRestore.Amount.rawAmount) throw new Exception("test10_5"); TransactionInput txIn1 = new TransactionInput(); txIn1.LoadVersion0(0, 0, 0, keypair1.pubKey); TransactionInput txIn2 = new TransactionInput(); txIn2.LoadVersion0(1, 0, 0, keypair2.pubKey); TransactionInput txIn3 = new TransactionInput(); txIn3.LoadVersion0(2, 0, 0, keypair3.pubKey); if (txIn1.PrevTxBlockIndex != 0) throw new Exception("test10_6"); if (txIn1.PrevTxIndex != 0) throw new Exception("test10_7"); if (txIn1.PrevTxOutputIndex != 0) throw new Exception("test10_8"); if (txIn1.SenderPubKey != keypair1.pubKey) throw new Exception("test10_9"); TransactionOutput[] txOuts = new TransactionOutput[] { txOut1, txOut2, txOut3 }; CoinbaseTransaction cTx = new CoinbaseTransaction(); cTx.LoadVersion0(txOuts); if (cTx.TxOutputs != txOuts) throw new Exception("test10_10"); if (cTx.TxInputs.Length != 0) throw new Exception("test10_11"); byte[] cTxBytes = cTx.ToBinary(); if (cTxBytes.Length != 97) throw new Exception("test10_12"); CoinbaseTransaction cTxRestore = SHAREDDATA.FromBinary<CoinbaseTransaction>(cTxBytes); if (!cTx.Id.Equals(cTxRestore.Id)) throw new Exception("test10_13"); if (cTx.Verify()) throw new Exception("test10_14"); if (cTx.VerifyNotExistDustTxOutput()) throw new Exception("test10_15"); if (!cTx.VerifyNumberOfTxInputs()) throw new Exception("test10_16"); if (!cTx.VerifyNumberOfTxOutputs()) throw new Exception("test10_17"); TransactionOutput[] txOuts2 = new TransactionOutput[11]; for (int i = 0; i < txOuts2.Length; i++) txOuts2[i] = txOut1; CoinbaseTransaction cTx2 = new CoinbaseTransaction(); cTx2.LoadVersion0(txOuts2); if (cTx2.Verify()) throw new Exception("test10_18"); if (!cTx2.VerifyNotExistDustTxOutput()) throw new Exception("test10_19"); if (!cTx2.VerifyNumberOfTxInputs()) throw new Exception("test10_20"); if (cTx2.VerifyNumberOfTxOutputs()) throw new Exception("test10_21"); TransactionOutput[] txOuts3 = new TransactionOutput[] { txOut1, txOut2 }; CoinbaseTransaction cTx3 = new CoinbaseTransaction(); cTx3.LoadVersion0(txOuts3); if (!cTx3.Verify()) throw new Exception("test10_22"); if (!cTx3.VerifyNotExistDustTxOutput()) throw new Exception("test10_23"); if (!cTx3.VerifyNumberOfTxInputs()) throw new Exception("test10_24"); if (!cTx3.VerifyNumberOfTxOutputs()) throw new Exception("test10_25"); TransactionInput[] txIns = new TransactionInput[] { txIn1, txIn2, txIn3 }; TransferTransaction tTx1 = new TransferTransaction(); tTx1.LoadVersion0(txIns, txOuts); tTx1.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (tTx1.TxInputs != txIns) throw new Exception("test10_26"); if (tTx1.TxOutputs != txOuts) throw new Exception("test10_27"); byte[] txInBytes = txIn1.ToBinary(); if (txInBytes.Length != 153) throw new Exception("test10_28"); TransactionInput txInRestore = SHAREDDATA.FromBinary<TransactionInput>(txInBytes, 0); if (txIn1.PrevTxBlockIndex != txInRestore.PrevTxBlockIndex) throw new Exception("test10_29"); if (txIn1.PrevTxIndex != txInRestore.PrevTxIndex) throw new Exception("test10_30"); if (txIn1.PrevTxOutputIndex != txInRestore.PrevTxOutputIndex) throw new Exception("test10_31"); if (!txIn1.SenderPubKey.pubKey.BytesEquals(txInRestore.SenderPubKey.pubKey)) throw new Exception("test10_32"); if (!txIn1.SenderSignature.signature.BytesEquals(txInRestore.SenderSignature.signature)) throw new Exception("test10_33"); byte[] tTxBytes = tTx1.ToBinary(); if (tTxBytes.Length != 557) throw new Exception("test10_34"); TransferTransaction tTxRestore = SHAREDDATA.FromBinary<TransferTransaction>(tTxBytes); if (!tTx1.Id.Equals(tTxRestore.Id)) throw new Exception("test10_35"); if (tTx1.Verify(txOuts)) throw new Exception("test10_36"); if (tTx1.VerifyNotExistDustTxOutput()) throw new Exception("test10_37"); if (!tTx1.VerifyNumberOfTxInputs()) throw new Exception("test10_38"); if (!tTx1.VerifyNumberOfTxOutputs()) throw new Exception("test10_39"); if (!tTx1.VerifySignature(txOuts)) throw new Exception("test10_40"); if (!tTx1.VerifyPubKey(txOuts)) throw new Exception("test10_41"); if (!tTx1.VerifyAmount(txOuts)) throw new Exception("test10_42"); if (tTx1.GetFee(txOuts).rawAmount != 0) throw new Exception("test10_43"); TransactionOutput[] txOuts4 = new TransactionOutput[] { txOut2, txOut1, txOut3 }; if (tTx1.Verify(txOuts4)) throw new Exception("test10_44"); if (tTx1.VerifySignature(txOuts4)) throw new Exception("test10_45"); if (tTx1.VerifyPubKey(txOuts4)) throw new Exception("test10_46"); byte temp2 = tTx1.TxInputs[0].SenderSignature.signature[0]; tTx1.TxInputs[0].SenderSignature.signature[0] = 0; if (tTx1.Verify(txOuts)) throw new Exception("test10_47"); if (tTx1.VerifySignature(txOuts)) throw new Exception("test10_48"); if (!tTx1.VerifyPubKey(txOuts)) throw new Exception("test10_49"); tTx1.TxInputs[0].SenderSignature.signature[0] = temp2; TransferTransaction tTx2 = new TransferTransaction(); tTx2.LoadVersion0(txIns, txOuts); tTx2.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair2.privKey, keypair1.privKey, keypair3.privKey }); if (tTx2.Verify(txOuts)) throw new Exception("test10_50"); if (tTx2.VerifySignature(txOuts)) throw new Exception("test10_51"); if (!tTx2.VerifyPubKey(txOuts)) throw new Exception("test10_52"); TransferTransaction tTx3 = new TransferTransaction(); tTx3.LoadVersion0(txIns, txOuts); tTx3.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); byte temp = tTx3.TxInputs[0].SenderPubKey.pubKey[0]; tTx3.TxInputs[0].SenderPubKey.pubKey[0] = 0; if (tTx3.Verify(txOuts)) throw new Exception("test10_50"); if (tTx3.VerifySignature(txOuts)) throw new Exception("test10_51"); if (tTx3.VerifyPubKey(txOuts)) throw new Exception("test10_52"); tTx3.TxInputs[0].SenderPubKey.pubKey[0] = temp; TransferTransaction tTx4 = new TransferTransaction(); tTx4.LoadVersion0(txIns, txOuts2); tTx4.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (tTx4.Verify(txOuts)) throw new Exception("test10_53"); if (!tTx4.VerifyNotExistDustTxOutput()) throw new Exception("test10_54"); if (!tTx4.VerifyNumberOfTxInputs()) throw new Exception("test10_55"); if (tTx4.VerifyNumberOfTxOutputs()) throw new Exception("test10_56"); if (!tTx4.VerifySignature(txOuts)) throw new Exception("test10_57"); if (!tTx4.VerifyPubKey(txOuts)) throw new Exception("test10_58"); if (tTx4.VerifyAmount(txOuts)) throw new Exception("test10_59"); if (tTx4.GetFee(txOuts).rawAmount != -47499990000) throw new Exception("test10_60"); TransferTransaction tTx5 = new TransferTransaction(); tTx5.LoadVersion0(txIns, txOuts3); tTx5.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey }); if (!tTx5.Verify(txOuts)) throw new Exception("test10_61"); if (!tTx5.VerifyNotExistDustTxOutput()) throw new Exception("test10_62"); if (!tTx5.VerifyNumberOfTxInputs()) throw new Exception("test10_63"); if (!tTx5.VerifyNumberOfTxOutputs()) throw new Exception("test10_64"); if (!tTx5.VerifySignature(txOuts)) throw new Exception("test10_65"); if (!tTx5.VerifyPubKey(txOuts)) throw new Exception("test10_66"); if (!tTx5.VerifyAmount(txOuts)) throw new Exception("test10_67"); if (tTx5.GetFee(txOuts).rawAmount != 10000) throw new Exception("test10_68"); TransactionInput[] txIns2 = new TransactionInput[101]; for (int i = 0; i < txIns2.Length; i++) txIns2[i] = txIn1; TransactionOutput[] txOuts5 = new TransactionOutput[txIns2.Length]; for (int i = 0; i < txOuts5.Length; i++) txOuts5[i] = txOut1; Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[txIns2.Length]; for (int i = 0; i < privKeys.Length; i++) privKeys[i] = keypair1.privKey; TransferTransaction tTx6 = new TransferTransaction(); tTx6.LoadVersion0(txIns2, txOuts3); tTx6.Sign(txOuts5, privKeys); if (tTx6.Verify(txOuts5)) throw new Exception("test10_61"); if (!tTx6.VerifyNotExistDustTxOutput()) throw new Exception("test10_62"); if (tTx6.VerifyNumberOfTxInputs()) throw new Exception("test10_63"); if (!tTx6.VerifyNumberOfTxOutputs()) throw new Exception("test10_64"); if (!tTx6.VerifySignature(txOuts5)) throw new Exception("test10_65"); if (!tTx6.VerifyPubKey(txOuts5)) throw new Exception("test10_66"); if (!tTx6.VerifyAmount(txOuts5)) throw new Exception("test10_67"); if (tTx6.GetFee(txOuts5).rawAmount != 497500000000) throw new Exception("test10_68"); byte[] cTxBytes2 = SHAREDDATA.ToBinary<Transaction>(cTx); if (cTxBytes2.Length != 117) throw new Exception("test10_69"); CoinbaseTransaction cTxRestore2 = SHAREDDATA.FromBinary<Transaction>(cTxBytes2) as CoinbaseTransaction; if (!cTx.Id.Equals(cTxRestore2.Id)) throw new Exception("test10_70"); byte[] tTxBytes2 = SHAREDDATA.ToBinary<Transaction>(tTx6); if (tTxBytes2.Length != 15445) throw new Exception("test10_71"); TransferTransaction tTxRestore2 = SHAREDDATA.FromBinary<Transaction>(tTxBytes2) as TransferTransaction; if (!tTx6.Id.Equals(tTxRestore2.Id)) throw new Exception("test10_72"); Sha256Sha256Hash ctxid = new Sha256Sha256Hash(cTxBytes); if (!ctxid.Equals(cTx.Id)) throw new Exception("test10_73"); Sha256Sha256Hash ttxid = new Sha256Sha256Hash(tTx6.ToBinary()); if (!ttxid.Equals(tTx6.Id)) throw new Exception("test10_74"); Console.WriteLine("test10_succeeded"); }
//Blockのテスト2 public static void Test12() { BlockGenerator bg = new BlockGenerator(); Block[] blks = new Block[10]; BlockContext[] blkCons = new BlockContext[blks.Length]; for (int i = 0; i < blks.Length; i++) { blkCons[i] = bg.CreateNextValidBlock(); blks[i] = blkCons[i].block; if (i > 0) { NormalBlock nblk = blks[i] as NormalBlock; byte[] nblkBytes = nblk.ToBinary(); NormalBlock nblkRestore = SHAREDDATA.FromBinary<NormalBlock>(nblkBytes); if (!nblk.Id.Equals(nblkRestore.Id)) throw new Exception("test12_1"); byte[] nblkBytes2 = SHAREDDATA.ToBinary<Block>(blks[i]); NormalBlock nblkRestore2 = SHAREDDATA.FromBinary<Block>(nblkBytes2) as NormalBlock; if (!nblk.Id.Equals(nblkRestore2.Id)) throw new Exception("test12_2"); } } GenesisBlock gblk = blks[0] as GenesisBlock; Creahash gblkid = new Creahash(gblk.ToBinary()); if (!gblk.Id.Equals(gblkid)) throw new Exception("test12_3"); NormalBlock nblk2 = blks[1] as NormalBlock; Creahash nblkid = new Creahash(nblk2.header.ToBinary()); if (!nblk2.Id.Equals(nblkid)) throw new Exception("test12_4"); nblk2.UpdateTimestamp(DateTime.Now); Creahash nblkid2 = new Creahash(nblk2.header.ToBinary()); if (!nblk2.Id.Equals(nblkid2)) throw new Exception("test12_5"); nblk2.UpdateNonce(new byte[10]); Creahash nblkid3 = new Creahash(nblk2.header.ToBinary()); if (!nblk2.Id.Equals(nblkid3)) throw new Exception("test12_6"); nblk2.UpdateMerkleRootHash(); Creahash nblkid4 = new Creahash(nblk2.header.ToBinary()); if (!nblk2.Id.Equals(nblkid4)) throw new Exception("test12_7"); if (!nblk2.VerifyBlockType()) throw new Exception("test12_8"); FoundationalBlock fblk = new FoundationalBlock(); fblk.LoadVersion0(nblk2.header, nblk2.coinbaseTxToMiner, nblk2.coinbaseTxToMiner, nblk2.transferTxs); byte[] fblkBytes = fblk.ToBinary(); FoundationalBlock fblkRestore = SHAREDDATA.FromBinary<FoundationalBlock>(fblkBytes); if (!fblk.Id.Equals(fblkRestore.Id)) throw new Exception("test12_9"); byte[] fblkBytes2 = SHAREDDATA.ToBinary<Block>(fblk); FoundationalBlock fblkRestore2 = SHAREDDATA.FromBinary<Block>(fblkBytes2) as FoundationalBlock; if (!fblk.Id.Equals(fblkRestore2.Id)) throw new Exception("test12_10"); if (fblk.VerifyBlockType()) throw new Exception("test12_11"); if (!nblk2.VerifyMerkleRootHash()) throw new Exception("test12_12"); byte[] nblkBytes3 = nblk2.ToBinary(); NormalBlock nblk3 = SHAREDDATA.FromBinary<NormalBlock>(nblkBytes3); nblk3.header.merkleRootHash.hash[0] ^= 255; if (nblk3.VerifyMerkleRootHash()) throw new Exception("test12_13"); byte[] nonce = new byte[10]; while (true) { nblk2.UpdateNonce(nonce); if (nblk2.Id.hash[0] == 0 && nblk2.Id.hash[1] <= 127) { if (!nblk2.VerifyId()) throw new Exception("test12_14"); break; } if (nblk2.VerifyId()) throw new Exception("test12_15"); int index = nonce.Length.RandomNum(); int value = 256.RandomNum(); nonce[index] = (byte)value; } TransferTransaction[] transferTxs1 = new TransferTransaction[99]; for (int i = 0; i < transferTxs1.Length; i++) transferTxs1[i] = (blks[2] as TransactionalBlock).transferTxs[0]; TransferTransaction[] transferTxs2 = new TransferTransaction[100]; for (int i = 0; i < transferTxs2.Length; i++) transferTxs2[i] = (blks[2] as TransactionalBlock).transferTxs[0]; NormalBlock nblk4 = new NormalBlock(); nblk4.LoadVersion0(nblk2.header, nblk2.coinbaseTxToMiner, transferTxs1); NormalBlock nblk5 = new NormalBlock(); nblk5.LoadVersion0(nblk2.header, nblk2.coinbaseTxToMiner, transferTxs2); if (!nblk4.VerifyNumberOfTxs()) throw new Exception("test12_16"); if (nblk5.VerifyNumberOfTxs()) throw new Exception("test12_17"); for (int i = 1; i < blks.Length; i++) { TransactionalBlock tblk = blks[i] as TransactionalBlock; CurrencyUnit amount = tblk.GetActualRewardToMinerAndTxFee(); CurrencyUnit amount2 = tblk.GetValidRewardToMinerAndTxFee(blkCons[i].prevTxOutss); CurrencyUnit amount3 = tblk.GetValidTxFee(blkCons[i].prevTxOutss); if (amount.rawAmount != (long)5400000000 + blkCons[i].feeRawAmount) throw new Exception("test12_18"); if (amount2.rawAmount != amount.rawAmount) throw new Exception("test12_19"); if (amount3.rawAmount != blkCons[i].feeRawAmount) throw new Exception("test12_20"); if (!tblk.VerifyRewardAndTxFee(blkCons[i].prevTxOutss)) throw new Exception("test12_21"); if (!tblk.VerifyTransferTransaction(blkCons[i].prevTxOutss)) throw new Exception("test12_22"); bool flag = false; TransactionOutput[][] invalidPrevTxOutss = new TransactionOutput[blkCons[i].prevTxOutss.Length][]; for (int j = 0; j < invalidPrevTxOutss.Length; j++) { invalidPrevTxOutss[j] = new TransactionOutput[blkCons[i].prevTxOutss[j].Length]; for (int k = 0; k < invalidPrevTxOutss[j].Length; k++) { if (j == 1 && k == 0) { invalidPrevTxOutss[j][k] = new TransactionOutput(); invalidPrevTxOutss[j][k].LoadVersion0(new Sha256Ripemd160Hash(), new CurrencyUnit(0)); flag = true; } else invalidPrevTxOutss[j][k] = blkCons[i].prevTxOutss[j][k]; } } if (flag) { if (tblk.VerifyRewardAndTxFee(invalidPrevTxOutss)) throw new Exception("test12_23"); if (tblk.VerifyTransferTransaction(invalidPrevTxOutss)) throw new Exception("test12_24"); } } Console.WriteLine("test12_succeeded"); }
public BlockContext CreateNextValidBlock() { currentBIndex++; if (currentBIndex == 0) { Block blk = new GenesisBlock(); blks.Add(blk); Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>> unspentTxOutsDictClone2 = new Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>>(); Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>> spentTxOutsDictClone2 = new Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>>(); for (int i = 0; i < keyPairs.Length; i++) { unspentTxOutsDictClone2.Add(addresses[i], new List<TransactionOutputContext>()); foreach (var toc in unspentTxOutsDict[addresses[i]]) unspentTxOutsDictClone2[addresses[i]].Add(toc); spentTxOutsDictClone2.Add(addresses[i], new List<TransactionOutputContext>()); foreach (var toc in spentTxOutsDict[addresses[i]]) spentTxOutsDictClone2[addresses[i]].Add(toc); } return new BlockContext(blk, new TransactionOutput[][] { }, 0, unspentTxOutsDictClone2, spentTxOutsDictClone2); } int numOfSpendTxs = maxNumOfSpendTxs.RandomNum() + 1; int[] numOfSpendTxOutss = new int[numOfSpendTxs]; for (int i = 0; i < numOfSpendTxOutss.Length; i++) numOfSpendTxOutss[i] = maxNumOfSpendTxOuts.RandomNum() + 1; TransactionOutputContext[][] spendTxOutss = new TransactionOutputContext[numOfSpendTxs][]; for (int i = 0; i < spendTxOutss.Length; i++) { if (unspentTxOuts.Count == 0) break; spendTxOutss[i] = new TransactionOutputContext[numOfSpendTxOutss[i]]; for (int j = 0; j < spendTxOutss[i].Length; j++) { int index = unspentTxOuts.Count.RandomNum(); spendTxOutss[i][j] = unspentTxOuts[index]; spentTxOutsDict[unspentTxOuts[index].address].Add(unspentTxOuts[index]); unspentTxOutsDict[unspentTxOuts[index].address].Remove(unspentTxOuts[index]); spentTxOuts.Add(unspentTxOuts[index]); unspentTxOuts.RemoveAt(index); if (unspentTxOuts.Count == 0) break; } } long fee = 0; List<TransferTransaction> transferTxs = new List<TransferTransaction>(); List<TransactionOutput[]> prevTxOutsList = new List<TransactionOutput[]>(); for (int i = 0; i < spendTxOutss.Length; i++) { if (spendTxOutss[i] == null) break; long sumRawAmount = 0; List<TransactionInput> txInputsList = new List<TransactionInput>(); for (int j = 0; j < spendTxOutss[i].Length; j++) { if (spendTxOutss[i][j] == null) break; txInputsList.Add(spendTxOutss[i][j].GenerateTransactionInput()); sumRawAmount += spendTxOutss[i][j].amount.rawAmount; } TransactionInput[] txIns = txInputsList.ToArray(); int num = sumRawAmount > 1000000 ? (int)Math.Ceiling(((avgIORatio - 1) * 2) * 1.RandomDouble() * txIns.Length) : 1; TransactionOutputContext[] txOutsCon = new TransactionOutputContext[num]; TransactionOutput[] txOuts = new TransactionOutput[num]; for (int j = 0; j < txOutsCon.Length; j++) { long outAmount = 0; if (sumRawAmount > 1000000) { long sumRawAmountDivided = sumRawAmount / 1000000; int subtract = ((int)sumRawAmountDivided / 2).RandomNum() + 1; outAmount = (long)subtract * 1000000; } else outAmount = sumRawAmount; sumRawAmount -= outAmount; int index = numOfKeyPairs.RandomNum(); txOutsCon[j] = new TransactionOutputContext(currentBIndex, i + 1, j, new CurrencyUnit(outAmount), addresses[index], keyPairs[index]); txOuts[j] = txOutsCon[j].GenerateTrasactionOutput(); } fee += sumRawAmount; for (int j = 0; j < txOutsCon.Length; j++) { unspentTxOutsDict[txOutsCon[j].address].Add(txOutsCon[j]); unspentTxOuts.Add(txOutsCon[j]); } TransactionOutput[] prevTxOuts = new TransactionOutput[txIns.Length]; Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[txIns.Length]; for (int j = 0; j < prevTxOuts.Length; j++) { prevTxOuts[j] = spendTxOutss[i][j].GenerateTrasactionOutput(); privKeys[j] = spendTxOutss[i][j].keyPair.privKey; } TransferTransaction tTx = new TransferTransaction(); tTx.LoadVersion0(txIns, txOuts); tTx.Sign(prevTxOuts, privKeys); transferTxs.Add(tTx); prevTxOutsList.Add(prevTxOuts); } long rewardAndFee = TransactionalBlock.GetRewardToMiner(currentBIndex, 0).rawAmount + fee; TransactionOutputContext[] coinbaseTxOutsCon = new TransactionOutputContext[numOfCoinbaseTxOuts]; TransactionOutput[] coinbaseTxOuts = new TransactionOutput[numOfCoinbaseTxOuts]; for (int i = 0; i < coinbaseTxOutsCon.Length; i++) { long outAmount2 = 0; if (i != coinbaseTxOutsCon.Length - 1) { long rewardAndFeeDevided = rewardAndFee / 1000000; int subtract2 = ((int)rewardAndFeeDevided / 2).RandomNum() + 1; outAmount2 = (long)subtract2 * 1000000; rewardAndFee -= outAmount2; } else outAmount2 = rewardAndFee; int index = numOfKeyPairs.RandomNum(); coinbaseTxOutsCon[i] = new TransactionOutputContext(currentBIndex, 0, i, new CurrencyUnit(outAmount2), addresses[index], keyPairs[index]); coinbaseTxOuts[i] = coinbaseTxOutsCon[i].GenerateTrasactionOutput(); } CoinbaseTransaction coinbaseTx = new CoinbaseTransaction(); coinbaseTx.LoadVersion0(coinbaseTxOuts); for (int i = 0; i < coinbaseTxOutsCon.Length; i++) { unspentTxOutsDict[coinbaseTxOutsCon[i].address].Add(coinbaseTxOutsCon[i]); unspentTxOuts.Add(coinbaseTxOutsCon[i]); } prevTxOutsList.Insert(0, new TransactionOutput[] { }); Difficulty<Creahash> diff = new Difficulty<Creahash>(HASHBASE.FromHash<Creahash>(new byte[] { 0, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 })); byte[] nonce = new byte[10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; BlockHeader bh = new BlockHeader(); bh.LoadVersion0(currentBIndex, blks[blks.Count - 1].Id, DateTime.Now, diff, nonce); NormalBlock nblk = new NormalBlock(); nblk.LoadVersion0(bh, coinbaseTx, transferTxs.ToArray()); nblk.UpdateMerkleRootHash(); blks.Add(nblk); Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>> unspentTxOutsDictClone = new Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>>(); Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>> spentTxOutsDictClone = new Dictionary<Sha256Ripemd160Hash, List<TransactionOutputContext>>(); for (int i = 0; i < keyPairs.Length; i++) { unspentTxOutsDictClone.Add(addresses[i], new List<TransactionOutputContext>()); foreach (var toc in unspentTxOutsDict[addresses[i]]) unspentTxOutsDictClone[addresses[i]].Add(toc); spentTxOutsDictClone.Add(addresses[i], new List<TransactionOutputContext>()); foreach (var toc in spentTxOutsDict[addresses[i]]) spentTxOutsDictClone[addresses[i]].Add(toc); } BlockContext blkCon = new BlockContext(nblk, prevTxOutsList.ToArray(), fee, unspentTxOutsDictClone, spentTxOutsDictClone); return blkCon; }