< Summary - Combined Code Coverage

Information
Class: NLightning.Infrastructure.Serialization.Payloads.OpenChannel1PayloadSerializer
Assembly: NLightning.Infrastructure.Serialization
File(s): /home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/OpenChannel1PayloadSerializer.cs
Tag: 36_15743069263
Line coverage
2%
Covered lines: 3
Uncovered lines: 100
Coverable lines: 103
Total lines: 170
Line coverage: 2.9%
Branch coverage
0%
Covered branches: 0
Total branches: 14
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
SerializeAsync()0%7280%
DeserializeAsync()0%4260%
NLightning-Domain-Serialization-Interfaces-IPayloadSerializer-DeserializeAsync()100%210%

File(s)

/home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/OpenChannel1PayloadSerializer.cs

#LineLine coverage
 1using System.Buffers;
 2using System.Runtime.Serialization;
 3using NLightning.Domain.Protocol.Interfaces;
 4using NLightning.Domain.Serialization.Interfaces;
 5
 6namespace NLightning.Infrastructure.Serialization.Payloads;
 7
 8using Converters;
 9using Domain.Channels.ValueObjects;
 10using Domain.Crypto.Constants;
 11using Domain.Crypto.ValueObjects;
 12using Domain.Money;
 13using Domain.Protocol.Payloads;
 14using Domain.Protocol.ValueObjects;
 15using Exceptions;
 16
 17public class OpenChannel1PayloadSerializer : IPayloadSerializer<OpenChannel1Payload>
 18{
 19    private readonly IValueObjectSerializerFactory _valueObjectSerializerFactory;
 20
 421    public OpenChannel1PayloadSerializer(IValueObjectSerializerFactory valueObjectSerializerFactory)
 22    {
 423        _valueObjectSerializerFactory = valueObjectSerializerFactory;
 424    }
 25
 26    public async Task SerializeAsync(IMessagePayload payload, Stream stream)
 27    {
 028        if (payload is not OpenChannel1Payload openChannel1Payload)
 029            throw new SerializationException($"Payload is not of type {nameof(OpenChannel1Payload)}");
 30
 31        // Get the value object serializer
 032        var chainHashSerializer =
 033            _valueObjectSerializerFactory.GetSerializer<ChainHash>()
 034         ?? throw new SerializationException($"No serializer found for value object type {nameof(ChainHash)}");
 035        await chainHashSerializer.SerializeAsync(openChannel1Payload.ChainHash, stream);
 36
 037        var channelIdSerializer =
 038            _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 039         ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 040        await channelIdSerializer.SerializeAsync(openChannel1Payload.ChannelId, stream);
 41
 042        var channelFlagsSerializer =
 043            _valueObjectSerializerFactory.GetSerializer<ChannelFlags>()
 044         ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelFlags)}");
 45
 46        // Serialize other types
 047        await stream
 048           .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)openChannel1Payload.FundingAmount.Satoshi));
 049        await stream
 050           .WriteAsync(EndianBitConverter
 051                          .GetBytesBigEndian(openChannel1Payload.PushAmount.MilliSatoshi));
 052        await stream
 053           .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)openChannel1Payload.DustLimitAmount.Satoshi));
 054        await stream
 055           .WriteAsync(EndianBitConverter
 056                          .GetBytesBigEndian(openChannel1Payload.MaxHtlcValueInFlight.MilliSatoshi));
 057        await stream
 058           .WriteAsync(EndianBitConverter
 059                          .GetBytesBigEndian((ulong)openChannel1Payload.ChannelReserveAmount.Satoshi));
 060        await stream
 061           .WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel1Payload.HtlcMinimumAmount.MilliSatoshi));
 062        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)openChannel1Payload.FeeRatePerKw.Satoshi));
 063        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel1Payload.ToSelfDelay));
 064        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel1Payload.MaxAcceptedHtlcs));
 065        await stream.WriteAsync(openChannel1Payload.FundingPubKey);
 066        await stream.WriteAsync(openChannel1Payload.RevocationBasepoint);
 067        await stream.WriteAsync(openChannel1Payload.PaymentBasepoint);
 068        await stream.WriteAsync(openChannel1Payload.DelayedPaymentBasepoint);
 069        await stream.WriteAsync(openChannel1Payload.HtlcBasepoint);
 070        await stream.WriteAsync(openChannel1Payload.FirstPerCommitmentPoint);
 71
 072        await channelFlagsSerializer.SerializeAsync(openChannel1Payload.ChannelFlags, stream);
 073    }
 74
 75    public async Task<OpenChannel1Payload?> DeserializeAsync(Stream stream)
 76    {
 077        var buffer = ArrayPool<byte>.Shared.Rent(CryptoConstants.CompactPubkeyLen);
 78
 79        try
 80        {
 81            // Get the value object serializer
 082            var chainHashSerializer =
 083                _valueObjectSerializerFactory.GetSerializer<ChainHash>()
 084             ?? throw new SerializationException($"No serializer found for value object type {nameof(ChainHash)}");
 085            var chainHash = await chainHashSerializer.DeserializeAsync(stream);
 86
 087            var channelIdSerializer =
 088                _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 089             ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 090            var temporaryChannelId = await channelIdSerializer.DeserializeAsync(stream);
 91
 092            var channelFlagsSerializer =
 093                _valueObjectSerializerFactory.GetSerializer<ChannelFlags>()
 094             ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelFlags)}");
 95
 096            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 097            var fundingSatoshis = LightningMoney
 098               .Satoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 99
 0100            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 0101            var pushAmount = LightningMoney
 0102               .MilliSatoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 103
 0104            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 0105            var dustLimitSatoshis = LightningMoney
 0106               .Satoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 107
 0108            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 0109            var maxHtlcValueInFlightMsat = LightningMoney
 0110               .MilliSatoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 111
 0112            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 0113            var channelReserveAmount = LightningMoney
 0114               .Satoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 115
 0116            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 0117            var htlcMinimumAmount = LightningMoney
 0118               .MilliSatoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 119
 0120            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 0121            var feeRatePerKw = LightningMoney
 0122               .Satoshis(EndianBitConverter.ToUInt32BigEndian(buffer.AsSpan()[..sizeof(uint)]));
 123
 0124            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 0125            var toSelfDelay = EndianBitConverter.ToUInt16BigEndian(buffer.AsSpan()[..sizeof(ushort)]);
 126
 0127            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 0128            var maxAcceptedHtlcs = EndianBitConverter.ToUInt16BigEndian(buffer.AsSpan()[..sizeof(ushort)]);
 129
 0130            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0131            var fundingPubKey = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 132
 0133            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0134            var revocationBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 135
 0136            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0137            var paymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 138
 0139            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0140            var delayedPaymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 141
 0142            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0143            var htlcBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 144
 0145            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0146            var firstPerCommitmentPoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 147
 0148            var channelFlags = await channelFlagsSerializer.DeserializeAsync(stream);
 149
 0150            return new OpenChannel1Payload(chainHash, channelFlags, temporaryChannelId, channelReserveAmount,
 0151                                           delayedPaymentBasepoint, dustLimitSatoshis, feeRatePerKw,
 0152                                           firstPerCommitmentPoint, fundingSatoshis, fundingPubKey, htlcBasepoint,
 0153                                           htlcMinimumAmount, maxAcceptedHtlcs, maxHtlcValueInFlightMsat,
 0154                                           paymentBasepoint, pushAmount, revocationBasepoint, toSelfDelay);
 155        }
 0156        catch (Exception e)
 157        {
 0158            throw new PayloadSerializationException("Error deserializing OpenChannel1Payload", e);
 159        }
 160        finally
 161        {
 0162            ArrayPool<byte>.Shared.Return(buffer);
 163        }
 0164    }
 165
 166    async Task<IMessagePayload?> IPayloadSerializer.DeserializeAsync(Stream stream)
 167    {
 0168        return await DeserializeAsync(stream);
 0169    }
 170}
Generated by: ReportGenerator 5.2.4.0
06/18/2025 - 20:36:12
GitHub | reportgenerator.io

Methods/Properties

.ctor(NLightning.Domain.Serialization.Interfaces.IValueObjectSerializerFactory)
SerializeAsync()
DeserializeAsync()
NLightning-Domain-Serialization-Interfaces-IPayloadSerializer-DeserializeAsync()