示例#1
0
        public BlockPolicySource(ILogger logger, LogEventLevel logEventLevel = LogEventLevel.Verbose)
        {
            LoggedActionRenderer =
                new LoggedActionRenderer <NCAction>(ActionRenderer, logger, logEventLevel);

            LoggedBlockRenderer =
                new LoggedRenderer <NCAction>(BlockRenderer, logger, logEventLevel);
        }
示例#2
0
        public async Task BroadcastBlockWithSkip()
        {
            var policy           = new BlockPolicy <DumbAction>(new MinerReward(1));
            var fx1              = new DefaultStoreFixture(memory: true);
            var blockChain       = TestUtils.MakeBlockChain(policy, fx1.Store, fx1.StateStore);
            var privateKey       = new PrivateKey();
            var minerSwarm       = CreateSwarm(blockChain, privateKey);
            var fx2              = new DefaultStoreFixture(memory: true);
            var receiverRenderer = new RecordingActionRenderer <DumbAction>();
            var loggedRenderer   = new LoggedActionRenderer <DumbAction>(
                receiverRenderer,
                _logger);
            var receiverChain = TestUtils.MakeBlockChain(
                policy,
                fx2.Store,
                fx2.StateStore,
                renderers: new[] { loggedRenderer });
            Swarm <DumbAction> receiverSwarm = CreateSwarm(receiverChain);

            int renderCount = 0;

            receiverRenderer.RenderEventHandler += (_, a) => renderCount += a is DumbAction ? 1 : 0;

            Transaction <DumbAction>[] transactions =
            {
                fx1.MakeTransaction(
                    new[]
                {
                    new DumbAction(fx1.Address2, "foo"),
                    new DumbAction(fx1.Address2, "bar"),
                },
                    timestamp: DateTimeOffset.MinValue,
                    nonce: 0,
                    privateKey: privateKey),
                fx1.MakeTransaction(
                    new[]
                {
                    new DumbAction(fx1.Address2, "baz"),
                    new DumbAction(fx1.Address2, "qux"),
                },
                    timestamp: DateTimeOffset.MinValue.AddSeconds(5),
                    nonce: 1,
                    privateKey: privateKey),
            };

            try
            {
                await StartAsync(minerSwarm);
                await StartAsync(receiverSwarm);

                await BootstrapAsync(receiverSwarm, minerSwarm.AsPeer);

                Block <DumbAction> block1 = TestUtils.MineNext(
                    blockChain.Genesis,
                    policy.GetHashAlgorithm,
                    new[] { transactions[0] },
                    null,
                    policy.GetNextBlockDifficulty(blockChain),
                    miner: TestUtils.GenesisMiner.PublicKey
                    ).Evaluate(TestUtils.GenesisMiner, blockChain);
                blockChain.Append(block1, true, true, false);
                Block <DumbAction> block2 = TestUtils.MineNext(
                    block1,
                    policy.GetHashAlgorithm,
                    new[] { transactions[1] },
                    null,
                    policy.GetNextBlockDifficulty(blockChain),
                    miner: TestUtils.GenesisMiner.PublicKey
                    ).Evaluate(TestUtils.GenesisMiner, blockChain);
                blockChain.Append(block2, true, true, false);
                Log.Debug("Ready to broadcast blocks.");
                minerSwarm.BroadcastBlock(block2);
                await receiverSwarm.BlockAppended.WaitAsync();

                Assert.Equal(3, receiverChain.Count);
                Assert.Equal(4, renderCount);
            }
            finally
            {
                await StopAsync(minerSwarm);
                await StopAsync(receiverSwarm);

                fx1.Dispose();
                minerSwarm.Dispose();
            }
        }