/// <summary>
/// The get subtree by index.
/// </summary>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="MerkleSubTree"/>.
/// </returns>
public MerkleSubTree GetSubtreeByIndex(int index)
{
if (this.Size == 1)
{
return(new MerkleSubTree {
Key = this.Root.LeftNode.Key, Leaves = new List <MerkleNode>()
});
}
var leaves = new List <MerkleNode>();
var node = this.Root;
AbstractPrivateKey key = null;
var size = this.Size;
if (index < size)
{
while (node != null)
{
if (node.LeftNode == null)
{
key = node.Key;
break;
}
size = node.LeftNode.Size;
if (index < size)
{
leaves.Add(node.RightNode ?? node.LeftNode);
node = node.LeftNode;
}
else
{
leaves.Add(node.LeftNode);
node = node.RightNode;
index -= size;
}
}
}
leaves.Reverse();
return(new MerkleSubTree
{
Key = key,
Leaves = leaves
});
}
/// <inheritdoc />
public List <Fragment> Generate(AbstractPrivateKey privateKey, Hash hash)
{
var result = new List <Fragment>();
var normalizedHash = Hash.Normalize(hash);
var i = 0;
var chunks = privateKey.GetChunks(AbstractPrivateKey.ChunkLength);
foreach (var chunk in chunks)
{
var normalizedHashChunk = normalizedHash.Skip((i % Converter.Radix) * 27).Take(27).ToArray();
var signatureFragmentTrits = chunk.ToTrits();
var finalizedSignatureFragmentTrits = new List <int>();
var count = chunk.GetChunks(Hash.Length).Count;
for (var j = 0; j < count; j++)
{
var buffer = signatureFragmentTrits.Skip(j * Constants.TritHashLength).Take(Constants.TritHashLength).ToArray();
for (var k = 0; k < Hash.MaxTryteValue - normalizedHashChunk[j]; k++)
{
this.Curl.Reset();
this.Curl.Absorb(buffer);
this.Curl.Squeeze(buffer);
}
finalizedSignatureFragmentTrits.AddRange(buffer);
}
result.Add(new Fragment(Converter.TritsToTrytes(finalizedSignatureFragmentTrits.ToArray())));
i++;
}
return(result);
}
/// <inheritdoc />
public Address GetAddress(AbstractPrivateKey privateKey)
{
throw new System.NotImplementedException();
}
/// <inheritdoc />
public async Task <List <Fragment> > GenerateAsync(AbstractPrivateKey privateKey, Hash hash)
{
return(await Task.Run(() => this.Generate(privateKey, hash)));
}
/// <inheritdoc />
public Address GetAddress(AbstractPrivateKey privateKey)
{
return(null);
}
protected async Task <TryteString> CreateSignedPublicKeyPayloadAsync(IAsymmetricKey publicKey, TryteString requestAddress, AbstractPrivateKey addressPrivateKey)
{
var payload = new PublicKeyPayload(publicKey, requestAddress);
var signature = await this.SignatureGenerator.GenerateAsync(addressPrivateKey, payload.Hash);
var signedPayload = (TryteString)payload;
foreach (var fragment in signature)
{
signedPayload = signedPayload.Concat(fragment);
}
return(signedPayload);
}
/// <inheritdoc />
public async Task <List <Fragment> > GenerateAsync(AbstractPrivateKey privateKey, Hash hash)
{
return(new List <Fragment> {
new Fragment("STUBFRAGMENTSIGNATURE")
});
}
