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);