public void GetMiningTimestamp()
{
var tool = new KeyTool(new DataFolder(string.Empty));
Key key = tool.GeneratePrivateKey();
this.network = new TestPoANetwork(new List <PubKey>()
{
tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey
});
FederationManager fedManager = PoATestsBase.CreateFederationManager(this, this.network, new ExtendedLoggerFactory());
this.slotsManager = new SlotsManager(this.network, fedManager, new LoggerFactory());
List <PubKey> fedKeys = this.federationManager.GetFederationMembers();
uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count * 5;
fedManager.SetPrivatePropertyValue(nameof(FederationManager.IsFederationMember), true);
fedManager.SetPrivatePropertyValue(nameof(FederationManager.FederationMemberKey), key);
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4));
roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count;
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1));
Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5)));
}
public void GetMiningTimestamp()
{
var tool = new KeyTool(null);
Key key = tool.GeneratePrivateKey();
this.network = new TestPoANetwork(new List <PubKey>()
{
tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey
});
var fedManager = new FederationManager(NodeSettings.Default(this.network), this.network, new LoggerFactory());
this.slotsManager = new SlotsManager(this.network, fedManager, new LoggerFactory());
List <PubKey> fedKeys = this.consensusOptions.FederationPublicKeys;
uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count * 5;
fedManager.SetPrivatePropertyValue(nameof(FederationManager.IsFederationMember), true);
fedManager.SetPrivatePropertyValue(nameof(FederationManager.FederationMemberKey), key);
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4));
roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count;
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1));
Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5)));
}
public void GetMiningTimestamp()
{
var tool = new KeyTool(new DataFolder(string.Empty));
Key key = tool.GeneratePrivateKey();
this.network = new TestPoANetwork(new List <PubKey>()
{
tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey
});
(IFederationManager fedManager, IFederationHistory federationHistory) = PoATestsBase.CreateFederationManager(this, this.network, new ExtendedLoggerFactory(), new Signals.Signals(new LoggerFactory(), null));
var header = new BlockHeader();
this.chainIndexer.Setup(x => x.Tip).Returns(new ChainedHeader(header, header.GetHash(), 0));
this.slotsManager = new SlotsManager(this.network, fedManager, federationHistory, this.chainIndexer.Object);
List <IFederationMember> federationMembers = fedManager.GetFederationMembers();
uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count * 5;
fedManager.SetPrivatePropertyValue(typeof(FederationManager), nameof(IFederationManager.CurrentFederationKey), key);
fedManager.SetPrivatePropertyValue(typeof(FederationManager), nameof(this.federationManager.IsFederationMember), true);
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4));
roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count;
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5));
Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1));
Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5)));
uint thisTurnTimestamp = roundStart + this.consensusOptions.TargetSpacingSeconds;
uint nextTurnTimestamp = thisTurnTimestamp + this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count;
// If we are past our last timestamp's turn, always give us the NEXT timestamp.
uint justPastOurTurnTime = thisTurnTimestamp + (this.consensusOptions.TargetSpacingSeconds / 2) + 1;
Assert.Equal(nextTurnTimestamp, this.slotsManager.GetMiningTimestamp(justPastOurTurnTime));
// If we are only just past our last timestamp, but still in the "range" and we haven't mined a block yet, get THIS turn's timestamp.
Assert.Equal(thisTurnTimestamp, this.slotsManager.GetMiningTimestamp(thisTurnTimestamp + 1));
// If we are only just past our last timestamp, but we've already mined a block there, then get the NEXT turn's timestamp.
header = new BlockHeader
{
Time = thisTurnTimestamp
};
Mock.Get(federationHistory).Setup(x => x.GetFederationMemberForBlock(It.IsAny <ChainedHeader>())).Returns <ChainedHeader>((chainedHeader) =>
{
return(federationMembers[1]);
});
this.chainIndexer.Setup(x => x.Tip).Returns(new ChainedHeader(header, header.GetHash(), 0));
this.slotsManager = new SlotsManager(this.network, fedManager, federationHistory, this.chainIndexer.Object);
Assert.Equal(nextTurnTimestamp, this.slotsManager.GetMiningTimestamp(thisTurnTimestamp + 1));
}
private static void GeneratePublicPrivateKeys()
{
// Generate keys for signing.
var mnemonicForSigningKey = new Mnemonic(Wordlist.English, WordCount.Twelve);
PubKey signingPubKey = mnemonicForSigningKey.DeriveExtKey().PrivateKey.PubKey;
// Generate keys for migning.
var tool = new KeyTool(new DataFolder(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)));
Key key = tool.GeneratePrivateKey();
string savePath = tool.GetPrivateKeySavePath();
tool.SavePrivateKey(key);
PubKey miningPubKey = key.PubKey;
Console.WriteLine($"-----------------------------------------------------------------------------");
Console.WriteLine($"-- Please give the following 2 public keys to the federation administrator --");
Console.WriteLine($"-----------------------------------------------------------------------------");
Console.WriteLine($"1. Your signing pubkey: {Encoders.Hex.EncodeData(signingPubKey.ToBytes(false))}");
Console.WriteLine($"2. Your mining pubkey: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}");
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"------------------------------------------------------------------------------------------");
Console.WriteLine($"-- Please keep the following 12 words for yourself and note them down in a secure place --");
Console.WriteLine($"------------------------------------------------------------------------------------------");
Console.WriteLine($"Your signing mnemonic: {string.Join(" ", mnemonicForSigningKey.Words)}");
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"-- Please save the following file in a secure place, you'll need it when the federation has been created. --");
Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"File path: {savePath}");
Console.WriteLine(Environment.NewLine);
}
private bool CreateFederationKey()
{
var keyFilePath = Path.Combine(this.rootDataDir, this.sidechainNetwork.RootFolderName, this.sidechainNetwork.Name, KeyTool.KeyFileDefaultName);
if (File.Exists(keyFilePath))
{
Console.WriteLine($"Your masternode public key file already exists.");
return(true);
}
Console.Clear();
Console.WriteLine($"Your masternode public key will now be generated.");
string publicKeyPassphrase;
do
{
Console.WriteLine($"Please enter a passphrase (this can be anything, but please write it down):");
publicKeyPassphrase = Console.ReadLine();
if (!string.IsNullOrEmpty(publicKeyPassphrase))
{
break;
}
Console.WriteLine("ERROR: Please ensure that you enter a valid passphrase.");
} while (true);
// Generate keys for mining.
var tool = new KeyTool(keyFilePath);
Key key = tool.GeneratePrivateKey();
string savePath = tool.GetPrivateKeySavePath();
tool.SavePrivateKey(key);
PubKey miningPubKey = key.PubKey;
Console.WriteLine($"Your Masternode Public Key (PubKey) is: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}");
if (publicKeyPassphrase != null)
{
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"Your passphrase: {publicKeyPassphrase}");
}
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"It has been saved in the root Cirrus data folder: {savePath}");
Console.WriteLine($"Please ensure that you take a backup of this file.");
return(true);
}
public void CheckSignaturesEqual()
{
Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
var validationContext = new ValidationContext()
{
ChainedHeaderToValidate = this.currentHeader, BlockToValidate = block
};
var ruleContext = new RuleContext(validationContext, DateTimeOffset.Now);
var tool = new KeyTool(new DataFolder(string.Empty));
Key key1 = tool.GeneratePrivateKey();
Key key2 = tool.GeneratePrivateKey();
this.poaHeaderValidator.Sign(key1, this.currentHeader.Header as PoABlockHeader);
this.poaHeaderValidator.Sign(key2, block.Header as PoABlockHeader);
Assert.Throws <ConsensusErrorException>(() => this.integritySignatureRule.Run(ruleContext));
(block.Header as PoABlockHeader).BlockSignature = (this.currentHeader.Header as PoABlockHeader).BlockSignature;
this.integritySignatureRule.Run(ruleContext);
}
private static void GeneratePublicPrivateKeys(string passphrase, string keyPath, bool isMultiSigOutput = true)
{
// Generate keys for signing.
var mnemonicForSigningKey = new Mnemonic(Wordlist.English, WordCount.Twelve);
PubKey signingPubKey = mnemonicForSigningKey.DeriveExtKey(passphrase).PrivateKey.PubKey;
// Generate keys for migning.
var tool = new KeyTool(keyPath);
Key key = tool.GeneratePrivateKey();
string savePath = tool.GetPrivateKeySavePath();
tool.SavePrivateKey(key);
PubKey miningPubKey = key.PubKey;
Console.WriteLine($"Your Masternode Public Key: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}");
Console.WriteLine($"-----------------------------------------------------------------------------");
if (isMultiSigOutput)
{
Console.WriteLine(
$"Your Masternode Signing Key: {Encoders.Hex.EncodeData(signingPubKey.ToBytes(false))}");
Console.WriteLine(Environment.NewLine);
Console.WriteLine(
$"------------------------------------------------------------------------------------------");
Console.WriteLine(
$"-- Please keep the following 12 words for yourself and note them down in a secure place --");
Console.WriteLine(
$"------------------------------------------------------------------------------------------");
Console.WriteLine($"Your signing mnemonic: {string.Join(" ", mnemonicForSigningKey.Words)}");
}
if (passphrase != null)
{
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"Your passphrase: {passphrase}");
}
Console.WriteLine(Environment.NewLine);
Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"-- Please save the following file in a secure place, you'll need it when the federation has been created. --");
Console.WriteLine($"------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"File path: {savePath}");
Console.WriteLine(Environment.NewLine);
}
private static void GenerateFederationKey(DataFolder dataFolder)
{
var tool = new KeyTool(dataFolder);
Key key = tool.GeneratePrivateKey();
string savePath = tool.GetPrivateKeySavePath();
tool.SavePrivateKey(key);
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine($"Federation key pair was generated and saved to {savePath}.");
stringBuilder.AppendLine("Make sure to back it up!");
stringBuilder.AppendLine($"Your public key is {key.PubKey}.");
stringBuilder.AppendLine();
stringBuilder.AppendLine("Press eny key to exit...");
Console.WriteLine(stringBuilder.ToString());
Console.ReadKey();
}
private static void GenerateServiceNodeKey(NodeSettings nodeSettings)
{
var tool = new KeyTool(nodeSettings.DataFolder);
Key key = tool.GeneratePrivateKey();
string savePath = tool.GetPrivateKeySavePath();
tool.SavePrivateKey(key);
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine($"ServiceNode key pair was generated and saved to {savePath}.");
stringBuilder.AppendLine("Make sure to back it up!");
stringBuilder.AppendLine($"Your public key is {key.PubKey}.");
stringBuilder.AppendLine();
stringBuilder.AppendLine("You can now restart the node to use the key pair. If you need to re-generate add generateKeyPair to settings");
stringBuilder.AppendLine("Press eny key to exit...");
Console.WriteLine(stringBuilder.ToString());
Console.ReadKey();
}