Exemple #1
0
        public async Task PremineIsReceivedAsync()
        {
            TestPoANetwork network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                string   walletName = "mywallet";
                CoreNode node       = builder.CreatePoANode(network, network.FederationKey1).WithWallet("pass", walletName).Start();

                IWalletManager walletManager  = node.FullNode.NodeService <IWalletManager>();
                long           balanceOnStart = walletManager.GetBalances(walletName, "account 0").Sum(x => x.AmountConfirmed);
                Assert.Equal(0, balanceOnStart);

                long toMineCount = network.Consensus.PremineHeight + network.Consensus.CoinbaseMaturity + 1 - node.GetTip().Height;

                await node.MineBlocksAsync((int)toMineCount).ConfigureAwait(false);

                TestBase.WaitLoop(() =>
                {
                    long balanceAfterPremine = walletManager.GetBalances(walletName, "account 0").Sum(x => x.AmountConfirmed);

                    return(network.Consensus.PremineReward.Satoshi == balanceAfterPremine);
                });
            }
        }
        public async Task HeaderInFutureIsntAcceptedButNoBan()
        {
            // Create 2 nodes from 2 different builders, so they have different internal times.
            var            network  = new TestPoANetwork();
            PoANodeBuilder builder  = PoANodeBuilder.CreatePoANodeBuilder(this);
            PoANodeBuilder builder2 = PoANodeBuilder.CreatePoANodeBuilder(this);
            CoreNode       node1    = builder.CreatePoANode(network, network.FederationKey1).Start();
            CoreNode       node2    = builder2.CreatePoANode(network, network.FederationKey2).Start();

            // They can connect, they agree on genesis.
            TestHelper.Connect(node1, node2);

            // When one mines a block, his time will be pushed forwards by multiple TargetSpacings.
            await node1.MineBlocksAsync(1);

            long dateTime1 = node1.FullNode.NodeService <IDateTimeProvider>().GetAdjustedTimeAsUnixTimestamp();
            long dateTime2 = node2.FullNode.NodeService <IDateTimeProvider>().GetAdjustedTimeAsUnixTimestamp();

            Assert.True(dateTime1 > dateTime2 + network.ConsensusOptions.TargetSpacingSeconds);

            // Give the other node plenty of time such that he should have also synced if he thought the block was valid.
            Thread.Sleep(3000);

            // But he didn't sync - header was too far ahead.
            Assert.Equal(0, node2.FullNode.ChainIndexer.Height);

            // However the other node isn't disconnected or banned.
            Assert.True(node2.FullNode.ConnectionManager.ConnectedPeers.Any());
        }
