Example #1
0
        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);
        }
Example #2
0
        private BlockBase CreateAcceptAssetTransitionBlock(byte[] transactionKey, byte[] assetCommitment, byte[] blindingFactor, byte[] assetId, ulong tagId)
        {
            if (_clientState.IsConfidential())
            {
                return(null);
            }

            List <TransactionalOutcomingBlock> outcomingBlocks = _dataAccessService.GetOutcomingTransactionBlocks();

            List <TransactionalOutcomingBlock> acceptanceBlocks = outcomingBlocks?.Where(b => b.BlockType == BlockTypes.Transaction_AcceptAssetTransition).ToList();

            List <byte[]> assetIds = new List <byte[]>();
            List <ulong>  amounts  = new List <ulong>();

            if (acceptanceBlocks != null)
            {
                TransactionalOutcomingBlock outcomingBlock = acceptanceBlocks.OrderByDescending(b => b.Height).First();
                AcceptAssetTransitionBlock  acceptAsset    = (AcceptAssetTransitionBlock)_blockParsersRepositoriesRepository.
                                                             GetBlockParsersRepository(PacketType.Transactional).
                                                             GetInstance(BlockTypes.Transaction_AcceptAssetTransition).
                                                             Parse(outcomingBlock.Content);

                assetIds = new List <byte[]>(acceptAsset.AssetIds);
                amounts  = new List <ulong>(acceptAsset.AssetAmounts);
            }

            int index = assetIds.FindIndex(a => a.Equals32(assetId));

            if (index >= 0)
            {
                amounts[index]++;
            }
            else
            {
                assetIds.Add(assetId);
                amounts.Add(1);
            }

            AcceptAssetTransitionBlock block = new AcceptAssetTransitionBlock
            {
                AssetIds               = assetIds.ToArray(),
                AssetAmounts           = amounts.ToArray(),
                TagId                  = tagId,
                UptodateFunds          = 0,
                AcceptedTransactionKey = transactionKey,
                AcceptedCommitment     = assetCommitment,
                AcceptedBlindingFactor = blindingFactor,
                AcceptedAssetId        = assetId
            };

            FillHeightInfo(block);
            FillSyncData(block);
            FillRawData(block);

            return(block);
        }