private static BlockForRpc BuildBlock(DeltaWithCid deltaWithCid, long blockNumber, IHashProvider hashProvider)
        {
            var(delta, deltaHash) = deltaWithCid;

            Address author;
            var     firstCoinBaseEntry = delta.CoinbaseEntries.FirstOrDefault();

            if (firstCoinBaseEntry != null)
            {
                author = new Address(Keccak.Compute(firstCoinBaseEntry.ReceiverPublicKey.ToByteArray()));
            }
            else
            {
                author = Address.Zero;
            }

            var nonce = new byte[8];

            BinaryPrimitives.WriteUInt64BigEndian(nonce, 42);

            BlockForRpc blockForRpc = new BlockForRpc
            {
                ExtraData        = new byte[0],
                Miner            = author,
                Difficulty       = 1,
                Hash             = deltaHash,
                Number           = blockNumber,
                GasLimit         = (long)delta.GasLimit,
                GasUsed          = delta.GasUsed,
                Timestamp        = new UInt256(delta.TimeStamp.Seconds),
                ParentHash       = blockNumber == 0 ? null : Cid.Read(delta.PreviousDeltaDfsHash.ToByteArray()),
                StateRoot        = delta.StateRoot.ToKeccak(),
                ReceiptsRoot     = Keccak.EmptyTreeHash,
                TransactionsRoot = Keccak.EmptyTreeHash,
                LogsBloom        = Bloom.Empty,
                MixHash          = Keccak.Zero,
                Nonce            = nonce,
                Uncles           = new Keccak[0],
                Transactions     = delta.PublicEntries.Select(x => x.GetHash(hashProvider))
            };

            blockForRpc.TotalDifficulty = (UInt256)((long)blockForRpc.Difficulty * (blockNumber + 1));
            blockForRpc.Sha3Uncles      = Keccak.OfAnEmptySequenceRlp;
            return(blockForRpc);
        }
        protected override BlockForRpc Handle(BlockParameter block, IWeb3EthApi api)
        {
            Cid  deltaHash;
            long blockNumber;

            IDeltaCache    deltaCache    = api.DeltaCache;
            IDeltaResolver deltaResolver = api.DeltaResolver;

            switch (block.Type)
            {
            case BlockParameterType.Earliest:
                deltaHash   = deltaCache.GenesisHash;
                blockNumber = 0;
                break;

            case BlockParameterType.Latest:
                deltaHash   = deltaResolver.LatestDelta;
                blockNumber = deltaResolver.LatestDeltaNumber;
                break;

            case BlockParameterType.Pending:
                deltaHash   = deltaResolver.LatestDelta;
                blockNumber = deltaResolver.LatestDeltaNumber;
                break;

            case BlockParameterType.BlockNumber:
                blockNumber = block.BlockNumber.Value;
                if (!deltaResolver.TryResolve(blockNumber, out deltaHash))
                {
                    return(null);
                }

                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            DeltaWithCid deltaWithCid = api.GetDeltaWithCid(deltaHash);

            return(BuildBlock(deltaWithCid, blockNumber, api.HashProvider));
        }
        protected override BlockForRpc Handle(Keccak deltaHash, IWeb3EthApi api)
        {
            DeltaWithCid deltaWithCid = api.GetDeltaWithCid(deltaHash.ToCid());

            return(BuildBlock(deltaWithCid, deltaWithCid.Delta.DeltaNumber, api.HashProvider));
        }