Exemple #3
0
        public async Task CanMineVotingRequestTransactionAsync()
        {
            var network = new TestPoACollateralNetwork(true, Guid.NewGuid().ToString());

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                string walletName     = "mywallet";
                string walletPassword = "******";
                string walletAccount  = "account 0";

                Money transferAmount = Money.Coins(0.01m);
                Money feeAmount      = Money.Coins(0.0001m);

                var counterchainNetwork = new StraxTest();

                CoreNode nodeA = builder.CreatePoANodeWithCounterchain(network, counterchainNetwork, network.FederationKey1).WithWallet(walletPassword, walletName).Start();
                CoreNode nodeB = builder.CreatePoANodeWithCounterchain(network, counterchainNetwork, network.FederationKey2).WithWallet(walletPassword, walletName).Start();

                TestHelper.Connect(nodeA, nodeB);

                long toMineCount = network.Consensus.PremineHeight + network.Consensus.CoinbaseMaturity + 1 - nodeA.GetTip().Height;

                // Get coins on nodeA via the premine.
                await nodeA.MineBlocksAsync((int)toMineCount).ConfigureAwait(false);

                CoreNodePoAExtensions.WaitTillSynced(nodeA, nodeB);

                // Create voting-request transaction.
                var minerKey      = new Key();
                var collateralKey = new Key();
                var request       = new JoinFederationRequest(minerKey.PubKey, new Money(CollateralFederationMember.MinerCollateralAmount, MoneyUnit.BTC), collateralKey.PubKey.Hash);

                // In practice this signature will come from calling the counter-chain "signmessage" API.
                request.AddSignature(collateralKey.SignMessage(request.SignatureMessage));

                var         encoder = new JoinFederationRequestEncoder(nodeA.FullNode.NodeService <Microsoft.Extensions.Logging.ILoggerFactory>());
                Transaction trx     = JoinFederationRequestBuilder.BuildTransaction(nodeA.FullNode.WalletTransactionHandler(), this.network, request, encoder, walletName, walletAccount, walletPassword);

                await nodeA.FullNode.NodeController <WalletController>().SendTransaction(new SendTransactionRequest(trx.ToHex()));

                TestBase.WaitLoop(() => nodeA.CreateRPCClient().GetRawMempool().Length == 1 && nodeB.CreateRPCClient().GetRawMempool().Length == 1);

                await nodeB.MineBlocksAsync((int)toMineCount).ConfigureAwait(false);

                TestBase.WaitLoop(() => nodeA.CreateRPCClient().GetRawMempool().Length == 0 && nodeB.CreateRPCClient().GetRawMempool().Length == 0);

                IWalletManager walletManager = nodeB.FullNode.NodeService <IWalletManager>();

                TestBase.WaitLoop(() =>
                {
                    long balance = walletManager.GetBalances(walletName, walletAccount).Sum(x => x.AmountConfirmed);

                    return(balance == feeAmount);
                });

                Assert.Single(nodeA.FullNode.NodeService <VotingManager>().GetPendingPolls());
                Assert.Single(nodeB.FullNode.NodeService <VotingManager>().GetPendingPolls());
            }
        }
        public async Task TransactionSentFeesReceivedByMinerAsync()
        {
            TestPoANetwork network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                string walletName     = "mywallet";
                string walletPassword = "******";
                string walletAccount  = "account 0";

                Money transferAmount = Money.Coins(1m);
                Money feeAmount      = Money.Coins(0.0001m);

                CoreNode nodeA = builder.CreatePoANode(network, network.FederationKey1).WithWallet(walletPassword, walletName).Start();
                CoreNode nodeB = builder.CreatePoANode(network, network.FederationKey2).WithWallet(walletPassword, walletName).Start();

                TestHelper.Connect(nodeA, nodeB);

                long toMineCount = network.Consensus.PremineHeight + network.Consensus.CoinbaseMaturity + 1 - nodeA.GetTip().Height;

                // Get coins on nodeA via the premine.
                await nodeA.MineBlocksAsync((int)toMineCount).ConfigureAwait(false);

                CoreNodePoAExtensions.WaitTillSynced(nodeA, nodeB);

                // Will send funds to one of nodeB's addresses.
                Script destination = nodeB.FullNode.WalletManager().GetUnusedAddress().ScriptPubKey;

                var context = new TransactionBuildContext(network)
                {
                    AccountReference = new WalletAccountReference(walletName, walletAccount),
                    MinConfirmations = 0,
                    FeeType          = FeeType.High,
                    WalletPassword   = walletPassword,
                    Recipients       = new[] { new Recipient {
                                                   Amount = transferAmount, ScriptPubKey = destination
                                               } }.ToList()
                };

                Transaction trx = nodeA.FullNode.WalletTransactionHandler().BuildTransaction(context);

                nodeA.FullNode.NodeController <WalletController>().SendTransaction(new SendTransactionRequest(trx.ToHex()));

                TestBase.WaitLoop(() => nodeA.CreateRPCClient().GetRawMempool().Length == 1 && nodeB.CreateRPCClient().GetRawMempool().Length == 1);

                await nodeB.MineBlocksAsync((int)toMineCount).ConfigureAwait(false);

                TestBase.WaitLoop(() => nodeA.CreateRPCClient().GetRawMempool().Length == 0 && nodeB.CreateRPCClient().GetRawMempool().Length == 0);

                IWalletManager walletManager = nodeB.FullNode.NodeService <IWalletManager>();
                long           balance       = walletManager.GetBalances(walletName, walletAccount).Sum(x => x.AmountConfirmed);

                Assert.True(balance == transferAmount + feeAmount);
            }
        }
Exemple #5
0
        public VotingAndMiningTests()
        {
            this.testPubKey = new Mnemonic("lava frown leave virtual wedding ghost sibling able liar wide wisdom mammal").DeriveExtKey().PrivateKey.PubKey;
            this.network    = new TestPoANetwork();

            this.builder = PoANodeBuilder.CreatePoANodeBuilder(this);

            this.node1 = this.builder.CreatePoANode(this.network, this.network.FederationKey1).Start();
            this.node2 = this.builder.CreatePoANode(this.network, this.network.FederationKey2).Start();
            this.node3 = this.builder.CreatePoANode(this.network, this.network.FederationKey3).Start();
        }
        public void NodeCanMine()
        {
            var network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                CoreNode node = builder.CreatePoANode(network, network.FederationKey1).Start();
                node.EnableFastMining();

                var tipBefore = node.GetTip().Height;
                TestHelper.WaitLoop(() => node.GetTip().Height >= tipBefore + 5);
            }
        }
