/// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetBlockResponse response = new GetBlockResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Block", targetDepth))
                {
                    var unmarshaller = ValueHolderUnmarshaller.Instance;
                    response.Block = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Proof", targetDepth))
                {
                    var unmarshaller = ValueHolderUnmarshaller.Instance;
                    response.Proof = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
        /// <summary>
        ///     Gets The Block Details For The Given 'Block' Hash
        /// </summary>
        /// <param name="blockHash">Hash of The Block</param>
        /// <param name="showTX">Show TX Information</param>
        /// <returns></returns>
        public async Task <GetBlockResponse> GetBlock(string blockHash, bool showTX = true)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(blockHash))
                {
                    throw new ArgumentNullException(nameof(blockHash), "Block Hash Cannot Be NULL/Empty!");
                }

                GetBlockResponse response = await base.SendGet <GetBlockResponse>(
                    $"api/BlockStore/block?Hash={blockHash}&ShowTransactionDetails={showTX}&OutputJson=true");

                Guard.Null(response, nameof(response),
                           $"NULL Data Returned For The api/BlockStore/block Call With Block Hash '{blockHash}'");


                return(response);
            }
            catch (Exception ex)
            {
                logger.LogCritical(
                    $"An Error '{ex.Message}' Occured When Getting Block Information For Hash '{blockHash}'!", ex);
                throw;
            } //end of try-catch
        }     //end of public async Task<GetStakingInfoResponse> GetStakingInfo()
Пример #3
0
        // retrieve blockchain, can throw if the RPC server is unreachable or RPC credentials are incorrect
        static List <GetBlockResponse> GetBlocks(ICryptocoinService cryptoService)
        {
            List <GetBlockResponse> blocks = new List <GetBlockResponse>();

            try
            {
                string hash = cryptoService.GetBlockHash(0);
                while (!String.IsNullOrEmpty(hash))
                {
                    GetBlockResponse block = cryptoService.GetBlock(hash);
                    blocks.Add(block);
                    hash = block.NextBlockHash;
                }
            }
            catch (Exception e)
            {
                do
                {
                    Console.Error.WriteLine("ERROR -> " + e.Message);
                } while ((e = e.InnerException) != null);

                Environment.Exit(1);
            }

            return(blocks);
        }
Пример #4
0
        }//end of public virtual async void OnNewTX(List<Transaction> txs)

        /// <summary>
        /// Fires Off a "New Block" Event
        /// </summary>
        /// <param name="blockNumber">Block #</param>
        public virtual async void OnNewBlock(ulong blockNumber)
        {
            GetBlockResponse blockData = await _RestClient.GetBlock(blockNumber);

            Guard.Null(blockData, nameof(blockData), $"Node '{Name}' ({Address}:{Port}) Detected A New Block @ Height '{blockNumber}' But GetBlock Returned NULL!");

            this.NewBlockEvent?.Invoke(this, new NewBlockEvent(blockData.ToBlockHeader()));
        } //end of public virtual void OnNewBlock(ulong blockNumber)
        /// <summary>
        /// Fill the following fields for a transaction block:
        ///     1. Status
        ///     2. PartnerAddress
        /// </summary>
        /// <param name="transaction"></param>
        public static void FillTransactionData(string walletAddress, XDagTransaction transaction)
        {
            XDagExplorerClient client    = new XDagExplorerClient();
            GetBlockResponse   tResponse = client.GetBlock(transaction.BlockAddress);

            transaction.SetStatus(tResponse.State);
            transaction.PartnerAddress = GetPartnerAddress(walletAddress, tResponse, transaction.Direction.ToString());
        }
Пример #6
0
        public GetBlockResponse GetBlock(string address)
        {
            string responseString = SendRequest(string.Format("api/block/{0}", address));

            GetBlockResponse response = JsonConvert.DeserializeObject <GetBlockResponse>(responseString);

            return(response);
        }
        private static string GetPartnerAddress(string walletAddress, GetBlockResponse response, string direction)
        {
            foreach (TransactionData data in response.PartnersList)
            {
                if (data.Direction.Equals(direction, StringComparison.InvariantCultureIgnoreCase) && !data.Address.Equals(walletAddress))
                {
                    return(data.Address);
                }
            }

            return(string.Empty);
        }
