private void SendTransactionsShortBlock(Tuple <RegistryFullBlock, RegistryShortBlock> tuple)
{
RegistryShortBlock transactionsShortBlock = tuple.Item2;
ISerializer signatureSupportSerializer = _signatureSupportSerializersFactory.Create(transactionsShortBlock);
_tcpCommunicationService.PostMessage(_registryGroupState.GetAllNeighbors(), signatureSupportSerializer);
}
private void RecalculateProductionTimer()
{
_registryGroupState.Round = 0;
if (_syncCycleDescriptor != null)
{
_syncCycleDescriptor.CancellationTokenSource.Cancel();
_syncCycleDescriptor.CancellationRequested = true;
}
_syncCycleDescriptor = new SyncCycleDescriptor(_synchronizationContext.LastBlockDescriptor);
PeriodicTaskFactory.Start(o =>
{
SyncCycleDescriptor syncCycleDescriptor = (SyncCycleDescriptor)o;
SortedList <ushort, RegistryRegisterBlock> transactionStateWitnesses = _registryMemPool.DequeueStateWitnessBulk();
SortedList <ushort, RegistryRegisterUtxoConfidential> transactionUtxoWitnesses = _registryMemPool.DequeueUtxoWitnessBulk();
RegistryFullBlock registryFullBlock = ProduceTransactionsFullBlock(transactionStateWitnesses, transactionUtxoWitnesses, syncCycleDescriptor.SynchronizationDescriptor, syncCycleDescriptor.Round);
RegistryShortBlock registryShortBlock = ProduceTransactionsShortBlock(registryFullBlock);
SendTransactionsBlocks(registryFullBlock, registryShortBlock);
syncCycleDescriptor.Round++;
if (syncCycleDescriptor.CancellationRequested)
{
syncCycleDescriptor.CancellationTokenSource.Cancel();
}
}, _syncCycleDescriptor, _registrationPeriodMsec * _registryConfiguration.TotalNodes, _registryConfiguration.Position * _registrationPeriodMsec, cancelToken: _syncCycleDescriptor.CancellationTokenSource.Token, periodicTaskCreationOptions: TaskCreationOptions.LongRunning);
}
public byte[] GetConfidenceMask(RegistryShortBlock transactionsShortBlock, out byte[] bitMask)
{
lock (_sync)
{
bool[] bools = transactionsShortBlock.TransactionHeaderHashes.Select(kvp => _transactionOrderByTransactionKey[transactionsShortBlock.SyncBlockHeight].ContainsKey(kvp.Value)).ToArray();
BitArray bitArray = bools.ToBitArray();
bitMask = new byte[bitArray.Length / 8 + ((bitArray.Length % 8 > 0) ? 1 : 0)];
bitArray.CopyTo(bitMask, 0);
BigInteger bigIntegerSum = new BigInteger();
int i = 0;
foreach (var key in transactionsShortBlock.TransactionHeaderHashes.Keys)
{
if (bools[i++])
{
int transactionHeaderOrder = _transactionOrderByTransactionKey[transactionsShortBlock.SyncBlockHeight][transactionsShortBlock.TransactionHeaderHashes[key]];
ITransactionRegistryBlock registryRegisterBlock = _transactionRegisterBlocksOrdered[transactionsShortBlock.SyncBlockHeight][transactionHeaderOrder];
IKey registryRegisterBlockKey = _transactionsRegistryHelper.GetTransactionRegistryHashKey(registryRegisterBlock);
BigInteger bigInteger = new BigInteger(registryRegisterBlockKey.Value.ToArray());
bigIntegerSum += bigInteger;
}
}
byte[] sumBytes = bigIntegerSum.ToByteArray().Take(Globals.TRANSACTION_KEY_HASH_SIZE).ToArray();
byte[] returnValue = new byte[Globals.TRANSACTION_KEY_HASH_SIZE];
Array.Copy(sumBytes, 0, returnValue, 0, sumBytes.Length);
return(returnValue);
}
}
public static RegistryShortBlock GetTransactionsShortBlock(ulong syncBlockHeight, uint nonce, byte[] powHash, ulong blockHeight, byte round, IEnumerable <RegistryRegisterBlock> transactionRegisterBlocks, byte[] privateKey, ITransactionsRegistryHelper transactionsRegistryHelper)
{
byte[] publicKey = Ed25519.PublicKeyFromSeed(privateKey);
SortedList <ushort, IKey> transactionHeaders = new SortedList <ushort, IKey>();
ushort order = 0;
foreach (var item in transactionRegisterBlocks)
{
transactionHeaders.Add(order++, transactionsRegistryHelper.GetTransactionRegistryTwiceHashedKey(item));
}
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash ?? new byte[Globals.POW_HASH_SIZE],
BlockHeight = blockHeight,
TransactionHeaderHashes = transactionHeaders,
Signer = new Key32(publicKey)
};
return(transactionsShortBlock);
}
public void ClearWitnessed(RegistryShortBlock transactionsShortBlock)
{
lock (_sync)
{
foreach (var witnessStateKey in transactionsShortBlock.WitnessStateKeys)
{
if (_transactionStateWitnessesBySender.ContainsKey(witnessStateKey.PublicKey))
{
RegistryRegisterBlock transactionWitness = _transactionStateWitnessesBySender[witnessStateKey.PublicKey].FirstOrDefault(t => t.BlockHeight == witnessStateKey.Height);
if (transactionWitness != null)
{
_transactionStateWitnessesBySender[witnessStateKey.PublicKey].Remove(transactionWitness);
if (_transactionStateWitnessesBySender[witnessStateKey.PublicKey].Count == 0)
{
_transactionStateWitnessesBySender.Remove(witnessStateKey.PublicKey);
}
_transactionStateWitnesses.Remove(transactionWitness);
}
}
}
foreach (var witnessUtxoKey in transactionsShortBlock.WitnessUtxoKeys)
{
if (_transactionUtxoWitnessesByKeyImage.ContainsKey(witnessUtxoKey.KeyImage))
{
RegistryRegisterUtxoConfidential transactionWitness = _transactionUtxoWitnessesByKeyImage[witnessUtxoKey.KeyImage];
_transactionStateWitnessesBySender.Remove(witnessUtxoKey.KeyImage);
_transactionUtxoWitnesses.Remove(transactionWitness);
}
}
}
}
public static RegistryShortBlock GetTransactionsShortBlock(ulong syncBlockHeight, uint nonce, byte[] powHash, ulong blockHeight, byte round, IEnumerable <RegistryRegisterBlock> transactionRegisterBlocks, byte[] privateKey)
{
byte[] publicKey = Ed25519.PublicKeyFromSeed(privateKey);
WitnessStateKey[] transactionHeaders = new WitnessStateKey[transactionRegisterBlocks.Count()];
ushort order = 0;
foreach (var item in transactionRegisterBlocks)
{
transactionHeaders[order++] = new WitnessStateKey {
PublicKey = item.Signer, Height = item.BlockHeight
};
}
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash ?? new byte[Globals.POW_HASH_SIZE],
BlockHeight = blockHeight,
WitnessStateKeys = transactionHeaders,
Signer = new Key32(publicKey)
};
return(transactionsShortBlock);
}
protected override Memory <byte> ParseSynced(ushort version, Memory <byte> spanBody, out SyncedBlockBase syncedBlockBase)
{
if (version == 1)
{
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock();
ushort itemsCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span);
transactionsShortBlock.TransactionHeaderHashes = new SortedList <ushort, IKey>(itemsCount);
for (int i = 0; i < itemsCount; i++)
{
ushort order = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(2 + i * (Globals.TRANSACTION_KEY_HASH_SIZE + 2)));
byte[] hashKey = spanBody.Slice(2 + i * (Globals.TRANSACTION_KEY_HASH_SIZE + 2) + 2, Globals.TRANSACTION_KEY_HASH_SIZE).ToArray();
IKey key = _transactionHashKeyProvider.GetKey(hashKey);
transactionsShortBlock.TransactionHeaderHashes.Add(order, key);
}
syncedBlockBase = transactionsShortBlock;
return(spanBody.Slice(2 + itemsCount * (Globals.TRANSACTION_KEY_HASH_SIZE + 2)));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
public bool EnqueueTransactionsShortBlock(RegistryShortBlock transactionsShortBlock)
{
lock (_sync)
{
if (!_transactionsShortBlocks[transactionsShortBlock.SyncBlockHeight].ContainsKey(transactionsShortBlock.BlockHeight))
{
_transactionsShortBlocks[transactionsShortBlock.SyncBlockHeight].Add(transactionsShortBlock.BlockHeight, new HashSet <RegistryShortBlock>());
}
return(_transactionsShortBlocks[transactionsShortBlock.SyncBlockHeight][transactionsShortBlock.BlockHeight].Add(transactionsShortBlock));
}
}
private void ProcessWitnessed(RegistryShortBlock registryShortBlock)
{
_registryGroupState.ToggleLastBlockConfirmationReceived();
if (registryShortBlock != null)
{
_registryMemPool.ClearWitnessed(registryShortBlock);
}
//TODO: obtain Transactions Registry Short block from MemPool by hash given in confirmationBlock
//TODO: clear MemPool from Transaction Headers of confirmed Short Block
}
protected override Memory <byte> ParseSigned(ushort version, Memory <byte> spanBody, out SignedPacketBase syncedBlockBase)
{
if (version == 1)
{
int readBytes = 0;
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock();
ushort witnessStateKeysCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += sizeof(ushort);
ushort witnessUtxoKeysCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += sizeof(ushort);
transactionsShortBlock.WitnessStateKeys = new WitnessStateKey[witnessStateKeysCount];
transactionsShortBlock.WitnessUtxoKeys = new WitnessUtxoKey[witnessUtxoKeysCount];
for (int i = 0; i < witnessStateKeysCount; i++)
{
byte[] witnessPublicKey = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
ulong witnessHeight = BinaryPrimitives.ReadUInt64LittleEndian(spanBody.Slice(readBytes).Span);
readBytes += sizeof(ulong);
IKey key = _keyProvider.GetKey(witnessPublicKey);
transactionsShortBlock.WitnessStateKeys[i] = new WitnessStateKey {
PublicKey = key, Height = witnessHeight
};
}
for (int i = 0; i < witnessUtxoKeysCount; i++)
{
byte[] witnessKeyImage = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
IKey key = _keyProvider.GetKey(witnessKeyImage);
transactionsShortBlock.WitnessUtxoKeys[i] = new WitnessUtxoKey {
KeyImage = key
};
}
syncedBlockBase = transactionsShortBlock;
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
private Tuple <RegistryFullBlock, RegistryShortBlock> ProduceTransactionsShortBlock(RegistryFullBlock transactionsFullBlock)
{
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock
{
SyncBlockHeight = transactionsFullBlock.SyncBlockHeight,
Nonce = transactionsFullBlock.Nonce,
PowHash = transactionsFullBlock.PowHash, // _powCalculation.CalculateHash(_synchronizationContext.LastBlockDescriptor?.Hash ?? new byte[Globals.DEFAULT_HASH_SIZE]),
BlockHeight = transactionsFullBlock.BlockHeight,
TransactionHeaderHashes = new SortedList <ushort, IKey>(transactionsFullBlock.TransactionHeaders.ToDictionary(i => i.Key, i => _transactionsRegistryHelper.GetTransactionRegistryTwiceHashedKey(i.Value)))
};
Tuple <RegistryFullBlock, RegistryShortBlock> tuple = new Tuple <RegistryFullBlock, RegistryShortBlock>(transactionsFullBlock, transactionsShortBlock);
return(tuple);
}
private void SendTransactionsBlocks(Tuple <RegistryFullBlock, RegistryShortBlock> tuple)
{
RegistryFullBlock transactionsFullBlock = tuple.Item1;
RegistryShortBlock transactionsShortBlock = tuple.Item2;
ISerializer fullBlockSerializer = _signatureSupportSerializersFactory.Create(transactionsFullBlock);
ISerializer shortBlockSerializer = _signatureSupportSerializersFactory.Create(transactionsShortBlock);
shortBlockSerializer.FillBodyAndRowBytes();
transactionsFullBlock.ShortBlockHash = _hashCalculation.CalculateHash(transactionsShortBlock.RawData);
_logger.Debug($"Sending FullBlock with {transactionsFullBlock.TransactionHeaders.Count} transactions and ShortBlock with {transactionsShortBlock.TransactionHeaderHashes.Count} hashes at round {transactionsFullBlock.BlockHeight}");
_tcpCommunicationService.PostMessage(_registryGroupState.SyncLayerNode, fullBlockSerializer);
_tcpCommunicationService.PostMessage(_registryGroupState.GetAllNeighbors(), shortBlockSerializer);
}
public RegistryShortBlock GetRegistryShortBlockByHash(ulong syncBlockHeight, ulong round, byte[] hash)
{
if (!_transactionsShortBlocks.ContainsKey(syncBlockHeight))
{
return(null);
}
if (!_transactionsShortBlocks[syncBlockHeight].ContainsKey(round))
{
return(null);
}
RegistryShortBlock registryShortBlock = _transactionsShortBlocks[syncBlockHeight][round].FirstOrDefault(s => _hashCalculation.CalculateHash(s.RawData).Equals32(hash));
return(registryShortBlock);
}
private void ProcessConfirmationBlock(RegistryConfirmationBlock confirmationBlock)
{
_registryGroupState.ToggleLastBlockConfirmationReceived();
RegistryShortBlock registryShortBlock = _registryMemPool.GetRegistryShortBlockByHash(confirmationBlock.SyncBlockHeight, confirmationBlock.BlockHeight, confirmationBlock.ReferencedBlockHash);
if (registryShortBlock != null)
{
if (registryShortBlock.TransactionHeaderHashes.Count > 0)
{
}
_registryMemPool.ClearByConfirmed(registryShortBlock);
}
//TODO: obtain Transactions Registry Short block from MemPool by hash given in confirmationBlock
//TODO: clear MemPool from Transaction Headers of confirmed Short Block
}
private RegistryShortBlock ProduceTransactionsShortBlock(RegistryFullBlock transactionsFullBlock)
{
RegistryShortBlock transactionsShortBlock = new RegistryShortBlock
{
SyncBlockHeight = transactionsFullBlock.SyncBlockHeight,
Nonce = transactionsFullBlock.Nonce,
PowHash = transactionsFullBlock.PowHash,
BlockHeight = transactionsFullBlock.BlockHeight,
WitnessStateKeys = transactionsFullBlock.StateWitnesses.Select(w => new WitnessStateKey {
PublicKey = w.Signer, Height = w.BlockHeight
}).ToArray(),
WitnessUtxoKeys = transactionsFullBlock.UtxoWitnesses.Select(w => new WitnessUtxoKey {
KeyImage = w.KeyImage
}).ToArray()
};
return(transactionsShortBlock);
}
private void SendTransactionsBlocks(RegistryFullBlock transactionsFullBlock, RegistryShortBlock transactionsShortBlock)
{
ISerializer fullBlockSerializer = _serializersFactory.Create(transactionsFullBlock);
ISerializer shortBlockSerializer = _serializersFactory.Create(transactionsShortBlock);
shortBlockSerializer.SerializeBody();
_nodeContext.SigningService.Sign(transactionsShortBlock);
shortBlockSerializer.SerializeFully();
transactionsFullBlock.ShortBlockHash = _hashCalculation.CalculateHash(transactionsShortBlock.RawData);
fullBlockSerializer.SerializeBody();
_nodeContext.SigningService.Sign(transactionsFullBlock);
_logger.Debug($"Sending FullBlock with {transactionsFullBlock.StateWitnesses.Length + transactionsFullBlock.UtxoWitnesses.Length} transactions and ShortBlock with {transactionsShortBlock.WitnessStateKeys.Length + transactionsShortBlock.WitnessUtxoKeys.Length} keys at round {transactionsFullBlock.BlockHeight}");
_tcpCommunicationService.PostMessage(_registryGroupState.SyncLayerNode, fullBlockSerializer);
_tcpCommunicationService.PostMessage(_registryGroupState.GetAllNeighbors(), shortBlockSerializer);
}
public void ClearByConfirmed(RegistryShortBlock transactionsShortBlock)
{
lock (_sync)
{
if (_transactionOrderByTransactionKey.ContainsKey(transactionsShortBlock.SyncBlockHeight))
{
IEnumerable <IKey> mutualTransactionKeys = _transactionOrderByTransactionKey[transactionsShortBlock.SyncBlockHeight].Keys.Where(k => transactionsShortBlock.TransactionHeaderHashes.Values.Contains(k)).ToList();
foreach (IKey transactionKey in mutualTransactionKeys)
{
_transactionKeyBySourceKeys[transactionsShortBlock.SyncBlockHeight].Remove(_transactionSourceKeyByTransactionKey[transactionsShortBlock.SyncBlockHeight][transactionKey]);
_transactionSourceKeyByTransactionKey[transactionsShortBlock.SyncBlockHeight].Remove(transactionKey);
_transactionRegisterBlocksOrdered[transactionsShortBlock.SyncBlockHeight].Remove(_transactionOrderByTransactionKey[transactionsShortBlock.SyncBlockHeight][transactionKey]);
_transactionOrderByTransactionKey[transactionsShortBlock.SyncBlockHeight].Remove(transactionKey);
_transactionsShortBlocks[transactionsShortBlock.SyncBlockHeight].Remove(transactionsShortBlock.BlockHeight);
}
}
}
}
private RegistryConfidenceBlock GetConfidence(RegistryShortBlock transactionsShortBlock)
{
_registryMemPool.EnqueueTransactionsShortBlock(transactionsShortBlock);
byte[] proof = _registryMemPool.GetConfidenceMask(transactionsShortBlock, out byte[] bitMask);
SynchronizationDescriptor synchronizationDescriptor = _synchronizationContext.LastBlockDescriptor;
RegistryConfidenceBlock transactionsRegistryConfidenceBlock = new RegistryConfidenceBlock()
{
SyncBlockHeight = transactionsShortBlock.SyncBlockHeight,
Nonce = transactionsShortBlock.Nonce,
PowHash = transactionsShortBlock.PowHash,
BlockHeight = transactionsShortBlock.BlockHeight,
ReferencedBlockHash = _defaulHashCalculation.CalculateHash(transactionsShortBlock.RawData),
BitMask = bitMask,
ConfidenceProof = proof
};
_logger.Debug($"BitMask of Confidence for RegistryShortBlock at round {transactionsShortBlock.BlockHeight} with {transactionsShortBlock.TransactionHeaderHashes.Count} hashes is {transactionsRegistryConfidenceBlock.BitMask.ToHexString()}");
return(transactionsRegistryConfidenceBlock);
}
public void RegistryShortBlockParserTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
byte[] body;
ushort expectedCount = 10;
Random random = new Random();
WitnessStateKey[] witnessStateKeys = new WitnessStateKey[expectedCount];
WitnessUtxoKey[] witnessUtxoKeys = new WitnessUtxoKey[expectedCount];
for (ushort i = 0; i < expectedCount; i++)
{
witnessStateKeys[i] = new WitnessStateKey {
PublicKey = new Key32(ConfidentialAssetsHelper.GetRandomSeed()), Height = (ulong)random.Next(0, int.MaxValue)
};
witnessUtxoKeys[i] = new WitnessUtxoKey {
KeyImage = new Key32(ConfidentialAssetsHelper.GetRandomSeed())
};
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)witnessStateKeys.Length);
bw.Write((ushort)witnessUtxoKeys.Length);
foreach (WitnessStateKey witnessStateKey in witnessStateKeys)
{
bw.Write(witnessStateKey.PublicKey.Value.ToArray());
bw.Write(witnessStateKey.Height);
}
foreach (WitnessUtxoKey witnessUtxoKey in witnessUtxoKeys)
{
bw.Write(witnessUtxoKey.KeyImage.Value.ToArray());
}
}
body = ms.ToArray();
}
byte[] packet = BinaryHelper.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_ShortBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryShortBlockParser registryFullBlockParser = new RegistryShortBlockParser(_identityKeyProvidersRegistry);
RegistryShortBlock block = (RegistryShortBlock)registryFullBlockParser.Parse(packet);
Assert.Equal(syncBlockHeight, block.SyncBlockHeight);
Assert.Equal(nonce, block.Nonce);
Assert.Equal(powHash, block.PowHash);
Assert.Equal(version, block.Version);
Assert.Equal(blockHeight, block.BlockHeight);
for (int i = 0; i < witnessStateKeys.Length; i++)
{
Assert.Equal(witnessStateKeys[i].PublicKey, block.WitnessStateKeys[i].PublicKey);
Assert.Equal(witnessStateKeys[i].Height, block.WitnessStateKeys[i].Height);
}
for (int i = 0; i < witnessUtxoKeys.Length; i++)
{
Assert.Equal(witnessUtxoKeys[i].KeyImage, block.WitnessUtxoKeys[i].KeyImage);
}
Assert.Equal(_publicKey, block.Signer.Value.ToArray());
Assert.Equal(expectedSignature, block.Signature.ToArray());
}
public void GetMostConfidentFullBlockTest()
{
List <RegistryFullBlock> registryFullBlocks = new List <RegistryFullBlock>();
List <RegistryShortBlock> registryShortBlocks = new List <RegistryShortBlock>();
Dictionary <IKey, int> votesPerShortBlockKey = new Dictionary <IKey, int>();
int fullBlockCount = 10;
int votersCount = 100;
ulong syncBlockHeight = 1;
ulong blockHeight = 12;
uint nonce = 0;
byte[] powHash = BinaryBuilder.GetPowHash(1234);
IHashCalculation hashCalculationTransactionKey = new MurMurHashCalculation();
IHashCalculation hashCalculationDefault = new Keccak256HashCalculation();
IHashCalculation hashCalculationMurMur = new MurMurHashCalculation();
ISerializersFactory signatureSupportSerializersFactory = Substitute.For <ISerializersFactory>();
IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
IIdentityKeyProvider identityKeyProviderTransactionKey = Substitute.For <IIdentityKeyProvider>();
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
ICryptoService cryptoService = GetRandomCryptoService();
ILoggerService loggerService = Substitute.For <ILoggerService>();
IStatesRepository statesRepository = Substitute.For <IStatesRepository>();
ISynchronizationContext synchronizationContext = new Wist.Core.Synchronization.SynchronizationContext(loggerService);
statesRepository.GetInstance <ISynchronizationContext>().ReturnsForAnyArgs(synchronizationContext);
identityKeyProviderTransactionKey.GetKey(null).ReturnsForAnyArgs(c => new Key16(c.ArgAt <Memory <byte> >(0)));
identityKeyProvidersRegistry.GetInstance("DefaultHash").Returns(new DefaultHashKeyProvider());
identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(identityKeyProviderTransactionKey);
hashCalculationsRepository.Create(HashType.Keccak256).Returns(hashCalculationDefault);
hashCalculationsRepository.Create(HashType.MurMur).Returns(hashCalculationMurMur);
signatureSupportSerializersFactory.Create(null).ReturnsForAnyArgs(c =>
{
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer(cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository);
registryShortBlockSerializer.Initialize(c.Arg <SignedBlockBase>());
return(registryShortBlockSerializer);
});
SyncRegistryMemPool syncRegistryMemPool = new SyncRegistryMemPool(signatureSupportSerializersFactory, hashCalculationsRepository, identityKeyProvidersRegistry, cryptoService, statesRepository, loggerService);
for (int i = 0; i < fullBlockCount; i++)
{
ICryptoService cryptoService1 = GetRandomCryptoService();
ushort expectedCount = 1000;
SortedList <ushort, ITransactionRegistryBlock> transactionHeaders = GetTransactionHeaders(syncBlockHeight, blockHeight, nonce, expectedCount);
SortedList <ushort, IKey> transactionHeaderKeys = GetTransactionHeaderKeys(hashCalculationTransactionKey, transactionHeaders);
RegistryShortBlock registryShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
TransactionHeaderHashes = transactionHeaderKeys
};
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer(cryptoService1, identityKeyProvidersRegistry, hashCalculationsRepository);
registryShortBlockSerializer.Initialize(registryShortBlock);
registryShortBlockSerializer.FillBodyAndRowBytes();
RegistryFullBlock registryFullBlock = new RegistryFullBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
TransactionHeaders = transactionHeaders,
ShortBlockHash = hashCalculationDefault.CalculateHash(registryShortBlock.RawData)
};
RegistryFullBlockSerializer serializer = new RegistryFullBlockSerializer(cryptoService1, identityKeyProvidersRegistry, hashCalculationsRepository);
serializer.Initialize(registryFullBlock);
serializer.FillBodyAndRowBytes();
registryFullBlocks.Add(registryFullBlock);
registryShortBlocks.Add(registryShortBlock);
}
foreach (RegistryFullBlock fullBlock in registryFullBlocks)
{
syncRegistryMemPool.AddCandidateBlock(fullBlock);
}
Random random = new Random();
for (int i = 0; i < votersCount; i++)
{
ICryptoService cryptoService2 = GetRandomCryptoService();
foreach (var registryShortBlock in registryShortBlocks)
{
byte[] hashBytes = hashCalculationDefault.CalculateHash(registryShortBlock.RawData);
Random randNum = new Random();
byte[] bitMask = Enumerable.Repeat(0, registryShortBlock.TransactionHeaderHashes.Count).Select(j => (byte)randNum.Next(0, 255)).ToArray();
byte[] expectedProof = Enumerable.Repeat(0, 16).Select(j => (byte)randNum.Next(0, 255)).ToArray();
IKey shortBlockKey = new Key32(hashBytes);
long vote = GetConfidence(bitMask);
if (!votesPerShortBlockKey.ContainsKey(shortBlockKey))
{
votesPerShortBlockKey.Add(shortBlockKey, (ushort)vote);
}
else
{
votesPerShortBlockKey[shortBlockKey] += (ushort)vote;
}
RegistryConfidenceBlock registryConfidenceBlock = new RegistryConfidenceBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
ReferencedBlockHash = hashBytes,
BitMask = bitMask,
ConfidenceProof = expectedProof
};
RegistryConfidenceBlockSerializer registryConfidenceBlockSerializer = new RegistryConfidenceBlockSerializer(cryptoService2, identityKeyProvidersRegistry, hashCalculationsRepository);
registryConfidenceBlockSerializer.Initialize(registryConfidenceBlock);
registryConfidenceBlockSerializer.FillBodyAndRowBytes();
syncRegistryMemPool.AddVotingBlock(registryConfidenceBlock);
}
}
IKey expectedMostConfidentKey = votesPerShortBlockKey.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).First();
RegistryFullBlock actualFullBlock = syncRegistryMemPool.GetMostConfidentFullBlock(blockHeight);
IKey actualMostConfidentKey = new Key32(actualFullBlock.ShortBlockHash);
Assert.Equal(expectedMostConfidentKey, actualMostConfidentKey);
}
public void RegistryShortBlockSerializerTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
byte[] body;
ushort expectedCount = 10;
Random random = new Random();
WitnessStateKey[] witnessStateKeys = new WitnessStateKey[expectedCount];
WitnessUtxoKey[] witnessUtxoKeys = new WitnessUtxoKey[expectedCount];
for (ushort i = 0; i < expectedCount; i++)
{
witnessStateKeys[i] = new WitnessStateKey {
PublicKey = new Key32(ConfidentialAssetsHelper.GetRandomSeed()), Height = (ulong)random.Next(0, int.MaxValue)
};
witnessUtxoKeys[i] = new WitnessUtxoKey {
KeyImage = new Key32(ConfidentialAssetsHelper.GetRandomSeed())
};
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)witnessStateKeys.Length);
bw.Write((ushort)witnessUtxoKeys.Length);
foreach (WitnessStateKey witnessStateKey in witnessStateKeys)
{
bw.Write(witnessStateKey.PublicKey.Value.ToArray());
bw.Write(witnessStateKey.Height);
}
foreach (WitnessUtxoKey witnessUtxoKey in witnessUtxoKeys)
{
bw.Write(witnessUtxoKey.KeyImage.Value.ToArray());
}
}
body = ms.ToArray();
}
byte[] expectedPacket = BinaryHelper.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_ShortBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryShortBlock block = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash,
BlockHeight = blockHeight,
WitnessStateKeys = witnessStateKeys,
WitnessUtxoKeys = witnessUtxoKeys
};
RegistryShortBlockSerializer serializer = new RegistryShortBlockSerializer();
serializer.Initialize(block);
serializer.SerializeBody();
_signingService.Sign(block);
byte[] actualPacket = serializer.GetBytes();
Trace.WriteLine(expectedPacket.ToHexString());
Trace.WriteLine(actualPacket.ToHexString());
Assert.Equal(expectedPacket, actualPacket);
}
public void GetMostConfidentFullBlockTest()
{
List <RegistryFullBlock> registryFullBlocks = new List <RegistryFullBlock>();
List <RegistryShortBlock> registryShortBlocks = new List <RegistryShortBlock>();
Dictionary <IKey, int> votesPerShortBlockKey = new Dictionary <IKey, int>();
int fullBlockCount = 10;
int votersCount = 100;
ulong syncBlockHeight = 1;
ulong blockHeight = 12;
uint nonce = 0;
byte[] powHash = BinaryHelper.GetPowHash(1234);
IHashCalculation hashCalculationTransactionKey = new MurMurHashCalculation();
IHashCalculation hashCalculationDefault = new Keccak256HashCalculation();
IHashCalculation hashCalculationMurMur = new MurMurHashCalculation();
ISerializersFactory serializersFactory = Substitute.For <ISerializersFactory>();
IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
IIdentityKeyProvider identityKeyProviderTransactionKey = Substitute.For <IIdentityKeyProvider>();
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
ISigningService signingService = GetRandomCryptoService();
ILoggerService loggerService = Substitute.For <ILoggerService>();
IStatesRepository statesRepository = Substitute.For <IStatesRepository>();
ISynchronizationContext synchronizationContext = new Wist.Core.Synchronization.SynchronizationContext(loggerService);
statesRepository.GetInstance <ISynchronizationContext>().ReturnsForAnyArgs(synchronizationContext);
identityKeyProviderTransactionKey.GetKey(null).ReturnsForAnyArgs(c => new Key16(c.ArgAt <Memory <byte> >(0)));
identityKeyProvidersRegistry.GetInstance("DefaultHash").Returns(new DefaultHashKeyProvider());
identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().Returns(identityKeyProviderTransactionKey);
hashCalculationsRepository.Create(HashType.Keccak256).Returns(hashCalculationDefault);
hashCalculationsRepository.Create(HashType.MurMur).Returns(hashCalculationMurMur);
serializersFactory.Create(null).ReturnsForAnyArgs(c =>
{
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer();
registryShortBlockSerializer.Initialize(c.Arg <SignedPacketBase>());
return(registryShortBlockSerializer);
});
SyncRegistryMemPool syncRegistryMemPool = new SyncRegistryMemPool(loggerService, hashCalculationsRepository);
for (int i = 0; i < fullBlockCount; i++)
{
ISigningService signingService1 = GetRandomCryptoService();
ushort expectedCount = 1000;
SortedList <ushort, RegistryRegisterBlock> transactionHeaders = GetTransactionHeaders(syncBlockHeight, blockHeight, nonce, expectedCount);
WitnessStateKey[] transactionHeaderKeys = GetTransactionHeaderKeys(transactionHeaders);
RegistryShortBlock registryShortBlock = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
WitnessStateKeys = transactionHeaderKeys
};
RegistryShortBlockSerializer registryShortBlockSerializer = new RegistryShortBlockSerializer();
registryShortBlockSerializer.Initialize(registryShortBlock);
registryShortBlockSerializer.SerializeBody();
signingService1.Sign(registryShortBlock);
registryShortBlockSerializer.SerializeFully();
RegistryFullBlock registryFullBlock = new RegistryFullBlock
{
SyncBlockHeight = syncBlockHeight,
BlockHeight = blockHeight,
Nonce = nonce,
PowHash = powHash,
StateWitnesses = transactionHeaders.Values.ToArray(),
ShortBlockHash = hashCalculationDefault.CalculateHash(registryShortBlock.RawData)
};
RegistryFullBlockSerializer serializer = new RegistryFullBlockSerializer();
serializer.Initialize(registryFullBlock);
serializer.SerializeBody();
signingService.Sign(registryFullBlock);
serializer.SerializeFully();
registryFullBlocks.Add(registryFullBlock);
registryShortBlocks.Add(registryShortBlock);
}
foreach (RegistryFullBlock fullBlock in registryFullBlocks)
{
syncRegistryMemPool.AddCandidateBlock(fullBlock);
}
IKey expectedMostConfidentKey = votesPerShortBlockKey.OrderByDescending(kv => kv.Value).Select(kv => kv.Key).First();
IEnumerable <RegistryFullBlock> actualFullBlocks = syncRegistryMemPool.GetRegistryBlocks();
}
public void RegistryShortBlockParserTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryBuilder.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
byte[] body;
ushort expectedCount = 10;
SortedList <ushort, IKey> transactionHeaders = new SortedList <ushort, IKey>();
for (ushort i = 0; i < expectedCount; i++)
{
transactionHeaders.Add(i, new Key16(BinaryBuilder.GetTransactionKeyHash(i)));
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)transactionHeaders.Count);
foreach (ushort order in transactionHeaders.Keys)
{
bw.Write(order);
bw.Write(transactionHeaders[order].Value.ToArray());
}
}
body = ms.ToArray();
}
byte[] packet = BinaryBuilder.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_ShortBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryShortBlockParser registryFullBlockParser = new RegistryShortBlockParser(_identityKeyProvidersRegistry, _hashCalculationRepository);
RegistryShortBlock block = (RegistryShortBlock)registryFullBlockParser.Parse(packet);
Assert.Equal(syncBlockHeight, block.SyncBlockHeight);
Assert.Equal(nonce, block.Nonce);
Assert.Equal(powHash, block.PowHash);
Assert.Equal(version, block.Version);
Assert.Equal(blockHeight, block.BlockHeight);
foreach (var item in transactionHeaders)
{
Assert.True(block.TransactionHeaderHashes.ContainsKey(item.Key));
Assert.Equal(item.Value, block.TransactionHeaderHashes[item.Key]);
}
Assert.Equal(_publicKey, block.Signer.Value.ToArray());
Assert.Equal(expectedSignature, block.Signature.ToArray());
}
public void MemPool_ContainsXItems_ConfidenceLevelOnAll()
{
SynchronizationDescriptor synchronizationDescriptor = new SynchronizationDescriptor(1, new byte[Globals.DEFAULT_HASH_SIZE], DateTime.Now, DateTime.Now, 1);
IHash transactionKeyHash = HashFactory.Hash128.CreateMurmur3_128();
ILogger logger = Substitute.For <ILogger>();
ILoggerService loggerService = Substitute.For <ILoggerService>();
IIdentityKeyProvider identityKeyProvider = new TransactionRegistryKeyProvider();
IIdentityKeyProvidersRegistry identityKeyProvidersRegistry = Substitute.For <IIdentityKeyProvidersRegistry>();
IHashCalculationsRepository hashCalculationsRepository = Substitute.For <IHashCalculationsRepository>();
ICryptoService cryptoService = Substitute.For <ICryptoService>();
SynchronizationContext synchronizationContext = new SynchronizationContext(loggerService);
synchronizationContext.UpdateLastSyncBlockDescriptor(synchronizationDescriptor);
IStatesRepository statesRepository = Substitute.For <IStatesRepository>();
hashCalculationsRepository.Create(HashType.MurMur).Returns(new MurMurHashCalculation());
logger.WhenForAnyArgs(l => l.Error(null)).DoNotCallBase();
logger.WhenForAnyArgs(l => l.Warning(null)).DoNotCallBase();
logger.WhenForAnyArgs(l => l.Info(null)).DoNotCallBase();
loggerService.GetLogger(null).Returns(logger);
identityKeyProvidersRegistry.GetTransactionsIdenityKeyProvider().ReturnsForAnyArgs(identityKeyProvider);
statesRepository.GetInstance <ISynchronizationContext>().Returns(synchronizationContext);
byte[] privateKey = CryptoHelper.GetRandomSeed();
Ed25519.KeyPairFromSeed(out byte[] publicKey, out byte[] expandedPrivateKey, privateKey);
cryptoService.ComputeTransactionKey(new Memory <byte>()).ReturnsForAnyArgs(c => transactionKeyHash.ComputeBytes(c.Arg <Memory <byte> >().ToArray()).GetBytes());
cryptoService.ComputeTransactionKey(new byte[0]).ReturnsForAnyArgs(c => transactionKeyHash.ComputeBytes(c.Arg <byte[]>()).GetBytes());
cryptoService.Sign(null).ReturnsForAnyArgs(c => Ed25519.Sign(c.Arg <byte[]>(), expandedPrivateKey));
cryptoService.PublicKey.ReturnsForAnyArgs(new Key32(publicKey));
TransactionRegistryMemPool transactionRegistryMemPool = new TransactionRegistryMemPool(loggerService, identityKeyProvidersRegistry, cryptoService, statesRepository, new TransactionsRegistryHelper(cryptoService, identityKeyProvidersRegistry), hashCalculationsRepository);
SortedList <ushort, RegistryRegisterBlock> expectedBlocks = new SortedList <ushort, RegistryRegisterBlock>();
ulong[] heights = new ulong[] { 1, 2, 2, 5, 4, 3, 4, 3, 4, 5, 3 };
HashSet <ulong> addedHeights = new HashSet <ulong>();
ushort order = 0;
for (ulong i = 0; i < (ulong)heights.Length; i++)
{
RegistryRegisterBlock transactionRegisterBlock = PacketsBuilder.GetTransactionRegisterBlock(synchronizationContext.LastBlockDescriptor.BlockHeight, 1, null, heights[i],
PacketType.Transactional, BlockTypes.Transaction_TransferFunds, new byte[Globals.POW_HASH_SIZE], new byte[Globals.DEFAULT_HASH_SIZE], privateKey);
RegistryRegisterBlockSerializer serializer = new RegistryRegisterBlockSerializer(cryptoService, identityKeyProvidersRegistry, hashCalculationsRepository);
serializer.Initialize(transactionRegisterBlock);
serializer.FillBodyAndRowBytes();
if (!addedHeights.Contains(heights[i]))
{
expectedBlocks.Add(order++, transactionRegisterBlock);
addedHeights.Add(heights[i]);
}
transactionRegistryMemPool.EnqueueTransactionRegisterBlock(transactionRegisterBlock);
}
RegistryShortBlock transactionsShortBlockAll = PacketsBuilder.GetTransactionsShortBlock(1, 1, null, 1, 1, expectedBlocks.Values, privateKey, new TransactionsRegistryHelper(cryptoService, identityKeyProvidersRegistry));
RegistryShortBlock transactionsShortBlockOneLess = PacketsBuilder.GetTransactionsShortBlock(1, 1, null, 1, 1, expectedBlocks.Values.Skip(1), privateKey, new TransactionsRegistryHelper(cryptoService, identityKeyProvidersRegistry));
byte[] bitMaskAll, bitMaskOneLess;
byte[] confidenceProofAll = transactionRegistryMemPool.GetConfidenceMask(transactionsShortBlockAll, out bitMaskAll);
byte[] confidenceProofOneLess = transactionRegistryMemPool.GetConfidenceMask(transactionsShortBlockOneLess, out bitMaskOneLess);
long expectedConfidenceAll = expectedBlocks.Count;
long expectedConfidenceOneLess = expectedBlocks.Count - 1;
long actualConfidenceAll = GetConfidence(bitMaskAll);
long actualConfidenceOneLess = GetConfidence(bitMaskOneLess);
Assert.Equal(expectedConfidenceAll, actualConfidenceAll);
Assert.Equal(expectedConfidenceOneLess, actualConfidenceOneLess);
}
public void RegistryShortBlockSerializerTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryBuilder.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
byte[] body;
ushort expectedCount = 10;
SortedList <ushort, IKey> transactionHeaders = new SortedList <ushort, IKey>();
for (ushort i = 0; i < expectedCount; i++)
{
transactionHeaders.Add(i, new Key16(BinaryBuilder.GetTransactionKeyHash(i)));
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)transactionHeaders.Count);
foreach (ushort order in transactionHeaders.Keys)
{
bw.Write(order);
bw.Write(transactionHeaders[order].Value.ToArray());
}
}
body = ms.ToArray();
}
byte[] expectedPacket = BinaryBuilder.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_ShortBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryShortBlock block = new RegistryShortBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash,
BlockHeight = blockHeight,
TransactionHeaderHashes = transactionHeaders
};
RegistryShortBlockSerializer serializer = new RegistryShortBlockSerializer(_cryptoService, _identityKeyProvidersRegistry, _hashCalculationRepository);
serializer.Initialize(block);
byte[] actualPacket = serializer.GetBytes();
Trace.WriteLine(expectedPacket.ToHexString());
Trace.WriteLine(actualPacket.ToHexString());
Assert.Equal(expectedPacket, actualPacket);
}