Exemple #7
0
        public async Task NodeCanMineAsync()
        {
            var network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                CoreNode node = builder.CreatePoANode(network, network.FederationKey1).Start();

                int tipBefore = node.GetTip().Height;

                await node.MineBlocksAsync(5).ConfigureAwait(false);

                Assert.True(node.GetTip().Height >= tipBefore + 5);
            }
        }
Exemple #8
0
        public void NodeCanLoadFederationKey()
        {
            var network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                // Create first node as fed member.
                Key      key  = network.FederationKey1;
                CoreNode node = builder.CreatePoANode(network, key).Start();

                Assert.True(node.FullNode.NodeService <IFederationManager>().IsFederationMember);
                Assert.Equal(node.FullNode.NodeService <IFederationManager>().CurrentFederationKey, key);

                // Create second node as normal node.
                CoreNode node2 = builder.CreatePoANode(network).Start();

                Assert.False(node2.FullNode.NodeService <IFederationManager>().IsFederationMember);
                Assert.Equal(node2.FullNode.NodeService <IFederationManager>().CurrentFederationKey, null);
            }
        }
        public void NodeCanMine()
        {
            var network = (CirrusRegTest)CirrusNetwork.NetworksSelector.Regtest();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                CoreNode node0 = builder.CreatePoANode(network, network.FederationKeys[0]).Start();
                CoreNode node1 = builder.CreatePoANode(network, network.FederationKeys[1]).Start();
                // node0.EnableFastMining(); Old method
                // node1.EnableFastMining(); Old method

                int tipBefore = node0.GetTip().Height;
                TestBase.WaitLoop(
                    () =>
                {
                    return(node0.GetTip().Height >= tipBefore + 5);
                }
                    );
            }
        }
        public void NodeCanMine()
        {
            var network = (FederatedPegRegTest)FederatedPegNetwork.NetworksSelector.Regtest();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                CoreNode node0 = builder.CreatePoANode(network, network.FederationKeys[0]).Start();
                CoreNode node1 = builder.CreatePoANode(network, network.FederationKeys[1]).Start();
                node0.EnableFastMining();
                node1.EnableFastMining();

                var tipBefore = node0.GetTip().Height;
                TestHelper.WaitLoop(
                    () =>
                {
                    return(node0.GetTip().Height >= tipBefore + 5);
                }
                    );
            }
        }
        public void PremineIsReceived()
        {
            TestPoANetwork network = new TestPoANetwork();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                string   walletName = "mywallet";
                CoreNode node       = builder.CreatePoANode(network, network.FederationKey1).WithWallet("pass", walletName).Start();
                node.EnableFastMining();

                IWalletManager walletManager  = node.FullNode.NodeService <IWalletManager>();
                long           balanceOnStart = walletManager.GetBalances(walletName, "account 0").Sum(x => x.AmountConfirmed);
                Assert.Equal(0, balanceOnStart);

                TestHelper.WaitLoop(() => node.GetTip().Height >= network.Consensus.PremineHeight + network.Consensus.CoinbaseMaturity + 1);

                long balanceAfterPremine = walletManager.GetBalances(walletName, "account 0").Sum(x => x.AmountConfirmed);

                Assert.Equal(network.Consensus.PremineReward.Satoshi, balanceAfterPremine);
            }
        }
        public void NodeCanLoadFederationKey()
        {
            var network = (CirrusRegTest)CirrusNetwork.NetworksSelector.Regtest();

            using (PoANodeBuilder builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                // Create first node as fed member.
                Key      key  = network.FederationKeys[0];
                CoreNode node = builder.CreatePoANode(network, key).Start();

                Assert.True(node.FullNode.NodeService <IFederationManager>().IsFederationMember);
                Assert.Equal(node.FullNode.NodeService <IFederationManager>().CurrentFederationKey, key);
                // Assert.True(node.FullNode.NodeService<IPoAMiner>().IsMining()); Old method

                // Create second node as normal node.
                CoreNode node2 = builder.CreatePoANode(network).Start();

                Assert.False(node2.FullNode.NodeService <IFederationManager>().IsFederationMember);
                Assert.Equal(node2.FullNode.NodeService <IFederationManager>().CurrentFederationKey, null);
                // Assert.False(node2.FullNode.NodeService<IPoAMiner>().IsMining()); Old method
            }
        }
