diff --git a/zpay32/blinded_path.go b/zpay32/blinded_path.go
index 128a05e4b..1f3adb8ce 100644
--- a/zpay32/blinded_path.go
+++ b/zpay32/blinded_path.go
@@ -13,15 +13,6 @@ import (
 )
 
 const (
-	// relayInfoSize is the number of bytes that the relay info of a blinded
-	// payment will occupy.
-	// 	base fee: 4 bytes
-	//	prop fee: 4 bytes
-	//	cltv delta: 2 bytes
-	//	min htlc: 8 bytes
-	//	max htlc: 8 bytes
-	relayInfoSize = 26
-
 	// maxNumHopsPerPath is the maximum number of blinded path hops that can
 	// be included in a single encoded blinded path. This is calculated
 	// based on the `data_length` limit of 638 bytes for any tagged field in
@@ -32,6 +23,12 @@ const (
 	maxNumHopsPerPath = 7
 )
 
+var (
+	// byteOrder defines the endian-ness we use for encoding to and from
+	// buffers.
+	byteOrder = binary.BigEndian
+)
+
 // BlindedPaymentPath holds all the information a payer needs to know about a
 // blinded path to a receiver of a payment.
 type BlindedPaymentPath struct {
@@ -69,24 +66,30 @@ type BlindedPaymentPath struct {
 // DecodeBlindedPayment attempts to parse a BlindedPaymentPath from the passed
 // reader.
 func DecodeBlindedPayment(r io.Reader) (*BlindedPaymentPath, error) {
-	var relayInfo [relayInfoSize]byte
-	n, err := r.Read(relayInfo[:])
+	var payment BlindedPaymentPath
+
+	if err := binary.Read(r, byteOrder, &payment.FeeBaseMsat); err != nil {
+		return nil, err
+	}
+
+	if err := binary.Read(r, byteOrder, &payment.FeeRate); err != nil {
+		return nil, err
+	}
+
+	err := binary.Read(r, byteOrder, &payment.CltvExpiryDelta)
 	if err != nil {
 		return nil, err
 	}
-	if n != relayInfoSize {
-		return nil, fmt.Errorf("unable to read %d relay info bytes "+
-			"off of the given stream: %w", relayInfoSize, err)
+
+	err = binary.Read(r, byteOrder, &payment.HTLCMinMsat)
+	if err != nil {
+		return nil, err
 	}
 
-	var payment BlindedPaymentPath
-
-	// Parse the relay info fields.
-	payment.FeeBaseMsat = binary.BigEndian.Uint32(relayInfo[:4])
-	payment.FeeRate = binary.BigEndian.Uint32(relayInfo[4:8])
-	payment.CltvExpiryDelta = binary.BigEndian.Uint16(relayInfo[8:10])
-	payment.HTLCMinMsat = binary.BigEndian.Uint64(relayInfo[10:18])
-	payment.HTLCMaxMsat = binary.BigEndian.Uint64(relayInfo[18:])
+	err = binary.Read(r, byteOrder, &payment.HTLCMaxMsat)
+	if err != nil {
+		return nil, err
+	}
 
 	// Parse the feature bit vector.
 	f := lnwire.EmptyFeatureVector()
@@ -146,24 +149,31 @@ func DecodeBlindedPayment(r io.Reader) (*BlindedPaymentPath, error) {
 // 5) Number of hops: 1 byte.
 // 6) Encoded BlindedHops.
 func (p *BlindedPaymentPath) Encode(w io.Writer) error {
-	var relayInfo [26]byte
-	binary.BigEndian.PutUint32(relayInfo[:4], p.FeeBaseMsat)
-	binary.BigEndian.PutUint32(relayInfo[4:8], p.FeeRate)
-	binary.BigEndian.PutUint16(relayInfo[8:10], p.CltvExpiryDelta)
-	binary.BigEndian.PutUint64(relayInfo[10:18], p.HTLCMinMsat)
-	binary.BigEndian.PutUint64(relayInfo[18:], p.HTLCMaxMsat)
-
-	_, err := w.Write(relayInfo[:])
-	if err != nil {
+	if err := binary.Write(w, byteOrder, p.FeeBaseMsat); err != nil {
 		return err
 	}
 
-	err = p.Features.Encode(w)
-	if err != nil {
+	if err := binary.Write(w, byteOrder, p.FeeRate); err != nil {
 		return err
 	}
 
-	_, err = w.Write(p.FirstEphemeralBlindingPoint.SerializeCompressed())
+	if err := binary.Write(w, byteOrder, p.CltvExpiryDelta); err != nil {
+		return err
+	}
+
+	if err := binary.Write(w, byteOrder, p.HTLCMinMsat); err != nil {
+		return err
+	}
+
+	if err := binary.Write(w, byteOrder, p.HTLCMaxMsat); err != nil {
+		return err
+	}
+
+	if err := p.Features.Encode(w); err != nil {
+		return err
+	}
+
+	_, err := w.Write(p.FirstEphemeralBlindingPoint.SerializeCompressed())
 	if err != nil {
 		return err
 	}
@@ -174,14 +184,12 @@ func (p *BlindedPaymentPath) Encode(w io.Writer) error {
 			"maximum of %d", numHops, maxNumHopsPerPath)
 	}
 
-	_, err = w.Write([]byte{byte(numHops)})
-	if err != nil {
+	if _, err := w.Write([]byte{byte(numHops)}); err != nil {
 		return err
 	}
 
 	for _, hop := range p.Hops {
-		err = EncodeBlindedHop(w, hop)
-		if err != nil {
+		if err := EncodeBlindedHop(w, hop); err != nil {
 			return err
 		}
 	}