< Summary - Combined Code Coverage

Information
Class: NLightning.Infrastructure.Serialization.Payloads.OpenChannel2PayloadSerializer
Assembly: NLightning.Infrastructure.Serialization
File(s): /home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/OpenChannel2PayloadSerializer.cs
Tag: 30_15166811759
Line coverage
94%
Covered lines: 91
Uncovered lines: 5
Coverable lines: 96
Total lines: 166
Line coverage: 94.7%
Branch coverage
50%
Covered branches: 7
Total branches: 14
Branch coverage: 50%
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()50%8896.97%
DeserializeAsync()50%6696.55%
NLightning-Domain-Serialization-Payloads-IPayloadSerializer-DeserializeAsync()100%210%

File(s)

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

#LineLine coverage
 1using System.Buffers;
 2using System.Runtime.Serialization;
 3using NBitcoin;
 4using NLightning.Domain.Serialization.Payloads;
 5
 6namespace NLightning.Infrastructure.Serialization.Payloads;
 7
 8using Converters;
 9using Domain.Crypto.Constants;
 10using Domain.Enums;
 11using Domain.Money;
 12using Domain.Protocol.Payloads;
 13using Domain.Protocol.Payloads.Interfaces;
 14using Domain.Serialization.Factories;
 15using Domain.ValueObjects;
 16using Exceptions;
 17
 18public class OpenChannel2PayloadSerializer : IPayloadSerializer<OpenChannel2Payload>
 19{
 20    private readonly IValueObjectSerializerFactory _valueObjectSerializerFactory;
 21
 422    public OpenChannel2PayloadSerializer(IValueObjectSerializerFactory valueObjectSerializerFactory)
 23    {
 424        _valueObjectSerializerFactory = valueObjectSerializerFactory;
 425    }
 26
 27    public async Task SerializeAsync(IMessagePayload payload, Stream stream)
 28    {
 829        if (payload is not OpenChannel2Payload openChannel2Payload)
 030            throw new SerializationException($"Payload is not of type {nameof(OpenChannel2Payload)}");
 31
 32        // Get the ChainHash serializer
 833        var chainHashSerializer =
 834            _valueObjectSerializerFactory.GetSerializer<ChainHash>()
 835            ?? throw new SerializationException($"No serializer found for value object type {nameof(ChainHash)}");
 836        await chainHashSerializer.SerializeAsync(openChannel2Payload.ChainHash, stream);
 37
 38        // Get the ChannelId serializer
 839        var channelIdSerializer =
 840            _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 841            ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 842        await channelIdSerializer.SerializeAsync(openChannel2Payload.TemporaryChannelId, stream);
 43
 844        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.FundingFeeRatePerKw));
 845        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.CommitmentFeeRatePerKw));
 846        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.FundingAmount.Satoshi));
 847        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.DustLimitAmount.Satoshi));
 848        await stream.WriteAsync(
 849            EndianBitConverter.GetBytesBigEndian(openChannel2Payload.MaxHtlcValueInFlightAmount.MilliSatoshi));
 850        await stream
 851            .WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.HtlcMinimumAmount.MilliSatoshi));
 852        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.ToSelfDelay));
 853        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.MaxAcceptedHtlcs));
 854        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(openChannel2Payload.Locktime));
 855        await stream.WriteAsync(openChannel2Payload.FundingPubKey.ToBytes());
 856        await stream.WriteAsync(openChannel2Payload.RevocationBasepoint.ToBytes());
 857        await stream.WriteAsync(openChannel2Payload.PaymentBasepoint.ToBytes());
 858        await stream.WriteAsync(openChannel2Payload.DelayedPaymentBasepoint.ToBytes());
 859        await stream.WriteAsync(openChannel2Payload.HtlcBasepoint.ToBytes());
 860        await stream.WriteAsync(openChannel2Payload.FirstPerCommitmentPoint.ToBytes());
 861        await stream.WriteAsync(openChannel2Payload.SecondPerCommitmentPoint.ToBytes());
 62
 63        // Get the ChannelFlags serializer
 864        var channelFlagsSerializer =
 865            _valueObjectSerializerFactory.GetSerializer<ChannelFlags>()
 866            ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelFlags)}");
 867        await channelFlagsSerializer.SerializeAsync(openChannel2Payload.ChannelFlags, stream);
 868    }
 69
 70    public async Task<OpenChannel2Payload?> DeserializeAsync(Stream stream)
 71    {
 1272        var buffer = ArrayPool<byte>.Shared.Rent(CryptoConstants.PUBKEY_LEN);
 73
 74        try
 75        {
 76            // Get the ChainHash serializer
 1277            var chainHashSerializer =
 1278                _valueObjectSerializerFactory.GetSerializer<ChainHash>()
 1279                ?? throw new SerializationException($"No serializer found for value object type {nameof(ChainHash)}");
 1280            var chainHash = await chainHashSerializer.DeserializeAsync(stream);
 81
 82            // Get the ChannelId serializer
 1283            var channelIdSerializer =
 1284                _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 1285                ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 1286            var temporaryChannelId = await channelIdSerializer.DeserializeAsync(stream);
 87
 1288            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 1289            var fundingFeeRatePerKw = EndianBitConverter.ToUInt32BigEndian(buffer[..sizeof(uint)]);
 90
 1291            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 1292            var commitmentFeeRatePerKw = EndianBitConverter.ToUInt32BigEndian(buffer[..sizeof(uint)]);
 93
 1294            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1295            var fundingSatoshis = LightningMoney.FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]),
 1296                                                          LightningMoneyUnit.Satoshi);
 97
 1298            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1299            var dustLimitSatoshis = LightningMoney
 12100                .FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]), LightningMoneyUnit.Satoshi);
 101
 12102            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 12103            var maxHtlcValueInFlightMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 104
 12105            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 12106            var htlcMinimumMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 107
 12108            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 12109            var toSelfDelay = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 110
 12111            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 12112            var maxAcceptedHtlcs = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 113
 12114            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 12115            var locktime = EndianBitConverter.ToUInt32BigEndian(buffer[..sizeof(uint)]);
 116
 12117            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12118            var fundingPubKey = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 119
 12120            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12121            var revocationBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 122
 12123            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12124            var paymentBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 125
 12126            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12127            var delayedPaymentBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 128
 12129            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12130            var htlcBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 131
 12132            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12133            var firstPerCommitmentPoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 134
 12135            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12136            var secondPerCommitmentPoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 137
 138            // Get the ChannelFlags serializer
 12139            var channelFlagsSerializer =
 12140                _valueObjectSerializerFactory.GetSerializer<ChannelFlags>()
 12141                ?? throw new SerializationException(
 12142                    $"No serializer found for value object type {nameof(ChannelFlags)}");
 12143            var channelFlags = await channelFlagsSerializer.DeserializeAsync(stream);
 144
 12145            return new OpenChannel2Payload(chainHash, channelFlags, commitmentFeeRatePerKw, delayedPaymentBasepoint,
 12146                                           dustLimitSatoshis, firstPerCommitmentPoint, fundingSatoshis,
 12147                                           fundingFeeRatePerKw, fundingPubKey, htlcBasepoint, htlcMinimumMsat, locktime,
 12148                                           maxAcceptedHtlcs, maxHtlcValueInFlightMsat, paymentBasepoint,
 12149                                           revocationBasepoint, secondPerCommitmentPoint, toSelfDelay,
 12150                                           temporaryChannelId);
 151        }
 0152        catch (Exception e)
 153        {
 0154            throw new PayloadSerializationException("Error deserializing OpenChannel2Payload", e);
 155        }
 156        finally
 157        {
 12158            ArrayPool<byte>.Shared.Return(buffer);
 159        }
 12160    }
 161
 162    async Task<IMessagePayload?> IPayloadSerializer.DeserializeAsync(Stream stream)
 163    {
 0164        return await DeserializeAsync(stream);
 0165    }
 166}
Generated by: ReportGenerator 5.2.4.0
05/21/2025 - 15:52:42
GitHub | reportgenerator.io

Methods/Properties

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