Пример #8
0
        public static List <XDagTransaction> GetTransactionHistory(string walletAddress)
        {
            if (string.IsNullOrEmpty(walletAddress))
            {
                return(null);
            }

            XDagExplorerClient client   = new XDagExplorerClient();
            GetBlockResponse   response = client.GetBlock(walletAddress);

            if (response == null || response.TransactionsList == null)
            {
                return(null);
            }

            List <XDagTransaction> transactionList = new List <XDagTransaction>();

            foreach (TransactionData data in response.TransactionsList)
            {
                XDagTransaction transaction = new XDagTransaction();

                double amountValue = 0;
                if (double.TryParse(data.Amount, out amountValue))
                {
                    transaction.Amount = amountValue;
                }

                transaction.BlockAddress = data.Address;

                DateTime dateTime = DateTime.MinValue;
                if (DateTime.TryParse(data.TimeStamp, out dateTime))
                {
                    transaction.TimeStamp = dateTime;
                }

                transaction.SetDirection(data.Direction);

                /*
                 * GetBlockResponse tResponse = client.GetBlock(transaction.BlockAddress);
                 * transaction.SetStatus(tResponse.State);
                 * transaction.PartnerAddress = GetPartnerAddress(walletAddress, tResponse, data.Direction);
                 */
                transaction.Remark = data.Remark;

                transactionList.Add(transaction);
            }

            return(transactionList);
        }
Пример #9
0
        }//end of public static decimal ParseAPIAmount(this long amount)

        /// <summary>
        /// Converts the API Peer List Data Structure To A More Friendly One
        /// </summary>
        public static BlockHeader ToBlockHeader(this GetBlockResponse block)
        {
            Guard.Null(block, nameof(block));


            return(new BlockHeader
            {
                Height = block.height,
                Version = block.version,
                MerkleRoot = block.merkleroot,
                Nonce = block.nonce,
                PreviousBlockHash = block.previousblockhash,
                Time = block.time
            });
        }//end of public static Block ToBlock(this GetBlockResponse block)
Пример #10
0
        public GetBlockResponse GetLastBlock()
        {
            GetBlockResponse block = null;
            var id = GetBlockCount();

            if (id.HasValue)
            {
                var hash = GetBlockHash(id.Value);
                if (hash != null)
                {
                    block = GetBlockInfo(hash);
                }
            }
            return(block);
        }
Пример #11
0
        /// <summary>
        ///     Fires Off a "New Block" Event
        /// </summary>
        /// <param name="blockNumber">Block #</param>
        public async void OnNewBlock(ulong blockNumber)
        {
            try
            {
                GetBlockResponse blockData = await restClient.GetBlock(blockNumber);

                Guard.Null(blockData, nameof(blockData), $"Node '{Name}' ({Address}:{Port}) Detected A New Block @ Height '{blockNumber}' But GetBlock Returned NULL!");

                NewBlockEvent?.Invoke(this, new NewBlockEvent(blockData.ToBlockHeader()));
            }
            catch (Exception ex)
            {
                logger.LogDebug("Failed to call OnNewBlock()", ex);
            }
        }
Пример #12
0
        public void ParseTransaction(object block)
        {
            GetBlockResponse blockResponse = (GetBlockResponse)block;

            foreach ((Action action, PackedTransaction packedTransaction) in GetListAction(blockResponse))
            {
                if (action.Data.Equals(null))
                {
                    return;
                }
                if (action.Name == TRANSACTION_ACTION_TRANSFER)
                {
                    ParseValidTransferAction(action, packedTransaction, blockResponse);
                }
            }
        }
