public async Task <Response <Block> > SubmitMinedBlock(MinedBlock block, string minerAddress)
        {
            var requestMessage = BuildRequestMessage(HttpMethod.Post, $"api/mining/submit-mined-block/{minerAddress}");

            requestMessage.Content = SerializeRequestAsJson(block);
            return(await SendRequest <Block>(requestMessage).ConfigureAwait(false));
        }
Exemple #2
0
        public async Task SubmitJob(JobDTO job)
        {
            var minedBlock = new MinedBlock
            {
                BlockDataHash = job.BlockDataHash,
                BlockHash     = job.BlockHash,
                DateCreated   = job.DateCreated,
                Nonce         = job.Nonce
            };

            var payload = new ByteArrayContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(minedBlock)));

            payload.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            foreach (var nodeUrl in this.nodeUrls)
            {
                var fullUrl  = $"{nodeUrl}/api/node/mining/submit-mined-block";
                var response = await this.http.PostAsync(fullUrl, payload);

                if (response.IsSuccessStatusCode)
                {
                    this.timer.Interval = TimerInterval;
                    this.OnTimerElapsed(null, null);
                    break;
                }
            }
        }
        private static async Task <bool> SubmitMinedBlock(
            INodeClient nodeClient,
            string minerAddress,
            int maxRetries,
            string blockDataHash,
            DateTime dateCreated,
            ulong nonce,
            string computedHash)
        {
            MinedBlock block = new MinedBlock
            {
                BlockDataHash = blockDataHash,
                DateCreated   = dateCreated.Iso8601Formatted(),
                Nonce         = nonce.ToString(),
                BlockHash     = computedHash
            };

            Response <Block> response;
            int retries = 0;

            do
            {
                retries++;
                response = await nodeClient.SubmitMinedBlock(block, minerAddress).ConfigureAwait(false);
            } while (response.Status == Status.Failed && retries < maxRetries);

            return(response.Status == Status.Success);
        }
 private static void UpdateCandidateBlockData(
     Block candidateBlock,
     MinedBlock miningResult)
 {
     candidateBlock.MinerProvidedHash = miningResult.BlockHash;
     candidateBlock.DateCreated       = miningResult.DateCreated;
     candidateBlock.Nonce             = miningResult.Nonce;
 }
        public BlockValidationResult TryAddBlock(MinedBlock minedBlock, out Block candidateBlock)
        {
            bool found = _miningJobs.TryGetValue(minedBlock.BlockDataHash, out candidateBlock);

            if (!found)
            {
                return(BlockValidationResult.BlockNotFound);
            }

            string difficultyCheck = new string('0', _nodeSettings.CurrentDifficulty);

            if (!minedBlock.BlockHash.StartsWith(difficultyCheck))
            {
                return(BlockValidationResult.BlockHashDifficultyMismatch);
            }

            string blockHashCheck = HashUtils.ComputeBlockSha256Hash(
                minedBlock.BlockDataHash,
                minedBlock.DateCreated,
                minedBlock.Nonce);

            if (blockHashCheck != minedBlock.BlockHash)
            {
                return(BlockValidationResult.InvalidBlockHash);
            }

            if (candidateBlock.Index != _chain.Count)
            {
                return(BlockValidationResult.BlockAlreadyMined);
            }

            // block found, will be added in chain
            _chain.Add(candidateBlock);
            _miningJobs.Clear();

            UpdateCandidateBlockData(candidateBlock, minedBlock);
            MoveBlockTransactionsToConfirmed(candidateBlock);

            _peerSynchronizationService.BroadcastNewBlockNotification(
                _chain.Count,
                GetCumulativeDifficulty(),
                _nodeSettings.NodeUrl);

            return(BlockValidationResult.Ok);
        }