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);
}
private static WitnessStateKey[] GetTransactionHeaderKeys(SortedList <ushort, RegistryRegisterBlock> transactionHeaders)
{
WitnessStateKey[] transactionHeaderKeys = new WitnessStateKey[transactionHeaders.Count];
foreach (ushort order in transactionHeaders.Keys)
{
RegistryRegisterBlock registryRegisterBlock = transactionHeaders[order];
WitnessStateKey key = new WitnessStateKey {
PublicKey = registryRegisterBlock.Signer, Height = registryRegisterBlock.BlockHeight
};
transactionHeaderKeys[order] = key;
}
return(transactionHeaderKeys);
}
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 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);
}