Пример #13
0
        public IEnumerable <(Action, PackedTransaction)> GetListAction(GetBlockResponse block)
        {
            logger.Info(String.Format("Block number {0} produced on {1}", block.BlockNum, block.Timestamp));
            foreach (TransactionReceipt transactionReceipt in block.Transactions)
            {
                if (transactionReceipt.Status != TRANSACTION_STATUS_EXECUTED || transactionReceipt.Trx is String)
                {
                    continue;
                }

                PackedTransaction packedTransaction =
                    JsonHelper.DeserializeObject <PackedTransaction>(transactionReceipt.Trx.ToString());
                foreach (Action action in packedTransaction.Transaction.Actions)
                {
                    yield return(action, packedTransaction);
                }
            }
        }
Пример #14
0
        public void ParseValidTransferAction(Action action, PackedTransaction packedTransaction,
                                             GetBlockResponse blockResponse)
        {
            TransferData transferData = JsonHelper.DeserializeObject <TransferData>(action.Data.ToString());

            if (String.IsNullOrEmpty(transferData.Quantity))
            {
                return;
            }
            if (transferData.Symbol() == CryptoCurrency.VAKA)
            {
                // If receiver doesn't exist in wallet table then stop
                if (!_walletBusiness.CheckExistedAndUpdateByAddress(transferData.To, transferData.Amount(),
                                                                    transferData.Symbol()))
                {
                    return;
                }

                // Save to table in db
                _vakacoinBusiness.CreateDepositTransaction(packedTransaction.Id, (int)blockResponse.BlockNum,
                                                           transferData.Symbol(), transferData.Amount(), transferData.From, transferData.To, 0,
                                                           Status.STATUS_SUCCESS);

                //create pending email
                var createEmailResult = CreatePendingEmail(transferData);
                if (createEmailResult.Status == Status.STATUS_SUCCESS)
                {
                    logger.Info("Create pending email success");
                }
                else
                {
                    logger.Error("Create Pending email error!!!" + createEmailResult.Message);
                }

                logger.Info(String.Format("{0} was received {1}", transferData.To, transferData.Quantity));
            }
        }
Пример #15
0
        public JsonResult GetBlockInfo(String blockhashId)
        {
            GetBlockResponse transaction = _bitcoinService.GetBlock(blockhashId);

            return(Json(transaction, JsonRequestBehavior.AllowGet));
        }
