Пример #1
0
        private JObject SendRawTransaction(IEnumerable <string> parameters, JObject response, string id)
        {
            var blockChain = _blockChainStore.GetBlockChain();

            if (parameters == null || !parameters.Any())
            {
                return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_INVALID_PARAMS, "The transaction is missing"));
            }

            var txPayload     = parameters.First().FromHexString();
            var allowHighFees = false;

            if (parameters.Count() >= 2)
            {
                if (bool.TryParse(parameters.ElementAt(1), out allowHighFees))
                {
                }
            }

            var kvp = BaseTransaction.Deserialize(txPayload);

            try
            {
                var tx = kvp.Key;
                _transactionValidator.Check(tx);
                MemoryPool.Instance().AddTransaction(tx, blockChain.GetCurrentBlockHeight());
                P2PConnectorEventStore.Instance().Broadcast(tx);
                response["result"] = tx.GetTxId().ToHexString();
                return(response);
            }
            catch (ValidationException ex)
            {
                return(CreateErrorResponse(id, (int)RpcErrorCodes.RPC_VERIFY_ERROR, ex.Message));
            }
        }
Пример #2
0
        private void AddTransaction(BaseTransaction transaction)
        {
            if (transaction == null)
            {
                return;
            }

            var instance     = MemoryPool.Instance();
            var transactions = instance.GetTransactions();

            if (transactions.Any(t => t.Transaction.GetTxId().SequenceEqual(transaction.GetTxId())))
            {
                return;
            }

            _transactionValidator.Check(transaction);
            instance.AddTransaction(transaction, _blockChainStore.GetBlockChain().GetCurrentBlockHeight());
        }
Пример #3
0
        public void Check(Block block)
        {
            if (block == null)
            {
                throw new ArgumentNullException(nameof(block));
            }

            var merkleRoot           = block.BlockHeader.MerkleRoot; // Check MERKLE-ROOT.
            var calculatedMerkleRoot = block.GetMerkleRoot();

            if (!merkleRoot.SequenceEqual(calculatedMerkleRoot))
            {
                throw new ValidationException(ErrorCodes.InvalidMerkleRoot);
            }

            var blockChain   = _blockChainStore.GetBlockChain(); // Check PREVIOUS BLOCK.
            var currentBlock = blockChain.GetCurrentBlock();

            if (!currentBlock.GetHashHeader().SequenceEqual(block.BlockHeader.PreviousBlockHeader))
            {
                throw new ValidationException(ErrorCodes.InvalidPreviousHashHeader);
            }

            var hash         = currentBlock.GetHashHeader();
            var currentNBits = Constants.DEFAULT_NBITS; // TODO : CALCULATE THE DEFAULT NBITS : https://bitcoin.org/en/developer-guide#proof-of-work
            var target       = TargetHelper.GetTarget(currentNBits);

            if (!TargetHelper.IsValid(hash, target))
            {
                throw new ValidationException(ErrorCodes.NotEnoughDifficult);
            }

            foreach (var transaction in block.Transactions) // Check ALL TRANSACTIONS.
            {
                _transactionValidator.Check(transaction);
            }
        }