< Summary - Combined Code Coverage

Information
Class: NLightning.Infrastructure.Serialization.Payloads.AcceptChannel1PayloadSerializer
Assembly: NLightning.Infrastructure.Serialization
File(s): /home/runner/work/nlightning/nlightning/src/NLightning.Infrastructure.Serialization/Payloads/AcceptChannel1PayloadSerializer.cs
Tag: 36_15743069263
Line coverage
4%
Covered lines: 3
Uncovered lines: 69
Coverable lines: 72
Total lines: 130
Line coverage: 4.1%
Branch coverage
0%
Covered branches: 0
Total branches: 6
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%2040%
DeserializeAsync()0%620%
NLightning-Domain-Serialization-Interfaces-IPayloadSerializer-DeserializeAsync()100%210%

File(s)

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

#LineLine coverage
 1using System.Buffers;
 2using System.Runtime.Serialization;
 3using NLightning.Domain.Protocol.Interfaces;
 4
 5namespace NLightning.Infrastructure.Serialization.Payloads;
 6
 7using Converters;
 8using Domain.Channels.ValueObjects;
 9using Domain.Crypto.Constants;
 10using Domain.Crypto.ValueObjects;
 11using Domain.Money;
 12using Domain.Protocol.Payloads;
 13using Domain.Serialization.Interfaces;
 14using Exceptions;
 15
 16public class AcceptChannel1PayloadSerializer : IPayloadSerializer<AcceptChannel1Payload>
 17{
 18    private readonly IValueObjectSerializerFactory _valueObjectSerializerFactory;
 19
 420    public AcceptChannel1PayloadSerializer(IValueObjectSerializerFactory valueObjectSerializerFactory)
 21    {
 422        _valueObjectSerializerFactory = valueObjectSerializerFactory;
 423    }
 24
 25    public async Task SerializeAsync(IMessagePayload payload, Stream stream)
 26    {
 027        if (payload is not AcceptChannel1Payload acceptChannel1Payload)
 028            throw new SerializationException($"Payload is not of type {nameof(AcceptChannel1Payload)}");
 29
 30        // Get the value object serializer
 031        var channelIdSerializer =
 032            _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 033         ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 034        await channelIdSerializer.SerializeAsync(acceptChannel1Payload.ChannelId, stream);
 35
 36        // Serialize other types
 037        await stream
 038           .WriteAsync(EndianBitConverter.GetBytesBigEndian((ulong)acceptChannel1Payload.DustLimitAmount.Satoshi));
 039        await stream
 040           .WriteAsync(EndianBitConverter
 041                          .GetBytesBigEndian(acceptChannel1Payload.MaxHtlcValueInFlightAmount.MilliSatoshi));
 042        await stream
 043           .WriteAsync(EndianBitConverter
 044                          .GetBytesBigEndian((ulong)acceptChannel1Payload.ChannelReserveAmount.Satoshi));
 045        await stream
 046           .WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel1Payload.HtlcMinimumAmount.MilliSatoshi));
 047        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel1Payload.MinimumDepth));
 048        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel1Payload.ToSelfDelay));
 049        await stream.WriteAsync(EndianBitConverter.GetBytesBigEndian(acceptChannel1Payload.MaxAcceptedHtlcs));
 050        await stream.WriteAsync(acceptChannel1Payload.FundingPubKey);
 051        await stream.WriteAsync(acceptChannel1Payload.RevocationBasepoint);
 052        await stream.WriteAsync(acceptChannel1Payload.PaymentBasepoint);
 053        await stream.WriteAsync(acceptChannel1Payload.DelayedPaymentBasepoint);
 054        await stream.WriteAsync(acceptChannel1Payload.HtlcBasepoint);
 055        await stream.WriteAsync(acceptChannel1Payload.FirstPerCommitmentPoint);
 056    }
 57
 58    public async Task<AcceptChannel1Payload?> DeserializeAsync(Stream stream)
 59    {
 060        var buffer = ArrayPool<byte>.Shared.Rent(CryptoConstants.CompactPubkeyLen);
 61
 62        try
 63        {
 64            // Get the value object serializer
 065            var channelIdSerializer =
 066                _valueObjectSerializerFactory.GetSerializer<ChannelId>()
 067             ?? throw new SerializationException($"No serializer found for value object type {nameof(ChannelId)}");
 068            var temporaryChannelId = await channelIdSerializer.DeserializeAsync(stream);
 69
 070            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 071            var dustLimitSatoshis = LightningMoney
 072               .Satoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 73
 074            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 075            var maxHtlcValueInFlightMsat = EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]);
 76
 077            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 078            var channelReserveAmount = LightningMoney
 079               .Satoshis(EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]));
 80
 081            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ulong)]);
 082            var htlcMinimumMsat = EndianBitConverter.ToUInt64BigEndian(buffer.AsSpan()[..sizeof(ulong)]);
 83
 084            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(uint)]);
 085            var minimumDepth = EndianBitConverter.ToUInt32BigEndian(buffer.AsSpan()[..sizeof(uint)]);
 86
 087            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 088            var toSelfDelay = EndianBitConverter.ToUInt16BigEndian(buffer.AsSpan()[..sizeof(ushort)]);
 89
 090            await stream.ReadExactlyAsync(buffer.AsMemory()[..sizeof(ushort)]);
 091            var maxAcceptedHtlcs = EndianBitConverter.ToUInt16BigEndian(buffer.AsSpan()[..sizeof(ushort)]);
 92
 093            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 094            var fundingPubKey = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 95
 096            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 097            var revocationBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 98
 099            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0100            var paymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 101
 0102            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0103            var delayedPaymentBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 104
 0105            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0106            var htlcBasepoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 107
 0108            await stream.ReadExactlyAsync(buffer.AsMemory()[..CryptoConstants.CompactPubkeyLen]);
 0109            var firstPerCommitmentPoint = new CompactPubKey(buffer[..CryptoConstants.CompactPubkeyLen]);
 110
 0111            return new AcceptChannel1Payload(temporaryChannelId, channelReserveAmount, delayedPaymentBasepoint,
 0112                                             dustLimitSatoshis, firstPerCommitmentPoint, fundingPubKey, htlcBasepoint,
 0113                                             htlcMinimumMsat, maxAcceptedHtlcs, maxHtlcValueInFlightMsat, minimumDepth,
 0114                                             paymentBasepoint, revocationBasepoint, toSelfDelay);
 115        }
 0116        catch (Exception e)
 117        {
 0118            throw new PayloadSerializationException("Error deserializing AcceptChannel1Payload", e);
 119        }
 120        finally
 121        {
 0122            ArrayPool<byte>.Shared.Return(buffer);
 123        }
 0124    }
 125
 126    async Task<IMessagePayload?> IPayloadSerializer.DeserializeAsync(Stream stream)
 127    {
 0128        return await DeserializeAsync(stream);
 0129    }
 130}
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()