public override Task <TransactionalBlockEssense> GetLastTransactionalBlock(TransactionalBlockRequest request, ServerCallContext context)
{
if (request.PublicKey == null)
{
throw new ArgumentNullException(nameof(request.PublicKey));
}
byte[] keyBytes = request.PublicKey.ToByteArray();
if (keyBytes.Length != Globals.NODE_PUBLIC_KEY_SIZE)
{
throw new ArgumentException($"Public key size must be of {Globals.NODE_PUBLIC_KEY_SIZE} bytes");
}
IKey key = _identityKeyProvider.GetKey(keyBytes);
TransactionalBlockBase transactionalBlockBase = (TransactionalBlockBase)_transactionalDataService.GetLastBlock(key);
TransactionalBlockEssense transactionalBlockEssense = new TransactionalBlockEssense
{
Height = transactionalBlockBase?.BlockHeight ?? 0,
//TODO: need to reconsider hash calculation here since it is potential point of DoS attack
Hash = ByteString.CopyFrom(transactionalBlockBase != null ? _hashCalculation.CalculateHash(transactionalBlockBase.RawData) : new byte[Globals.DEFAULT_HASH_SIZE]),
UpToDateFunds = transactionalBlockBase?.UptodateFunds ?? 0
};
return(Task.FromResult(transactionalBlockEssense));
}
private void FillHeightInfo(TransactionalBlockBase transactionalBlockBase)
{
TransactionalBlockEssense transactionalBlockEssense = _networkAdapter.GetLastBlock(_clientState.GetPublicKey());
transactionalBlockBase.BlockHeight = transactionalBlockEssense.Height + 1;
transactionalBlockBase.HashPrev = transactionalBlockEssense.Hash.ToByteArray();
}
public bool SendAcceptAsset(byte[] transactionKey, byte[] assetCommitment, byte[] blindingFactor, byte[] assetId, ulong tagId)
{
TransactionalBlockBase block = (TransactionalBlockBase)CreateAcceptAssetTransitionBlock(transactionKey, assetCommitment, blindingFactor, assetId, tagId);
BlockBase registerBlock = CreateRegisterBlock(block, null);
return(_networkAdapter.SendTransaction(block, registerBlock));
}
public BlockBase CreateRegisterBlock(TransactionalBlockBase transactionalBlock, byte[] target)
{
RegistryRegisterBlock registerBlock = new RegistryRegisterBlock
{
SyncBlockHeight = transactionalBlock.SyncBlockHeight,
BlockHeight = transactionalBlock.BlockHeight,
Nonce = transactionalBlock.Nonce,
PowHash = transactionalBlock.PowHash,
ReferencedPacketType = transactionalBlock.PacketType,
ReferencedBlockType = transactionalBlock.BlockType,
ReferencedTarget = target ?? new byte[32],
ReferencedBodyHash = _hashCalculation.CalculateHash(transactionalBlock.RawData)
};
return(registerBlock);
}
private void UpdateTransactionalTransaction(TransactionalBlockBase transactionalBlockBase, ulong registryCombinedBlockHeight)
{
switch (transactionalBlockBase.BlockType)
{
case BlockTypes.Transaction_IssueAssets:
ProcessIssueAssetsBlock(transactionalBlockBase as IssueAssetsBlock, registryCombinedBlockHeight);
break;
case BlockTypes.Transaction_TransferAssetsToUtxo:
ProcessTransferAssetsToUtxo(transactionalBlockBase as TransferAssetToUtxoBlock, registryCombinedBlockHeight);
break;
case BlockTypes.Transaction_TransferFunds:
ProcessTranferFunds(transactionalBlockBase as TransferFundsBlock, registryCombinedBlockHeight);
break;
}
}
protected override Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetsCount, out TransactionalBlockBase transactionalBlockBase)
{
TransactionalBlockBase block = null;
if (version == 1)
{
byte[] target = spanBody.Slice(0, Globals.DEFAULT_HASH_SIZE).ToArray();
block = new TransferFundsBlock
{
TargetOriginalHash = target
};
transactionalBlockBase = block;
return(spanBody.Slice(Globals.DEFAULT_HASH_SIZE));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
protected override Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetsCount, out TransactionalBlockBase transactionalBlockBase)
{
TransactionalBlockBase block = null;
if (version == 1)
{
byte[] origin = spanBody.Slice(0, Globals.DEFAULT_HASH_SIZE).ToArray();
ulong funds = BinaryPrimitives.ReadUInt64LittleEndian(spanBody.Span.Slice(Globals.DEFAULT_HASH_SIZE));
block = new AcceptFundsBlock()
{
SourceOriginalHash = origin,
UptodateFunds = funds,
};
transactionalBlockBase = block;
return(spanBody.Slice(Globals.DEFAULT_HASH_SIZE + 8));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
protected override Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetsCount, out TransactionalBlockBase transactionalBlockBase)
{
if (version == 1)
{
int readBytes = 0;
byte[] acceptedTransactionKey = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
byte[] acceptedCommitment = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
byte[] acceptedBlindingFactor = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
byte[] acceptedAssetId = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
AcceptAssetTransitionBlock acceptAssetTransitionBlock = new AcceptAssetTransitionBlock
{
AcceptedTransactionKey = acceptedTransactionKey,
AcceptedCommitment = acceptedCommitment,
AcceptedBlindingFactor = acceptedBlindingFactor,
AcceptedAssetId = acceptedAssetId
};
transactionalBlockBase = acceptAssetTransitionBlock;
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
protected override Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetCount, out TransactionalBlockBase transactionalBlockBase)
{
if (version == 1)
{
int readBytes = 0;
uint count = BinaryPrimitives.ReadUInt32LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += sizeof(uint);
byte[][] issuedAssetIds = new byte[count][];
string[] issuedAssetInfos = new string[count];
for (int i = 0; i < count; i++)
{
issuedAssetIds[i] = spanBody.Slice(readBytes, Globals.NODE_PUBLIC_KEY_SIZE).ToArray();
readBytes += Globals.NODE_PUBLIC_KEY_SIZE;
}
for (int i = 0; i < count; i++)
{
byte strLen = spanBody.Slice(readBytes, 1).ToArray()[0];
readBytes++;
issuedAssetInfos[i] = Encoding.ASCII.GetString(spanBody.Slice(readBytes, strLen).ToArray());
readBytes += strLen;
}
byte strLen2 = spanBody.Slice(readBytes, 1).ToArray()[0];
readBytes++;
string issuanceInfo = Encoding.ASCII.GetString(spanBody.Slice(readBytes, strLen2).ToArray());
readBytes += strLen2;
transactionalBlockBase = new IssueAssetsBlock
{
IssuedAssetIds = issuedAssetIds,
IssuedAssetInfo = issuedAssetInfos,
IssuanceInfo = issuanceInfo
};
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
protected override Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetsCount, out TransactionalBlockBase transactionalBlockBase)
{
TransactionalBlockBase block = null;
if (version == 1)
{
int readBytes = 0;
byte[] destinationKey = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[] transactionPublicKey = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[] assetId = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[] assetCommitment = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[][] assetCommitments = new byte[assetsCount][];
for (int i = 0; i < assetsCount; i++)
{
assetCommitments[i] = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
}
byte[] e = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[][] s = new byte[assetsCount][];
for (int i = 0; i < assetsCount; i++)
{
s[i] = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
}
byte[] mask = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
byte[] asset = spanBody.Slice(readBytes, 32).ToArray();
readBytes += 32;
SurjectionProof surjectionProof = new SurjectionProof
{
AssetCommitments = assetCommitments,
Rs = new BorromeanRingSignature
{
E = e,
S = s
}
};
block = new TransferAssetToUtxoBlock
{
TransactionPublicKey = transactionPublicKey,
DestinationKey = destinationKey,
AssetId = assetId,
AssetCommitment = assetCommitment,
SurjectionProof = surjectionProof,
EcdhTuple = new EcdhTupleCA
{
Mask = mask,
AssetId = asset
}
};
transactionalBlockBase = block;
return(spanBody.Slice(readBytes));
}
throw new BlockVersionNotSupportedException(version, BlockType);
}
protected abstract Memory <byte> ParseTransactional(ushort version, Memory <byte> spanBody, uint assetsCount, out TransactionalBlockBase transactionalBlockBase);
