protected override Memory <byte> ParseUtxoConfidential(ushort version, Memory <byte> spanBody, out UtxoConfidentialBase utxoConfidentialBase)
{
if (version == 1)
{
int readBytes = 0;
PacketType referencedPacketType = (PacketType)BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span);
readBytes += 2;
ushort referencedBlockType = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += 2;
byte[] referencedBlockHash = spanBody.Slice(readBytes, Globals.DEFAULT_HASH_SIZE).ToArray();
readBytes += Globals.DEFAULT_HASH_SIZE;
RegistryRegisterUtxoConfidential registryRegisterUtxoConfidentialBlock = new RegistryRegisterUtxoConfidential
{
ReferencedPacketType = referencedPacketType,
ReferencedBlockType = referencedBlockType,
ReferencedBodyHash = referencedBlockHash,
};
utxoConfidentialBase = registryRegisterUtxoConfidentialBlock;
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
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 bool EnqueueTransactionWitness(RegistryRegisterUtxoConfidential transactionWitness)
{
lock (_sync)
{
if (!_transactionUtxoWitnessesByKeyImage.ContainsKey(transactionWitness.KeyImage))
{
_transactionUtxoWitnessesByKeyImage.Add(transactionWitness.KeyImage, transactionWitness);
_transactionUtxoWitnesses.Add(transactionWitness);
return(true);
}
}
return(false);
}
protected override Memory <byte> ParseSigned(ushort version, Memory <byte> spanBody, out SignedPacketBase syncedBlockBase)
{
if (version == 1)
{
int readBytes = 0;
RegistryFullBlock transactionsFullBlock = new RegistryFullBlock();
ushort stateWitnessesCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += sizeof(ushort);
ushort utxoWitnessesCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += sizeof(ushort);
transactionsFullBlock.StateWitnesses = new RegistryRegisterBlock[stateWitnessesCount];
transactionsFullBlock.UtxoWitnesses = new RegistryRegisterUtxoConfidential[utxoWitnessesCount];
for (int i = 0; i < stateWitnessesCount; i++)
{
RegistryRegisterBlock block = (RegistryRegisterBlock)_registryRegisterBlockParser.Parse(spanBody.Slice(readBytes));
readBytes += block?.RawData.Length ?? 0;
transactionsFullBlock.StateWitnesses[i] = block;
}
for (int i = 0; i < utxoWitnessesCount; i++)
{
RegistryRegisterUtxoConfidential block = (RegistryRegisterUtxoConfidential)_registryRegisterUtxoConfidentialBlockParser.Parse(spanBody.Slice(readBytes));
readBytes += block?.RawData.Length ?? 0;
transactionsFullBlock.UtxoWitnesses[i] = block;
}
transactionsFullBlock.ShortBlockHash = spanBody.Slice(readBytes, Globals.DEFAULT_HASH_SIZE).ToArray();
readBytes += Globals.DEFAULT_HASH_SIZE;
syncedBlockBase = transactionsFullBlock;
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
public void RegistryFullBlockParserTest()
{
IBlockParser blockParser = new RegistryRegisterBlockParser(_identityKeyProvidersRegistry);
_blockParsersRepository.GetInstance(0).ReturnsForAnyArgs(blockParser);
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
PacketType expectedReferencedPacketType = PacketType.Transactional;
ushort expectedReferencedBlockType = BlockTypes.Transaction_TransferFunds;
byte[] body;
ushort expectedCount = 1;
byte[] expectedShortBlockHash;
RegistryRegisterBlock[] stateWitnesses = new RegistryRegisterBlock[expectedCount];
RegistryRegisterUtxoConfidential[] utxoWitnesses = new RegistryRegisterUtxoConfidential[expectedCount];
for (ushort i = 0; i < expectedCount; i++)
{
RegistryRegisterBlock registryRegisterBlock = new RegistryRegisterBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce + i,
PowHash = BinaryHelper.GetPowHash(1234 + i),
BlockHeight = blockHeight,
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
ReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643 + i),
ReferencedTarget = BinaryHelper.GetDefaultHash(BinaryHelper.GetRandomPublicKey())
};
RegistryRegisterBlockSerializer serializer1 = new RegistryRegisterBlockSerializer();
serializer1.Initialize(registryRegisterBlock);
serializer1.SerializeBody();
_signingService.Sign(registryRegisterBlock);
serializer1.SerializeFully();
stateWitnesses[i] = registryRegisterBlock;
RegistryRegisterUtxoConfidential registryRegisterUtxoConfidentialBlock = new RegistryRegisterUtxoConfidential
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce + i,
PowHash = BinaryHelper.GetPowHash(1234 + i),
KeyImage = new Key32(ConfidentialAssetsHelper.GetRandomSeed()),
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
ReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643 + i),
DestinationKey = ConfidentialAssetsHelper.GetRandomSeed(),
DestinationKey2 = ConfidentialAssetsHelper.GetRandomSeed(),
TransactionPublicKey = ConfidentialAssetsHelper.GetRandomSeed(),
PublicKeys = new Key32[] { new Key32(ConfidentialAssetsHelper.GetRandomSeed()), new Key32(ConfidentialAssetsHelper.GetRandomSeed()), new Key32(ConfidentialAssetsHelper.GetRandomSeed()) },
Signatures = new RingSignature[]
{
new RingSignature {
R = ConfidentialAssetsHelper.GetRandomSeed(), C = ConfidentialAssetsHelper.GetRandomSeed()
},
new RingSignature {
R = ConfidentialAssetsHelper.GetRandomSeed(), C = ConfidentialAssetsHelper.GetRandomSeed()
},
new RingSignature {
R = ConfidentialAssetsHelper.GetRandomSeed(), C = ConfidentialAssetsHelper.GetRandomSeed()
}
}
};
RegistryRegisterUtxoConfidentialBlockSerializer serializer2 = new RegistryRegisterUtxoConfidentialBlockSerializer();
serializer2.Initialize(registryRegisterUtxoConfidentialBlock);
serializer2.SerializeFully();
utxoWitnesses[i] = registryRegisterUtxoConfidentialBlock;
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)stateWitnesses.Length);
bw.Write((ushort)utxoWitnesses.Length);
foreach (RegistryRegisterBlock witness in stateWitnesses)
{
bw.Write(witness.RawData.ToArray());
}
foreach (RegistryRegisterUtxoConfidential witness in utxoWitnesses)
{
bw.Write(witness.RawData.ToArray());
}
expectedShortBlockHash = BinaryHelper.GetDefaultHash(1111);
bw.Write(expectedShortBlockHash);
}
body = ms.ToArray();
}
byte[] packet = BinaryHelper.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_FullBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryFullBlockParser registryFullBlockParser = new RegistryFullBlockParser(_identityKeyProvidersRegistry);
RegistryFullBlock block = (RegistryFullBlock)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 < expectedCount; i++)
{
RegistryRegisterBlock registryRegisterBlock = block.StateWitnesses[i];
Assert.Equal(stateWitnesses[i].PacketType, registryRegisterBlock.PacketType);
Assert.Equal(stateWitnesses[i].SyncBlockHeight, registryRegisterBlock.SyncBlockHeight);
Assert.Equal(stateWitnesses[i].Nonce, registryRegisterBlock.Nonce);
Assert.Equal(stateWitnesses[i].PowHash, registryRegisterBlock.PowHash);
Assert.Equal(stateWitnesses[i].BlockHeight, registryRegisterBlock.BlockHeight);
Assert.Equal(stateWitnesses[i].BlockType, registryRegisterBlock.BlockType);
Assert.Equal(stateWitnesses[i].ReferencedPacketType, registryRegisterBlock.ReferencedPacketType);
Assert.Equal(stateWitnesses[i].ReferencedBlockType, registryRegisterBlock.ReferencedBlockType);
Assert.Equal(stateWitnesses[i].ReferencedBodyHash, registryRegisterBlock.ReferencedBodyHash);
Assert.Equal(stateWitnesses[i].ReferencedTarget, registryRegisterBlock.ReferencedTarget);
Assert.Equal(stateWitnesses[i].Signature.ToArray(), registryRegisterBlock.Signature.ToArray());
Assert.Equal(stateWitnesses[i].Signer, registryRegisterBlock.Signer);
RegistryRegisterUtxoConfidential registryRegisterUtxoConfidentialBlock = block.UtxoWitnesses[i];
Assert.Equal(utxoWitnesses[i].PacketType, registryRegisterUtxoConfidentialBlock.PacketType);
Assert.Equal(utxoWitnesses[i].SyncBlockHeight, registryRegisterUtxoConfidentialBlock.SyncBlockHeight);
Assert.Equal(utxoWitnesses[i].Nonce, registryRegisterUtxoConfidentialBlock.Nonce);
Assert.Equal(utxoWitnesses[i].PowHash, registryRegisterUtxoConfidentialBlock.PowHash);
Assert.Equal(utxoWitnesses[i].KeyImage, registryRegisterUtxoConfidentialBlock.KeyImage);
Assert.Equal(utxoWitnesses[i].BlockType, registryRegisterUtxoConfidentialBlock.BlockType);
Assert.Equal(utxoWitnesses[i].ReferencedPacketType, registryRegisterUtxoConfidentialBlock.ReferencedPacketType);
Assert.Equal(utxoWitnesses[i].ReferencedBlockType, registryRegisterUtxoConfidentialBlock.ReferencedBlockType);
Assert.Equal(utxoWitnesses[i].DestinationKey2, registryRegisterUtxoConfidentialBlock.DestinationKey2);
Assert.Equal(utxoWitnesses[i].ReferencedBodyHash, registryRegisterUtxoConfidentialBlock.ReferencedBodyHash);
Assert.Equal(utxoWitnesses[i].DestinationKey, registryRegisterUtxoConfidentialBlock.DestinationKey);
}
Assert.Equal(expectedShortBlockHash, block.ShortBlockHash);
Assert.Equal(_publicKey, block.Signer.Value.ToArray());
Assert.Equal(expectedSignature, block.Signature.ToArray());
}
public void RegistryRegisterUtxoConfidentialBlockParserTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
byte[] keyImage = ConfidentialAssetsHelper.GetRandomSeed();
byte[] destinationKey = ConfidentialAssetsHelper.GetRandomSeed();
byte[] transactionPublicKey = ConfidentialAssetsHelper.GetRandomSeed();
PacketType expectedReferencedPacketType = PacketType.Transactional;
ushort expectedReferencedBlockType = BlockTypes.Transaction_TransferFunds;
byte[] destinationKey2 = ConfidentialAssetsHelper.GetRandomSeed();
byte[] expectedReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643);
int ringSize = 3;
int outputIndex = 0;
byte[][] secretKeys = new byte[ringSize][];
byte[][] pubkeys = new byte[ringSize][];
byte[] body;
for (int i = 0; i < ringSize; i++)
{
pubkeys[i] = BinaryHelper.GetRandomPublicKey(out secretKeys[i]);
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)expectedReferencedPacketType);
bw.Write(expectedReferencedBlockType);
bw.Write(expectedReferencedBodyHash);
}
body = ms.ToArray();
}
byte[] packet = BinaryHelper.GetUtxoConfidentialPacket(
PacketType.Registry, syncBlockHeight, nonce, powHash, version,
BlockTypes.Registry_RegisterUtxoConfidential, keyImage, destinationKey, destinationKey2, transactionPublicKey, body, pubkeys, secretKeys[outputIndex], outputIndex, out RingSignature[] expectedSignatures);
RegistryRegisterUtxoConfidentialBlockParser registryRegisterBlockParser = new RegistryRegisterUtxoConfidentialBlockParser(_identityKeyProvidersRegistry);
RegistryRegisterUtxoConfidential block = (RegistryRegisterUtxoConfidential)registryRegisterBlockParser.Parse(packet);
Assert.Equal(syncBlockHeight, block.SyncBlockHeight);
Assert.Equal(nonce, block.Nonce);
Assert.Equal(powHash, block.PowHash);
Assert.Equal(version, block.Version);
Assert.Equal(expectedReferencedPacketType, block.ReferencedPacketType);
Assert.Equal(expectedReferencedBlockType, block.ReferencedBlockType);
Assert.Equal(destinationKey2, block.DestinationKey2);
Assert.Equal(expectedReferencedBodyHash, block.ReferencedBodyHash);
Assert.Equal(new Key32(keyImage), block.KeyImage);
Assert.Equal(destinationKey, block.DestinationKey);
Assert.Equal(transactionPublicKey, block.TransactionPublicKey);
}
public void RegistryFullBlockSerializerTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
ulong blockHeight = 9;
byte[] prevHash = null;
PacketType expectedReferencedPacketType = PacketType.Transactional;
ushort expectedReferencedBlockType = BlockTypes.Transaction_TransferFunds;
byte[] expectedReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643);
byte[] expectedTarget = BinaryHelper.GetDefaultHash(BinaryHelper.GetRandomPublicKey());
byte[] body;
ushort expectedCount = 1000;
RegistryRegisterBlock[] stateWitnesses = new RegistryRegisterBlock[expectedCount];
RegistryRegisterUtxoConfidential[] utxoWitnesses = new RegistryRegisterUtxoConfidential[expectedCount];
for (ushort i = 0; i < expectedCount; i++)
{
RegistryRegisterBlock registryRegisterBlock = new RegistryRegisterBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce + i,
PowHash = BinaryHelper.GetPowHash(1234 + i),
BlockHeight = blockHeight,
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
ReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643 + i),
ReferencedTarget = BinaryHelper.GetDefaultHash(BinaryHelper.GetRandomPublicKey())
};
RegistryRegisterBlockSerializer serializer1 = new RegistryRegisterBlockSerializer();
serializer1.Initialize(registryRegisterBlock);
serializer1.SerializeBody();
_signingService.Sign(registryRegisterBlock);
serializer1.SerializeFully();
stateWitnesses[i] = registryRegisterBlock;
RegistryRegisterUtxoConfidential registryRegisterUtxoConfidentialBlock = new RegistryRegisterUtxoConfidential
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce + i,
PowHash = BinaryHelper.GetPowHash(1234 + i),
DestinationKey = ConfidentialAssetsHelper.GetRandomSeed(),
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
DestinationKey2 = ConfidentialAssetsHelper.GetRandomSeed(),
ReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643 + i),
KeyImage = new Key32(ConfidentialAssetsHelper.GetRandomSeed()),
TransactionPublicKey = ConfidentialAssetsHelper.GetRandomSeed(),
PublicKeys = new IKey[] { new Key32(ConfidentialAssetsHelper.GetRandomSeed()), new Key32(ConfidentialAssetsHelper.GetRandomSeed()), new Key32(ConfidentialAssetsHelper.GetRandomSeed()) },
Signatures = new RingSignature[]
{
new RingSignature {
C = ConfidentialAssetsHelper.GetRandomSeed(), R = ConfidentialAssetsHelper.GetRandomSeed()
},
new RingSignature {
C = ConfidentialAssetsHelper.GetRandomSeed(), R = ConfidentialAssetsHelper.GetRandomSeed()
},
new RingSignature {
C = ConfidentialAssetsHelper.GetRandomSeed(), R = ConfidentialAssetsHelper.GetRandomSeed()
}
}
};
RegistryRegisterUtxoConfidentialBlockSerializer serializer2 = new RegistryRegisterUtxoConfidentialBlockSerializer();
serializer2.Initialize(registryRegisterUtxoConfidentialBlock);
serializer2.SerializeFully();
utxoWitnesses[i] = registryRegisterUtxoConfidentialBlock;
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)stateWitnesses.Length);
bw.Write((ushort)utxoWitnesses.Length);
foreach (RegistryRegisterBlock witness in stateWitnesses)
{
bw.Write(witness.RawData.ToArray());
}
foreach (RegistryRegisterUtxoConfidential witness in utxoWitnesses)
{
bw.Write(witness.RawData.ToArray());
}
bw.Write(BinaryHelper.GetDefaultHash(1111));
}
body = ms.ToArray();
}
byte[] expectedPacket = BinaryHelper.GetSignedPacket(
PacketType.Registry,
syncBlockHeight,
nonce, powHash, version,
BlockTypes.Registry_FullBlock, blockHeight, prevHash, body, _privateKey, out byte[] expectedSignature);
RegistryFullBlock block = new RegistryFullBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash,
BlockHeight = blockHeight,
StateWitnesses = stateWitnesses,
UtxoWitnesses = utxoWitnesses,
ShortBlockHash = BinaryHelper.GetDefaultHash(1111)
};
RegistryFullBlockSerializer serializer = new RegistryFullBlockSerializer();
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 RegistryRegisterUtxoConfidentialBlockSerializerTest()
{
ulong syncBlockHeight = 1;
uint nonce = 4;
byte[] powHash = BinaryHelper.GetPowHash(1234);
ushort version = 1;
byte[] keyImage = ConfidentialAssetsHelper.GetRandomSeed();
byte[] destinationKey = ConfidentialAssetsHelper.GetRandomSeed();
byte[] destinationKey2 = ConfidentialAssetsHelper.GetRandomSeed();
byte[] transactionPublicKey = ConfidentialAssetsHelper.GetRandomSeed();
int ringSize = 3;
int outputIndex = 0;
byte[][] secretKeys = new byte[ringSize][];
byte[][] pubkeys = new byte[ringSize][];
PacketType expectedReferencedPacketType = PacketType.Transactional;
ushort expectedReferencedBlockType = BlockTypes.Transaction_TransferFunds;
byte[] expectedReferencedBodyHash = BinaryHelper.GetDefaultHash(473826643);
byte[] expectedTarget = BinaryHelper.GetDefaultHash(BinaryHelper.GetRandomPublicKey());
byte[] body;
for (int i = 0; i < ringSize; i++)
{
pubkeys[i] = BinaryHelper.GetRandomPublicKey(out secretKeys[i]);
}
using (MemoryStream ms = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(ms))
{
bw.Write((ushort)expectedReferencedPacketType);
bw.Write(expectedReferencedBlockType);
bw.Write(expectedReferencedBodyHash);
}
body = ms.ToArray();
}
byte[] expectedPacket = BinaryHelper.GetUtxoConfidentialPacket(
PacketType.Registry, syncBlockHeight, nonce, powHash, version,
BlockTypes.Registry_RegisterUtxoConfidential, keyImage,
destinationKey, destinationKey2, transactionPublicKey, body, pubkeys, secretKeys[outputIndex], outputIndex, out RingSignature[] expectedSignatures);
RegistryRegisterUtxoConfidential block = new RegistryRegisterUtxoConfidential
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash,
KeyImage = new Key32(keyImage),
DestinationKey = destinationKey,
DestinationKey2 = destinationKey2,
TransactionPublicKey = transactionPublicKey,
ReferencedPacketType = expectedReferencedPacketType,
ReferencedBlockType = expectedReferencedBlockType,
ReferencedBodyHash = expectedReferencedBodyHash,
PublicKeys = pubkeys.Select(p => new Key32(p)).ToArray(),
Signatures = expectedSignatures
};
RegistryRegisterUtxoConfidentialBlockSerializer serializer = new RegistryRegisterUtxoConfidentialBlockSerializer();
serializer.Initialize(block);
byte[] actualPacket = serializer.GetBytes();
Trace.WriteLine(expectedPacket.ToHexString());
Trace.WriteLine(actualPacket.ToHexString());
Assert.Equal(expectedPacket, actualPacket);
}
