public Task LoadAsync(ConcurrentChain chain)
        {
            Guard.Assert(chain.Tip == chain.Genesis);

            Task task = Task.Run(() =>
            {
                using (DBreeze.Transactions.Transaction transaction = this.dbreeze.GetTransaction())
                {
                    transaction.ValuesLazyLoadingIsOn = false;
                    ChainedBlock tip = null;
                    Row <int, BlockHeader> firstRow = transaction.Select <int, BlockHeader>("Chain", 0);

                    if (!firstRow.Exists)
                    {
                        return;
                    }

                    BlockHeader previousHeader = firstRow.Value;
                    Guard.Assert(previousHeader.GetHash() == chain.Genesis.HashBlock); // can't swap networks

                    foreach (Row <int, BlockHeader> row in transaction.SelectForwardSkip <int, BlockHeader>("Chain", 1))
                    {
                        if ((tip != null) && (previousHeader.HashPrevBlock != tip.HashBlock))
                        {
                            break;
                        }

                        tip            = new ChainedBlock(previousHeader, row.Value.HashPrevBlock, tip);
                        previousHeader = row.Value;
                    }

                    if (previousHeader != null)
                    {
                        tip = new ChainedBlock(previousHeader, null, tip);
                    }

                    if (tip == null)
                    {
                        return;
                    }

                    this.locator = tip.GetLocator();
                    chain.SetTip(tip);
                }
            });

            return(task);
        }
Esempio n. 2
0
        /// <inheritdoc />
        public Task <ChainedHeader> LoadAsync(ChainedHeader genesisHeader)
        {
            Task <ChainedHeader> task = Task.Run(() =>
            {
                using (DBreeze.Transactions.Transaction transaction = this.dbreeze.GetTransaction())
                {
                    transaction.ValuesLazyLoadingIsOn = false;
                    ChainedHeader tip          = null;
                    Row <int, byte[]> firstRow = transaction.Select <int, byte[]>("Chain", 0);

                    if (!firstRow.Exists)
                    {
                        return(genesisHeader);
                    }

                    BlockHeader previousHeader = this.dBreezeSerializer.Deserialize <BlockHeader>(firstRow.Value);
                    Guard.Assert(previousHeader.GetHash() == genesisHeader.HashBlock); // can't swap networks

                    foreach (Row <int, byte[]> row in transaction.SelectForwardSkip <int, byte[]>("Chain", 1))
                    {
                        if ((tip != null) && (previousHeader.HashPrevBlock != tip.HashBlock))
                        {
                            break;
                        }

                        BlockHeader blockHeader = this.dBreezeSerializer.Deserialize <BlockHeader>(row.Value);
                        tip            = new ChainedHeader(previousHeader, blockHeader.HashPrevBlock, tip);
                        previousHeader = blockHeader;
                    }

                    if (previousHeader != null)
                    {
                        tip = new ChainedHeader(previousHeader, previousHeader.GetHash(), tip);
                    }

                    if (tip == null)
                    {
                        tip = genesisHeader;
                    }

                    this.locator = tip.GetLocator();
                    return(tip);
                }
            });

            return(task);
        }