示例#1
0
        public void AddCodeRemark(Address address, CodeRemark codeRemark)
        {
            Logger.LogTrace($"Set contract remarks Address: {address}, CodeRemark:{codeRemark}");
            if (!_forkCache.TryGetValue(address, out var codeRemarks))
            {
                codeRemarks         = new List <CodeRemark>();
                _forkCache[address] = codeRemarks;
            }

            codeRemarks.AddIfNotContains(codeRemark);
        }
示例#2
0
        public async Task <CodeRemark> GetCodeRemarkAsync(IChainContext chainContext, Address address, Hash codeHash)
        {
            var codeRemark = _contractRemarksProvider.GetCodeRemark(chainContext, address);

            if (codeRemark != null)
            {
                return(codeHash == codeRemark.CodeHash ? codeRemark : null);
            }
            var contractRemarks = await _contractRemarksManager.GetContractRemarksAsync(address);

            if (contractRemarks != null)
            {
                var chain = await _blockchainService.GetChainAsync();

                var codeRemarks = contractRemarks.CodeRemarks
                                  .Where(c => c.BlockHeight <= chain.LastIrreversibleBlockHeight)
                                  .OrderByDescending(c => c.BlockHeight).ToList();
                foreach (var remark in codeRemarks)
                {
                    var blockHash = await _blockchainService.GetBlockHashByHeightAsync(chain, remark.BlockHeight,
                                                                                       chain.LastIrreversibleBlockHash);

                    if (blockHash != remark.BlockHash)
                    {
                        continue;
                    }
                    codeRemark = remark;
                    break;
                }
            }

            if (codeRemark == null)
            {
                codeRemark = new CodeRemark
                {
                    CodeHash          = codeHash,
                    NonParallelizable = false
                }
            }
            ;

            _contractRemarksProvider.SetCodeRemark(address, codeRemark);
            return(codeHash == codeRemark.CodeHash ? codeRemark : null);
        }
示例#3
0
        public async Task SetCodeRemarkAsync(Address address, Hash codeHash, BlockHeader blockHeader)
        {
            var contractRemarks = await _contractRemarksManager.GetContractRemarksAsync(address) ?? new ContractRemarks
            {
                ContractAddress = address
            };
            var codeRemark = new CodeRemark
            {
                BlockHash         = blockHeader.GetHashWithoutCache(),
                BlockHeight       = blockHeader.Height,
                CodeHash          = codeHash,
                NonParallelizable = true
            };

            contractRemarks.CodeRemarks.AddIfNotContains(codeRemark);
            await _contractRemarksManager.SetContractRemarksAsync(address, contractRemarks);

            _contractRemarksProvider.AddCodeRemark(address, codeRemark);
        }
示例#4
0
 public void SetCodeRemark(Address address, CodeRemark codeRemark)
 {
     _cache[address] = codeRemark;
 }