< Summary - Combined Code Coverage

Information
Class: NLightning.Infrastructure.Serialization.Payloads.AcceptChannel2PayloadSerializer
Assembly: NLightning.Infrastructure.Serialization
File(s): /home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/AcceptChannel2PayloadSerializer.cs
Tag: 30_15166811759
Line coverage
93%
Covered lines: 67
Uncovered lines: 5
Coverable lines: 72
Total lines: 132
Line coverage: 93%
Branch coverage
50%
Covered branches: 3
Total branches: 6
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%4496%
DeserializeAsync()50%2295.24%
NLightning-Domain-Serialization-Payloads-IPayloadSerializer-DeserializeAsync()100%210%

File(s)

/home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/AcceptChannel2PayloadSerializer.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 AcceptChannel2PayloadSerializer : IPayloadSerializer<AcceptChannel2Payload>
 19{
 20    private readonly IValueObjectSerializerFactory _valueObjectSerializerFactory;
 21
 422    public AcceptChannel2PayloadSerializer(IValueObjectSerializerFactory valueObjectSerializerFactory)
 23    {
 424        _valueObjectSerializerFactory = valueObjectSerializerFactory;
 425    }
 26
 27    public async Task SerializeAsync(IMessagePayload payload, Stream stream)
 28    {
 829        if (payload is not AcceptChannel2Payload acceptChannel2Payload)
 030            throw new SerializationException($"Payload is not of type {nameof(AcceptChannel2Payload)}");
 31
 32        // Get the value object serializer
 833        var channelIdSerializer =
 834            _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 835            ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 836        await channelIdSerializer.SerializeAsync(acceptChannel2Payload.TemporaryChannelId, stream);
 37
 38        // Serialize other types
 839        await stream
 840            .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)acceptChannel2Payload.FundingAmount.Satoshi));
 841        await stream
 842            .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)acceptChannel2Payload.DustLimitAmount.Satoshi));
 843        await stream
 844            .WriteAsync(EndianBitConverter
 845                .GetBytesBigEndian(acceptChannel2Payload.MaxHtlcValueInFlightAmount.MilliSatoshi));
 846        await stream
 847            .WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.HtlcMinimumAmount.MilliSatoshi));
 848        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.MinimumDepth));
 849        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.ToSelfDelay));
 850        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.MaxAcceptedHtlcs));
 851        await stream.WriteAsync(acceptChannel2Payload.FundingPubKey.ToBytes());
 852        await stream.WriteAsync(acceptChannel2Payload.RevocationBasepoint.ToBytes());
 853        await stream.WriteAsync(acceptChannel2Payload.PaymentBasepoint.ToBytes());
 854        await stream.WriteAsync(acceptChannel2Payload.DelayedPaymentBasepoint.ToBytes());
 855        await stream.WriteAsync(acceptChannel2Payload.HtlcBasepoint.ToBytes());
 856        await stream.WriteAsync(acceptChannel2Payload.FirstPerCommitmentPoint.ToBytes());
 857    }
 58
 59    public async Task<AcceptChannel2Payload?> DeserializeAsync(Stream stream)
 60    {
 1261        var buffer = ArrayPool<byte>.Shared.Rent(CryptoConstants.PUBKEY_LEN);
 62
 63        try
 64        {
 65            // Get the value object serializer
 1266            var channelIdSerializer =
 1267                _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 1268                ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 1269            var temporaryChannelId = await channelIdSerializer.DeserializeAsync(stream);
 70
 1271            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1272            var fundingSatoshis = LightningMoney.FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]),
 1273                                                          LightningMoneyUnit.Satoshi);
 74
 1275            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1276            var dustLimitSatoshis =
 1277                LightningMoney.FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]),
 1278                                        LightningMoneyUnit.Satoshi);
 79
 1280            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1281            var maxHtlcValueInFlightMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 82
 1283            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1284            var htlcMinimumMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 85
 1286            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 1287            var minimumDepth = EndianBitConverter.ToUInt32BigEndian(buffer[..sizeof(uint)]);
 88
 1289            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 1290            var toSelfDelay = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 91
 1292            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 1293            var maxAcceptedHtlcs = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 94
 1295            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 1296            var fundingPubKey = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 97
 1298            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 1299            var revocationBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 100
 12101            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12102            var paymentBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 103
 12104            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12105            var delayedPaymentBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 106
 12107            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12108            var htlcBasepoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 109
 12110            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.PUBKEY_LEN]);
 12111            var firstPerCommitmentPoint = new PubKey(buffer[..CryptoConstants.PUBKEY_LEN]);
 112
 12113            return new AcceptChannel2Payload(delayedPaymentBasepoint, dustLimitSatoshis, firstPerCommitmentPoint,
 12114                                             fundingSatoshis, fundingPubKey, htlcBasepoint, htlcMinimumMsat,
 12115                                             maxAcceptedHtlcs, maxHtlcValueInFlightMsat, minimumDepth, paymentBasepoint,
 12116                                             revocationBasepoint, temporaryChannelId, toSelfDelay);
 117        }
 0118        catch (Exception e)
 119        {
 0120            throw new PayloadSerializationException("Error deserializing AcceptChannel2Payload", e);
 121        }
 122        finally
 123        {
 12124            ArrayPool<byte>.Shared.Return(buffer);
 125        }
 12126    }
 127
 128    async Task<IMessagePayload?> IPayloadSerializer.DeserializeAsync(Stream stream)
 129    {
 0130        return await DeserializeAsync(stream);
 0131    }
 132}
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()