Пример #16
0
        static void Main(string[] args)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath((Directory.GetCurrentDirectory()))
                          .AddJsonFile("appsettings.json");

            Configuration = builder.Build();


            connString = $"Server=tcp:localhost,1433;Initial Catalog=SAPI;User ID=sa;Password={Configuration["SyncDb"]};Connection Timeout=30;";
            serverUser = Configuration["rpcuser"];
            serverPass = Configuration["rpcpass"];


            var CoinService = new BitcoinService(serverURL,
                                                 serverUser,
                                                 serverPass,
                                                 "",
                                                 60);

            CoinService.Parameters.CoinLongName    = "SmartCash";
            CoinService.Parameters.CoinShortName   = "SMART";
            CoinService.Parameters.IsoCurrencyCode = "XSC";
            CoinService.Parameters.UseTestnet      = false;



            //Body
            HashSet <string> tx = new HashSet <string>();


            Sync();

            Console.Write("Done!");


            void Sync()
            {
                #region SyncBlocks


                //Body

                string startBlockHash = string.Empty;

                startBlockHash = GetStartBlockHash();

                if (args.Count() == 1)
                {
                    long blkNumber = Convert.ToInt64(args[0]);

                    if (blkNumber != 999)
                    {
                        startBlockHash = CoinService.GetBlockHash(blkNumber);
                    }
                    else
                    {
                        blkNumber      = CoinService.GetBlockCount() - 30;
                        startBlockHash = CoinService.GetBlockHash(blkNumber);
                    }
                }
                else if (args.Count() == 2)
                {
                    long blkNumber = Convert.ToInt64(args[0]);
                    rescan = Convert.ToBoolean(args[1]);

                    if (blkNumber != 999)
                    {
                        startBlockHash = CoinService.GetBlockHash(blkNumber);
                    }
                    else
                    {
                        blkNumber      = CoinService.GetBlockCount() - 30;
                        startBlockHash = CoinService.GetBlockHash(blkNumber);
                    }
                }

                int topBlock = Convert.ToInt32(CoinService.GetBlockCount());
                GetBlockResponse curBlock = new GetBlockResponse();

                if (startBlockHash == null || startBlockHash == "")                                      // Start from scratch
                {
                    startBlockHash = "00000009c4e61bee0e8d6236f847bb1dd23f4c61ca5240b74852184c9bf98c30"; // Block 1
                    curBlock       = GetBlock(startBlockHash);
                    InsertBlock(curBlock);
                    foreach (string txid in curBlock.Tx)
                    {
                        GetRawTransactionResponse nextTransaction = GetTransaction(txid);
                        InsertTransaction(nextTransaction);

                        var countInput = 0;
                        // Input
                        foreach (Vin transactionInput in nextTransaction.Vin)
                        {
                            InsertTransactionInput(transactionInput, txid, countInput);
                            countInput++;
                        }

                        // Output
                        foreach (var transactionOutput in nextTransaction.Vout)
                        {
                            if (transactionOutput.ScriptPubKey.Addresses != null)
                            {
                                if (transactionOutput.ScriptPubKey.Addresses.Count > 1)
                                {
                                    Debug.WriteLine("2> Address: " + txid);
                                }
                                InsertTransactionOutput(transactionOutput, txid);
                            }
                            else
                            {
                                Debug.WriteLine("No Address: " + txid);
                            }
                        }

                        tx.Add(txid);
                    }
                }
                else
                {
                    curBlock = GetBlock(startBlockHash);
                }

                //Fix Orphan Blocks
                if (curBlock.Confirmations == -1)
                {
                    DeleteOrphanBlock(curBlock.Hash);
                    startBlockHash = GetStartBlockHash();
                    curBlock       = GetBlock(startBlockHash);
                }

                while (curBlock.NextBlockHash != null)
                {
                    // Block
                    curBlock = GetBlock(curBlock.NextBlockHash);

                    ProcessBlock(curBlock, topBlock);
                }
                FindMissingBlocks();

                #endregion


                Console.WriteLine("Done");
            }

            void ProcessBlock(GetBlockResponse curBlock, int topBlock)
            {
                Console.Write("\r Processing Block {0} of {1}", curBlock.Height.ToString(), topBlock.ToString());

                InsertBlock(curBlock);

                // Transaction
                foreach (string txid in curBlock.Tx)
                {
                    try
                    {
                        GetRawTransactionResponse nextTransaction = GetTransaction(txid);

                        if (!tx.Contains(txid)) //Exclude transactions linked to multiple blocks (Zerocoin Mint/Smartcash Renew)
                        {
                            InsertTransaction(nextTransaction);

                            var countInput = 0;
                            // Input
                            foreach (Vin transactionInput in nextTransaction.Vin)
                            {
                                InsertTransactionInput(transactionInput, txid, countInput);
                                countInput++;
                            }

                            // Output
                            foreach (Vout transactionOutput in nextTransaction.Vout)
                            {
                                if (transactionOutput.ScriptPubKey.Addresses != null)
                                {
                                    if (transactionOutput.ScriptPubKey.Addresses.Count > 1)
                                    {
                                        Debug.WriteLine("2> Address: " + txid);
                                    }
                                    InsertTransactionOutput(transactionOutput, txid);
                                }
                                else
                                {
                                    Debug.WriteLine("No Address: " + txid);
                                }
                            }

                            tx.Add(txid);
                        }
                        else
                        {
                            UpdateTransaction(nextTransaction);
                        }
                    }
                    catch
                    {
                    }
                }

                //Console.WriteLine(curBlock.height);
            }

            void FindMissingBlocks()
            {
                string selectString = @"
                WITH Missing (missnum, maxid)
                AS
                (
                    SELECT (select min(Height) missnum from [Block]) , (select max(Height) from [Block])
                    UNION ALL
                    SELECT missnum + 1, maxid FROM Missing
                    WHERE missnum < maxid
                )
                SELECT missnum
                FROM Missing
                LEFT OUTER JOIN [Block] tt on tt.Height = Missing.missnum
                WHERE tt.Height is NULL
                OPTION (MAXRECURSION 0);";

                List <int> missing = new List <int>();

                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand(selectString, conn))
                    {
                        try
                        {
                            conn.Open();
                            using (SqlDataReader dr = comm.ExecuteReader())
                            {
                                while (dr.Read())
                                {
                                    missing.Add(Convert.ToInt32(dr["missnum"]));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("SQL Error" + ex.Message);
                            throw;
                        }
                    }
                }
                foreach (var item in missing)
                {
                    var hash  = CoinService.GetBlockHash(item);
                    var block = GetBlock(hash);
                    ProcessBlock(block, item);
                }
            }

            string GetStartBlockHash()
            {
                string startBlockHash = "";

                if (rescan)
                {
                    return(startBlockHash);
                }
                string selectString = "SELECT TOP 1 [Hash] FROM [Block] ORDER BY [Height] DESC";


                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand(selectString, conn))
                    {
                        try
                        {
                            conn.Open();
                            startBlockHash = (string)comm.ExecuteScalar();
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("SQL Error" + ex.Message + " : " + "GetStartBlockHash");
                            throw;
                        }
                    }
                }

                return(startBlockHash);
            }

            BitcoinLib.Responses.GetBlockResponse GetBlock(string blockHash)
            {
                return(CoinService.GetBlock(blockHash, true));
            }

            bool InsertBlock(GetBlockResponse block)
            {
                string cmdString = "INSERT INTO [Block] ([Hash],[Height],[Confirmation],[Size],[Difficulty],[Version],[Time]) VALUES (@Hash, @Height, @Confirmation, @Size, @Difficulty, @Version, @Time)";

                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand())
                    {
                        comm.Connection  = conn;
                        comm.CommandText = cmdString;
                        comm.Parameters.AddWithValue("@Hash", block.Hash);
                        comm.Parameters.AddWithValue("@Height", block.Height);
                        comm.Parameters.AddWithValue("@Confirmation", block.Confirmations);
                        comm.Parameters.AddWithValue("@Size", block.Size);
                        comm.Parameters.AddWithValue("@Difficulty", block.Difficulty);
                        comm.Parameters.AddWithValue("@Version", block.Version);
                        comm.Parameters.AddWithValue("@Time", UnixTimeStampToDateTime(block.Time));
                        try
                        {
                            conn.Open();
                            comm.ExecuteNonQuery();
                            lastBlock = block.Height;
                        }
                        catch (Exception ex)
                        {
                            if (!rescan)
                            {
                                Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(block));
                            }
                            //throw;
                        }
                    }
                }

                return(true);
            }

            GetRawTransactionResponse GetTransaction(string txid)
            {
                var raw = CoinService.GetRawTransaction(txid, 1);

                return(raw);
            }

            bool InsertTransaction(GetRawTransactionResponse transaction)
            {
                if (!tx.Contains(transaction.TxId)) //Exclude transactions linked to multiple blocks (Zerocoin Mint/Smartcash Renew)
                {
                    string cmdString = "EXEC Transaction_Create @Txid, @BlockHash, @Version, @Time, @IsInstantPay, @IsWebWallet";
                    using (SqlConnection conn = new SqlConnection(connString))
                    {
                        using (SqlCommand comm = new SqlCommand())
                        {
                            comm.Connection  = conn;
                            comm.CommandText = cmdString;
                            comm.Parameters.AddWithValue("@Txid", transaction.TxId);
                            comm.Parameters.AddWithValue("@BlockHash", transaction.BlockHash);
                            comm.Parameters.AddWithValue("@Version", transaction.Version);
                            comm.Parameters.AddWithValue("@Time", UnixTimeStampToDateTime(transaction.Time));
                            comm.Parameters.AddWithValue("@IsInstantPay", (transaction.LockTime > 0));
                            comm.Parameters.AddWithValue("@IsWebWallet", false);
                            try
                            {
                                conn.Open();
                                comm.ExecuteNonQuery();
                                tx.Add(transaction.TxId);
                            }
                            catch (Exception ex)
                            {
                                if (!rescan)
                                {
                                    Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(transaction));
                                }
                                throw;
                            }
                        }
                    }
                }
                return(true);
            }

            bool UpdateTransaction(GetRawTransactionResponse transaction)
            {
                string cmdString = "EXEC Transaction_Create @Txid, @BlockHash, @Version, @Time, @IsInstantPay, @IsWebWallet";

                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand())
                    {
                        comm.Connection  = conn;
                        comm.CommandText = cmdString;
                        comm.Parameters.AddWithValue("@Txid", transaction.TxId);
                        comm.Parameters.AddWithValue("@BlockHash", transaction.BlockHash);
                        comm.Parameters.AddWithValue("@Version", transaction.Version);
                        comm.Parameters.AddWithValue("@Time", UnixTimeStampToDateTime(transaction.Time));
                        comm.Parameters.AddWithValue("@IsInstantPay", (transaction.LockTime > 0));
                        comm.Parameters.AddWithValue("@IsWebWallet", false);

                        try
                        {
                            conn.Open();
                            comm.ExecuteNonQuery();
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(transaction));
                            throw;
                        }
                    }
                }

                return(true);
            }

            bool InsertTransactionInput(Vin transactionInput, string txid, int index)
            {
                string  coinbase = transactionInput.CoinBase;
                string  txidOut  = transactionInput.TxId;
                long    indexOut = Convert.ToInt32(transactionInput.Vout);
                string  sAddress = "";
                decimal sValue   = 0;

                if (coinbase != null)
                {
                    txidOut  = "0000000000000000000000000000000000000000000000000000000000000000";
                    sAddress = "0000000000000000000000000000000000";
                }
                else if (txidOut == "0000000000000000000000000000000000000000000000000000000000000000")
                {
                    indexOut = 0;
                    sAddress = "0000000000000000000000000000000001";
                }
                else
                {
                    string selectString = "SELECT [Address], [Value] FROM [TransactionOutput] WHERE [Txid] = '" + txidOut + "' AND [Index] = " + indexOut;
                    using (SqlConnection conn = new SqlConnection(connString))
                    {
                        using (SqlCommand comm = new SqlCommand(selectString, conn))
                        {
                            try
                            {
                                conn.Open();
                                using (SqlDataReader dr = comm.ExecuteReader())
                                {
                                    while (dr.Read())
                                    {
                                        sAddress = dr["Address"].ToString();
                                        sValue   = decimal.Parse(dr["Value"].ToString());
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(transactionInput) + " ; " + txid + " ; " + index.ToString());
                                throw;
                            }
                        }
                    }
                }

                string cmdString = "INSERT INTO [TransactionInput] ([TxidIn],[IndexIn],[TxidOut],[IndexOut],[Address],[Value]) VALUES (@TxidIn, @IndexIn, @TxidOut, @IndexOut, @Address, @Value)";

                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand())
                    {
                        comm.Connection  = conn;
                        comm.CommandText = cmdString;
                        comm.Parameters.AddWithValue("@TxidIn", txid);
                        comm.Parameters.AddWithValue("@IndexIn", index);
                        comm.Parameters.AddWithValue("@TxidOut", txidOut);
                        comm.Parameters.AddWithValue("@IndexOut", indexOut);
                        comm.Parameters.AddWithValue("@Address", sAddress);
                        comm.Parameters.AddWithValue("@Value", sValue);
                        try
                        {
                            conn.Open();
                            comm.ExecuteNonQuery();
                        }
                        catch (Exception ex)
                        {
                            if (!rescan)
                            {
                                Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(transactionInput) + " ; " + txid + " ; " + index.ToString());
                            }
                        }
                    }
                }

                return(true);
            }

            bool InsertTransactionOutput(Vout transactionOutput, string txid)
            {
                string cmdString = "INSERT INTO [TransactionOutput] ([Txid],[Index],[Address],[Value]) VALUES (@Txid, @Index, @Address, @Value)";

                using (SqlConnection conn = new SqlConnection(connString))
                {
                    using (SqlCommand comm = new SqlCommand())
                    {
                        comm.Connection  = conn;
                        comm.CommandText = cmdString;
                        comm.Parameters.AddWithValue("@Txid", txid);
                        comm.Parameters.AddWithValue("@Index", transactionOutput.N);
                        comm.Parameters.AddWithValue("@Address", transactionOutput.ScriptPubKey.Addresses[0]);
                        comm.Parameters.AddWithValue("@Value", transactionOutput.Value);
                        try
                        {
                            conn.Open();
                            comm.ExecuteNonQuery();
                        }
                        catch (Exception ex)
                        {
                            if (!rescan)
                            {
                                Console.WriteLine("SQL Error" + ex.Message + " : " + JsonConvert.SerializeObject(transactionOutput) + " ; " + txid);
                            }
                        }
                    }
                }

                return(true);
            }

            bool DeleteOrphanBlock(string blockHash)
            {
                using (SqlConnection conn = new SqlConnection(connString))
                {
                    try
                    {
                        conn.Open();

                        using (SqlCommand comm = new SqlCommand("SELECT [Txid] FROM [Transaction] WHERE [BlockHash] = '" + blockHash + "'", conn))
                        {
                            HashSet <string> hTxid = new HashSet <string>();

                            using (SqlDataReader dr = comm.ExecuteReader())
                            {
                                while (dr.Read())
                                {
                                    hTxid.Add(dr["Txid"].ToString());
                                }
                            }

                            foreach (string txid in hTxid)
                            {
                                using (SqlCommand commI = new SqlCommand())
                                {
                                    commI.Connection  = conn;
                                    commI.CommandText = "DELETE FROM [TransactionInput] WHERE [TxidIn] = '" + txid + "'";
                                    commI.ExecuteNonQuery();
                                }

                                using (SqlCommand commO = new SqlCommand())
                                {
                                    commO.Connection  = conn;
                                    commO.CommandText = "DELETE FROM [TransactionOutput] WHERE [Txid] = '" + txid + "'";
                                    commO.ExecuteNonQuery();
                                }
                            }
                        }

                        using (SqlCommand commT = new SqlCommand())
                        {
                            commT.Connection  = conn;
                            commT.CommandText = "DELETE FROM [Transaction] WHERE [BlockHash] = '" + blockHash + "'";
                            commT.ExecuteNonQuery();
                        }

                        using (SqlCommand commB = new SqlCommand())
                        {
                            commB.Connection  = conn;
                            commB.CommandText = "DELETE FROM [Block] WHERE [Hash] = '" + blockHash + "'";
                            commB.ExecuteNonQuery();
                        }
                    }
                    catch (Exception ex)
                    {
                        if (!rescan)
                        {
                            Console.WriteLine("SQL Error" + ex.Message + " : " + "DeleteOrphanBlock" + " : " + blockHash);
                        }
                        throw;
                    }
                }

                return(true);
            }

            //
            // Helper Functions
            //
            DateTime UnixTimeStampToDateTime(double unixTimeStamp)
            {
                // Unix timestamp is seconds past epoch
                System.DateTime dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc);
                dtDateTime = dtDateTime.AddSeconds(unixTimeStamp);
                return(dtDateTime);
            }
        }
Пример #17
0
 static public void GetBlock(QBitNinja.Client.Models.BlockFeature blockFeature, NBitcoin.Network network, GetBlockResponse response, bool headerOnly = false, bool extended = false)
 {
     ObservableWWW.Get(URL(network, "blocks/" + EscapeUrlPart(blockFeature.ToString()) + CreateParameters("headerOnly", headerOnly, "extended", extended))).
     Subscribe(x => response(JsonUtility.FromJson <Models.GetBlockResponse>(x).Result(), network),
               ex => Debug.Log("error : " + ex.Message));
 }