public bool TryParseTxIn(ref ByteSequenceReader r, IBlockParser bp)
{
if (!_prevOutPoint.TryReadOutPoint(ref r))
{
goto fail;
}
bp.TxInStart(this, r.Data.Consumed);
if (!_scriptSig.TryParseScript(ref r, bp))
{
goto fail;
}
if (!r.TryReadLittleEndian(out _sequence))
{
goto fail;
}
bp.TxInParsed(this, r.Data.Consumed);
return(true);
fail:
return(false);
}
public InvalidTxHandler(ITxRepository txRepository, ILogger <InvalidTxHandler> logger, IEventBus eventBus, IBlockParser blockParser, IClock clock)
: base(logger, eventBus)
{
this.txRepository = txRepository ?? throw new ArgumentNullException(nameof(txRepository));
this.blockParser = blockParser ?? throw new ArgumentNullException(nameof(blockParser));
this.clock = clock ?? throw new ArgumentNullException(nameof(clock));
}
private async Task UpdateTransactionsByFullRegistryBlock(SynchronizationRegistryCombinedBlock combinedBlock, byte[] fullRegistryBlockHash)
{
TransactionInfo registryFullBlockInfo = _syncLayerSyncManagerClient.GetFullRegistryBlock(new HeightHashRequest {
Height = combinedBlock.SyncBlockHeight, Hash = ByteString.CopyFrom(fullRegistryBlockHash)
});
if (registryFullBlockInfo.IsEmpty)
{
return;
}
IBlockParsersRepository registryFullBlockParserRepo = _blockParsersRepositoriesRepository.GetBlockParsersRepository((PacketType)registryFullBlockInfo.PacketType);
IBlockParser registryFullBlockParser = registryFullBlockParserRepo.GetInstance((ushort)registryFullBlockInfo.BlockType);
RegistryFullBlock registryFullBlock = (RegistryFullBlock)registryFullBlockParser.Parse(registryFullBlockInfo.Content.ToByteArray());
AsyncServerStreamingCall <TransactionInfo> asyncTransactionInfosStream = _storageLayerSyncManagerClient.GetTransactionInfos(new FullBlockRequest {
SyncBlockHeight = registryFullBlock.SyncBlockHeight, Round = registryFullBlock.BlockHeight
});
while (await asyncTransactionInfosStream.ResponseStream.MoveNext(_cancellationToken))
{
TransactionInfo transactionInfo = asyncTransactionInfosStream.ResponseStream.Current;
IBlockParsersRepository transactionBlockParserRepo = _blockParsersRepositoriesRepository.GetBlockParsersRepository((PacketType)transactionInfo.PacketType);
IBlockParser transactionBlockParser = transactionBlockParserRepo.GetInstance((ushort)transactionInfo.BlockType);
BlockBase transactionBlockBase = transactionBlockParser.Parse(transactionInfo.Content.ToByteArray());
UpdateTransaction(transactionBlockBase, combinedBlock.BlockHeight);
}
}
public bool TryParseScript(ref ByteSequenceReader reader, IBlockParser bp, bool withoutLength = false)
{
var length = reader.Data.Remaining;
if (!withoutLength && !reader.TryReadVariant(out length))
{
goto fail;
}
bp.ScriptStart(this, reader.Data.Consumed);
if (reader.Data.Remaining < length)
{
goto fail;
}
_script = (VarType)(ReadOnlyByteSequence)reader.Data.Sequence.Slice(reader.Data.Position, length);
reader.Data.Advance(length);
bp.ScriptParsed(this, reader.Data.Consumed);
return(true);
fail:
return(false);
}
public bool TryParseTransaction(ref ByteSequenceReader r, IBlockParser bp)
{
var offset = r.Data.Consumed;
var start = r.Data.Position;
if (!r.TryReadLittleEndian(out _version))
{
return(false);
}
if (!r.TryReadVariant(out var countIn))
{
return(false);
}
bp.TxStart(this, offset);
Inputs = new TxIn[countIn];
for (var i = 0L; i < countIn; i++)
{
ref var txIn = ref Inputs[i];
if (!txIn.TryParseTxIn(ref r, bp))
{
return(false);
}
}
public NodeController(
INodes nodes,
IBlockParser blockParser
)
{
this.nodes = nodes ?? throw new ArgumentNullException(nameof(nodes));
this.blockParser = blockParser ?? throw new ArgumentNullException(nameof(blockParser));
}
public bool TryParseBlock(ref ReadOnlyByteSequence ros, int height, IBlockParser bp)
{
var r = new ByteSequenceReader(ros);
if (!TryParseBlock(ref r, height, bp))
{
return(false);
}
ros = ros.Data.Slice(r.Data.Consumed);
return(true);
}
public static void Run(string input, IBlockParser parser)
{
if (parser.ValidateBalancedTags(input))
{
Block expression = new Block(input, parser);
Console.WriteLine(expression);
}
else
{
Console.WriteLine(parser.Log);
}
}
public Block(string input, IBlockParser parser)
{
input = input.Trim();
_childText = parser.Parse(input);
foreach (string block in _childText)
{
if (parser.CountBlocks(block) > 0)
{
_childBlocks.Add(new Block(block, parser));
}
}
}
public override PacketBase Translate(TransactionsRegistryBlock obj)
{
if (obj == null)
{
return(null);
}
IBlockParser blockParser = _blockParsersRepository.GetInstance(BlockTypes.Registry_FullBlock);
RegistryFullBlock registryFullBlock = (RegistryFullBlock)blockParser.Parse(obj.Content);
return(registryFullBlock);
}
public override PacketBase Translate(UtxoConfidentialBlock block)
{
PacketBase packetBase = null;
ushort blockType = block.BlockType;
IBlockParser blockParser = null;
blockParser = _blockParsersRepository.GetInstance(blockType);
packetBase = blockParser.Parse(block.BlockContent);
return(packetBase);
}
public static int ParseMany <T>(this IBlockParser <T> parser, ParserContext context, Subject subject)
where T : class
{
var count = 0;
while (!subject.EndOfString)
{
if (!parser.Parse(context, subject))
{
return(count);
}
count += 1;
}
return(count);
}
public override BlockBase Translate(SynchronizationBlock synchronizationBlock)
{
if (synchronizationBlock == null)
{
return(null);
}
SynchronizationConfirmedBlock synchronizationConfirmedBlock = null;
IBlockParser blockParser = _blockParsersRepository.GetInstance(BlockTypes.Synchronization_ConfirmedBlock);
synchronizationConfirmedBlock = blockParser.Parse(synchronizationBlock.BlockContent) as SynchronizationConfirmedBlock;
return(synchronizationConfirmedBlock);
}
public override BlockBase Translate(RegistryCombinedBlock registryCombinedBlock)
{
if (registryCombinedBlock == null)
{
return(null);
}
SynchronizationRegistryCombinedBlock block = null;
IBlockParser blockParser = _blockParsersRepository.GetInstance(BlockTypes.Synchronization_RegistryCombinationBlock);
block = blockParser.Parse(registryCombinedBlock.Content) as SynchronizationRegistryCombinedBlock;
block.SyncBlockHeight = registryCombinedBlock.SyncBlockHeight;
return(block);
}
public StartupChecker(INodeRepository nodeRepository,
INodes nodes,
IRpcClientFactory rpcClientFactory,
IMinerId minerId,
IBlockParser blockParser,
IDbManager dbManager,
INotificationsHandler notificationsHandler,
ILogger <StartupChecker> logger)
{
this.rpcClientFactory = rpcClientFactory ?? throw new ArgumentNullException(nameof(rpcClientFactory));
this.nodeRepository = nodeRepository ?? throw new ArgumentNullException(nameof(nodeRepository));
this.nodes = nodes ?? throw new ArgumentNullException(nameof(nodes));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.blockParser = blockParser ?? throw new ArgumentNullException(nameof(blockParser));
this.dbManager = dbManager ?? throw new ArgumentNullException(nameof(dbManager));
this.minerId = minerId ?? throw new ArgumentNullException(nameof(nodeRepository));
this.notificationsHandler = notificationsHandler ?? throw new ArgumentNullException(nameof(notificationsHandler));
}
public StartupChecker(INodeRepository nodeRepository,
IRpcClientFactory rpcClientFactory,
IMinerId minerId,
IBlockParser blockParser,
ICreateDB createDB,
INotificationsHandler notificationsHandler,
ILogger <StartupChecker> logger,
IConfiguration configuration)
{
this.rpcClientFactory = rpcClientFactory ?? throw new ArgumentNullException(nameof(rpcClientFactory));
this.nodeRepository = nodeRepository ?? throw new ArgumentNullException(nameof(nodeRepository));
this.logger = logger ?? throw new ArgumentException(nameof(logger));
this.blockParser = blockParser ?? throw new ArgumentException(nameof(blockParser));
this.createDB = createDB ?? throw new ArgumentException(nameof(createDB));
this.minerId = minerId ?? throw new ArgumentException(nameof(nodeRepository));
this.notificationsHandler = notificationsHandler ?? throw new ArgumentException(nameof(notificationsHandler));
rdbms = RDBMS.Postgres;
}
private SynchronizationRegistryCombinedBlock GetRegistryCombinedBlock(TransactionInfo blockInfo)
{
try
{
SynchronizationRegistryCombinedBlock combinedBlock;
IBlockParsersRepository blockParsersRepository = _blockParsersRepositoriesRepository.GetBlockParsersRepository((PacketType)blockInfo.PacketType);
IBlockParser blockParser = blockParsersRepository.GetInstance((ushort)blockInfo.BlockType);
BlockBase blockBase = blockParser.Parse(blockInfo.Content.ToByteArray());
combinedBlock = (SynchronizationRegistryCombinedBlock)blockBase;
return(combinedBlock);
}
catch (Exception ex)
{
_logger.Error($"Failure during deserealization of block of PacketType = {(PacketType)blockInfo.PacketType} and BlockType = {blockInfo.BlockType} at Sync Block Height {blockInfo.SyncBlockHeight}", ex);
}
return(null);
}
public async Task <List <BlockBase> > GetTransactions(ulong syncBlockHeight, ulong round)
{
List <BlockBase> transactionInfos = new List <BlockBase>();
AsyncServerStreamingCall <TransactionInfo> asyncServerStreaming = _transactionalChainManager.GetTransactionInfos(new FullBlockRequest {
SyncBlockHeight = syncBlockHeight, Round = round
});
while (await asyncServerStreaming.ResponseStream.MoveNext().ConfigureAwait(false))
{
TransactionInfo item = asyncServerStreaming.ResponseStream.Current;
IBlockParsersRepository blockParsersRepository = _blockParsersRepositoriesRepository.GetBlockParsersRepository((PacketType)item.PacketType);
IBlockParser blockParser = blockParsersRepository.GetInstance((ushort)item.BlockType);
BlockBase blockBase = blockParser.Parse(item.Content.ToByteArray());
transactionInfos.Add(blockBase);
}
return(transactionInfos);
}
public override BlockBase Translate(TransactionalBlock transactionalBlock)
{
if (transactionalBlock == null)
{
return(null);
}
BlockBase transactionalBlockBase = null;
ushort blockType = transactionalBlock.BlockType;
IBlockParser blockParser = null;
blockParser = _blockParsersRepository.GetInstance(blockType);
transactionalBlockBase = blockParser.Parse(transactionalBlock.BlockContent);
return(transactionalBlockBase);
}
public bool TryParseBlock(ref ByteSequenceReader r, int height, IBlockParser bp)
{
var offset = r.Data.Consumed;
if (!TryReadBlockHeader(ref r))
{
goto fail;
}
Height = height;
bp.BlockStart(this, offset);
if (!r.TryReadVariant(out var count))
{
goto fail;
}
Txs = new Transaction[count];
for (var i = 0L; i < count; i++)
{
var t = new Transaction();
Txs[i] = t;
if (!t.TryParseTransaction(ref r, bp))
{
goto fail;
}
}
if (!VerifyMerkleRoot())
{
goto fail;
}
bp.BlockParsed(this, r.Data.Consumed);
return(true);
fail:
return(false);
}
public MainForm(ISettingsRepository settingsRepository, IRPCClient client, IBlockParser blockParser
, UserControlFactory userControlFactory, ITransactionParser transactionParser
, ITransactionRepository transactionRepository)
{
this.settingsRepository = settingsRepository;
this.client = client;
this.blockParser = blockParser;
this.userControlFactory = userControlFactory;
this.transactionParser = transactionParser;
this.transactionRepository = transactionRepository;
this.templates = new List <MintTemplate>();
this.results = new List <CheckStakeResult>();
this.blockModifiers = new List <StakeModifier>();
InitializeComponent();
source = new CancellationTokenSource();
token = source.Token;
this.panel2.BackColor = System.Drawing.ColorTranslator.FromHtml("#3cb054");
}
protected override Memory <byte> ParseSynced(ushort version, Memory <byte> spanBody, out SyncedBlockBase syncedBlockBase)
{
if (version == 1)
{
RegistryFullBlock transactionsFullBlock = new RegistryFullBlock();
ushort itemsCount = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span);
transactionsFullBlock.TransactionHeaders = new SortedList <ushort, ITransactionRegistryBlock>(itemsCount);
int readBytes = 2;
if (itemsCount > 0)
{
for (int i = 0; i < itemsCount; i++)
{
ushort order = BinaryPrimitives.ReadUInt16LittleEndian(spanBody.Span.Slice(readBytes));
readBytes += 2;
BlockParserBase.GetPacketAndBlockTypes(spanBody.Slice(readBytes), out PacketType packetType, out ushort blockType);
IBlockParsersRepository blockParsersRepository = _blockParsersRepositoriesRepository.Value.GetBlockParsersRepository(packetType);
IBlockParser blockParser = blockParsersRepository.GetInstance(blockType);
BlockBase block = blockParser.Parse(spanBody.Slice(readBytes));
readBytes += block?.RawData.Length ?? 0;
if (block is ITransactionRegistryBlock transactionRegistryBlock)
{
transactionsFullBlock.TransactionHeaders.Add(order, transactionRegistryBlock);
}
}
}
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);
}
private bool CheckSpIdentityValidations(byte[] commitment, AssociatedProofs[] associatedProofsList, IEnumerable <SpIdenitityValidation> spIdenitityValidations, string sessionKey)
{
if (spIdenitityValidations != null && spIdenitityValidations.Count() > 0)
{
IBlockParsersRepository transactionalBlockParsersRepo = _blockParsersRepositoriesRepository.GetBlockParsersRepository(PacketType.Transactional);
IBlockParser issueAssociatedAttrBlockParser = transactionalBlockParsersRepo.GetInstance(BlockTypes.Transaction_IssueAssociatedBlindedAsset);
if (associatedProofsList == null)
{
_idenitiesHubContext.Clients.Group(sessionKey).SendAsync("PushSpAuthorizationFailed", new { Code = 3, Message = "Validation proofs were not provided" }).Wait();
return(false);
}
foreach (var spIdentityValidation in spIdenitityValidations)
{
if (!CheckSpIdentityValidation(commitment, associatedProofsList, spIdentityValidation, sessionKey))
{
return(false);
}
}
}
return(true);
}
public ExpressionParser( IBlockParser blockParser, IExecutorFactory executorFactory )
{
_blockParser = blockParser;
_executorFactory = executorFactory;
}
private BlockBase ParseMessagePacket(byte[] messagePacket)
{
_log.Debug($"Packet being parsed {messagePacket.ToHexString()}");
BlockBase blockBase = null;
PacketType packetType = (PacketType)BitConverter.ToUInt16(messagePacket, 0);
int blockTypePos = Globals.PACKET_TYPE_LENGTH + Globals.SYNC_BLOCK_HEIGHT_LENGTH + Globals.NONCE_LENGTH + Globals.POW_HASH_SIZE + Globals.VERSION_LENGTH;
if (messagePacket.Length < blockTypePos + 2)
{
_log.Error($"Length of packet is insufficient for obtaining BlockType value: {messagePacket.ToHexString()}");
return(blockBase);
}
ushort blockType = BitConverter.ToUInt16(messagePacket, Globals.PACKET_TYPE_LENGTH + Globals.SYNC_BLOCK_HEIGHT_LENGTH + Globals.NONCE_LENGTH + Globals.POW_HASH_SIZE + Globals.VERSION_LENGTH);
IBlockParser blockParser = null;
IBlockParsersRepository blockParsersFactory = null;
try
{
//TODO: weigh assumption that all messages are sync based (have reference to latest Sync Block)
_log.Info($"Parsing packet of type {packetType} and block type {blockType}");
blockParsersFactory = _blockParsersFactoriesRepository.GetBlockParsersRepository(packetType);
if (blockParsersFactory != null)
{
blockParser = blockParsersFactory.GetInstance(blockType);
if (blockParser != null)
{
blockBase = blockParser.Parse(messagePacket);
}
else
{
_log.Error($"Block parser of packet type {packetType} and block type {blockType} not found! Message: {messagePacket.ToHexString()}");
}
}
else
{
_log.Error($"Block parser factory of packet type {packetType} not found! Message: {messagePacket.ToHexString()}");
}
}
catch (Exception ex)
{
_log.Error($"Failed to parse message of packet type {packetType} and block type {blockType}: {messagePacket.ToHexString()}", ex);
}
_endToEndCountersService.ParsingThroughput.Increment();
if (blockBase != null)
{
_log.Debug($"Parsed block {blockBase.RawData.ToHexString()}");
}
else
{
_log.Error($"Failed to parse block from message {messagePacket.ToHexString()}");
}
return(blockBase);
}
public static int ParseMany <T>(this IBlockParser <T> parser, ParserContext context, string input)
where T : class
{
return(parser.ParseMany(context, new Subject(input)));
}
public IfParser(IExecutorFactory executorFactory, IExpressionParser expressionParser, IBlockParser blockParser)
{
_executorFactory = executorFactory;
_expressionParser = expressionParser;
_blockParser = blockParser;
}