Exemple #13
0
        public async Task EnableAutoKickAsync()
        {
            using (var builder = PoANodeBuilder.CreatePoANodeBuilder(this))
            {
                const int idleTimeSeconds = 10 * 60;

                // Have a network that mimics Cirrus where voting is on and kicking is off.
                var votingNetwork1 = new TestPoANetwork("VoteNetwork1");
                var votingNetwork2 = new TestPoANetwork("VoteNetwork2");

                var oldOptions = (PoAConsensusOptions)votingNetwork1.Consensus.Options;

                votingNetwork1.Consensus.Options = new PoAConsensusOptions(maxBlockBaseSize: oldOptions.MaxBlockBaseSize,
                                                                           maxStandardVersion: oldOptions.MaxStandardVersion,
                                                                           maxStandardTxWeight: oldOptions.MaxStandardTxWeight,
                                                                           maxBlockSigopsCost: oldOptions.MaxBlockSigopsCost,
                                                                           maxStandardTxSigopsCost: oldOptions.MaxStandardTxSigopsCost,
                                                                           genesisFederationMembers: oldOptions.GenesisFederationMembers,
                                                                           targetSpacingSeconds: 60,
                                                                           votingEnabled: true,
                                                                           autoKickIdleMembers: false,
                                                                           federationMemberMaxIdleTimeSeconds: oldOptions.FederationMemberMaxIdleTimeSeconds);

                CoreNode node1 = builder.CreatePoANode(votingNetwork1, votingNetwork1.FederationKey1).Start();
                CoreNode node2 = builder.CreatePoANode(votingNetwork2, votingNetwork2.FederationKey2).Start();
                TestHelper.Connect(node1, node2);

                // Mine a block on this network from each node. Confirm it's alive.
                await node1.MineBlocksAsync(1);

                CoreNodePoAExtensions.WaitTillSynced(node1, node2);
                await node2.MineBlocksAsync(1);

                CoreNodePoAExtensions.WaitTillSynced(node1, node2);

                // Edit the consensus options so that kicking is turned on.
                votingNetwork1.Consensus.Options = new PoAConsensusOptions(maxBlockBaseSize: oldOptions.MaxBlockBaseSize,
                                                                           maxStandardVersion: oldOptions.MaxStandardVersion,
                                                                           maxStandardTxWeight: oldOptions.MaxStandardTxWeight,
                                                                           maxBlockSigopsCost: oldOptions.MaxBlockSigopsCost,
                                                                           maxStandardTxSigopsCost: oldOptions.MaxStandardTxSigopsCost,
                                                                           genesisFederationMembers: oldOptions.GenesisFederationMembers,
                                                                           targetSpacingSeconds: 60,
                                                                           votingEnabled: true,
                                                                           autoKickIdleMembers: true,
                                                                           federationMemberMaxIdleTimeSeconds: idleTimeSeconds);

                // Restart node 1 to ensure that we have the new network consensus options which reflects
                // the autokicking enabled.
                node1.Restart();

                // Lets get our 2 nodes to actively mine some blocks.
                // In doing so, their test datetimeprovider will increment by minutes at a time.
                for (int i = 0; i < 5; i++)
                {
                    await node1.MineBlocksAsync(1);

                    CoreNodePoAExtensions.WaitTillSynced(node1, node2);

                    await node2.MineBlocksAsync(1);

                    CoreNodePoAExtensions.WaitTillSynced(node1, node2);
                }

                // Enough time has passed - Check that our new node wants to vote the third fed member out, who has not mined at all.
                // Check that we have a single active poll to vote him out.
                List <Poll> activePolls = node1.FullNode.NodeService <VotingManager>().GetPendingPolls();
                Assert.Single(activePolls);
                Assert.Equal(VoteKey.KickFederationMember, activePolls[0].VotingData.Key);
                byte[] lastMemberBytes = (votingNetwork1.Consensus.ConsensusFactory as PoAConsensusFactory).SerializeFederationMember(votingNetwork1.ConsensusOptions.GenesisFederationMembers[2]);
                Assert.Equal(lastMemberBytes, activePolls[0].VotingData.Data);
            }
        }