< 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: 36_15743069263
Line coverage
93%
Covered lines: 67
Uncovered lines: 5
Coverable lines: 72
Total lines: 131
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-Interfaces-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 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.Enums;
 13using Domain.Money;
 14using Domain.Protocol.Payloads;
 15using Exceptions;
 16
 17public class AcceptChannel2PayloadSerializer : IPayloadSerializer<AcceptChannel2Payload>
 18{
 19    private readonly IValueObjectSerializerFactory _valueObjectSerializerFactory;
 20
 421    public AcceptChannel2PayloadSerializer(IValueObjectSerializerFactory valueObjectSerializerFactory)
 22    {
 423        _valueObjectSerializerFactory = valueObjectSerializerFactory;
 424    }
 25
 26    public async Task SerializeAsync(IMessagePayload payload, Stream stream)
 27    {
 828        if (payload is not AcceptChannel2Payload acceptChannel2Payload)
 029            throw new SerializationException($"Payload is not of type {nameof(AcceptChannel2Payload)}");
 30
 31        // Get the value object serializer
 832        var channelIdSerializer =
 833            _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 834         ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 835        await channelIdSerializer.SerializeAsync(acceptChannel2Payload.ChannelId, stream);
 36
 37        // Serialize other types
 838        await stream
 839           .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)acceptChannel2Payload.FundingAmount.Satoshi));
 840        await stream
 841           .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)acceptChannel2Payload.DustLimitAmount.Satoshi));
 842        await stream
 843           .WriteAsync(EndianBitConverter
 844                          .GetBytesBigEndian(acceptChannel2Payload.MaxHtlcValueInFlightAmount.MilliSatoshi));
 845        await stream
 846           .WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.HtlcMinimumAmount.MilliSatoshi));
 847        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.MinimumDepth));
 848        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.ToSelfDelay));
 849        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel2Payload.MaxAcceptedHtlcs));
 850        await stream.WriteAsync(acceptChannel2Payload.FundingCompactPubKey);
 851        await stream.WriteAsync(acceptChannel2Payload.RevocationCompactBasepoint);
 852        await stream.WriteAsync(acceptChannel2Payload.PaymentCompactBasepoint);
 853        await stream.WriteAsync(acceptChannel2Payload.DelayedPaymentCompactBasepoint);
 854        await stream.WriteAsync(acceptChannel2Payload.HtlcCompactBasepoint);
 855        await stream.WriteAsync(acceptChannel2Payload.FirstPerCommitmentCompactPoint);
 856    }
 57
 58    public async Task<AcceptChannel2Payload?> DeserializeAsync(Stream stream)
 59    {
 1260        var buffer = ArrayPool<byte>.Shared.Rent(CryptoConstants.CompactPubkeyLen);
 61
 62        try
 63        {
 64            // Get the value object serializer
 1265            var channelIdSerializer =
 1266                _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 1267             ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 1268            var temporaryChannelId = await channelIdSerializer.DeserializeAsync(stream);
 69
 1270            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1271            var fundingSatoshis = LightningMoney.FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]),
 1272                                                          LightningMoneyUnit.Satoshi);
 73
 1274            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1275            var dustLimitSatoshis =
 1276                LightningMoney.FromUnit(EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]),
 1277                                        LightningMoneyUnit.Satoshi);
 78
 1279            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1280            var maxHtlcValueInFlightMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 81
 1282            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 1283            var htlcMinimumMsat = EndianBitConverter.ToUInt64BigEndian(buffer[..sizeof(ulong)]);
 84
 1285            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 1286            var minimumDepth = EndianBitConverter.ToUInt32BigEndian(buffer[..sizeof(uint)]);
 87
 1288            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 1289            var toSelfDelay = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 90
 1291            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 1292            var maxAcceptedHtlcs = EndianBitConverter.ToUInt16BigEndian(buffer[..sizeof(ushort)]);
 93
 1294            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 1295            var fundingPubKey = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 96
 1297            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 1298            var revocationBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 99
 12100            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 12101            var paymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 102
 12103            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 12104            var delayedPaymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 105
 12106            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 12107            var htlcBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 108
 12109            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 12110            var firstPerCommitmentPoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 111
 12112            return new AcceptChannel2Payload(delayedPaymentBasepoint, dustLimitSatoshis, firstPerCommitmentPoint,
 12113                                             fundingSatoshis, fundingPubKey, htlcBasepoint, htlcMinimumMsat,
 12114                                             maxAcceptedHtlcs, maxHtlcValueInFlightMsat, minimumDepth, paymentBasepoint,
 12115                                             revocationBasepoint, temporaryChannelId, toSelfDelay);
 116        }
 0117        catch (Exception e)
 118        {
 0119            throw new PayloadSerializationException("Error deserializing AcceptChannel2Payload", e);
 120        }
 121        finally
 122        {
 12123            ArrayPool<byte>.Shared.Return(buffer);
 124        }
 12125    }
 126
 127    async Task<IMessagePayload?> IPayloadSerializer.DeserializeAsync(Stream stream)
 128    {
 0129        return await DeserializeAsync(stream);
 0130    }
 131}
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()