Redefine single-variant discriminated union types

A lot of types in DotNetLightning are defined as discriminated unions
with a single constructor with the same name as the type. eg:

    type NodeId = | NodeId PubKey

This commit redefines these types as:

    type NodeId(id: PubKey) = ...

The main motivation for this is that having types and constructors with
the same name breaks the json serialization library on older mono
versions. It can also lead to confusing error messages. Besides that,
it's also somewhat pointless to define a type as a discriminated union
but then only give it one variant.

Author: canndrew

src/DotNetLightning.Core/Channel/ChannelError.fs

@@ -253,9 +253,9 @@ module private ValidationHelper =
 /// Helpers to create channel error
 [<AutoOpen>]
 module internal ChannelError =
-    let feeRateMismatch (FeeRatePerKw remote, FeeRatePerKw local) =
-        let remote = float remote
-        let local = float local
+    let feeRateMismatch (remote: FeeRatePerKw, local: FeeRatePerKw) =
+        let remote = float remote.Value
+        let local = float local.Value
         abs (2.0 * (remote - local) / (remote + local))
 
     let inline feeDeltaTooHigh msg (actualDelta, maxAccepted) =

src/DotNetLightning.Core/Channel/ChannelHelpers.fs

@@ -9,8 +9,8 @@ open NBitcoin
 /// cousin of `ChannelHelpers` module which only includes very primitive function.
 module internal ChannelConstantHelpers =
     let deriveOurDustLimitSatoshis (feeEstimator: IFeeEstimator): Money =
-        let (FeeRatePerKw atOpenBackGroundFee) = feeEstimator.GetEstSatPer1000Weight(ConfirmationTarget.Background)
-        (Money.Satoshis((uint64 atOpenBackGroundFee) * B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT / 1000UL), Money.Satoshis(546UL))
+        let atOpenBackGroundFee = feeEstimator.GetEstSatPer1000Weight(ConfirmationTarget.Background)
+        (Money.Satoshis((uint64 atOpenBackGroundFee.Value) * B_OUTPUT_PLUS_SPENDING_INPUT_WEIGHT / 1000UL), Money.Satoshis(546UL))
         |> Money.Max
 
     let getOurChannelReserve (channelValue: Money) =

src/DotNetLightning.Core/Channel/ChannelValidation.fs

@@ -21,9 +21,9 @@ module internal ChannelHelpers =
                       [| theirFundingPubKey; ourFundingKey |]
         PayToMultiSigTemplate.Instance.GenerateScriptPubKey(2, pks)
 
-    let getFundingScriptCoin (ck: ChannelPubKeys) (theirFundingPubKey: PubKey) (TxId fundingTxId) (TxOutIndex fundingOutputIndex) (fundingSatoshis): ScriptCoin =
+    let getFundingScriptCoin (ck: ChannelPubKeys) (theirFundingPubKey: PubKey) (fundingTxId: TxId) (fundingOutputIndex: TxOutIndex) (fundingSatoshis): ScriptCoin =
         let redeem = getFundingRedeemScript ck theirFundingPubKey
-        Coin(fundingTxId, uint32 fundingOutputIndex, fundingSatoshis, redeem.WitHash.ScriptPubKey)
+        Coin(fundingTxId.Value, uint32 fundingOutputIndex.Value, fundingSatoshis, redeem.WitHash.ScriptPubKey)
         |> fun c -> ScriptCoin(c, redeem)
 
     let private makeFlags (isNode1: bool, enable: bool) =
@@ -52,14 +52,14 @@ module internal ChannelHelpers =
         }
 
     /// gets the fee we'd want to charge for adding an HTLC output to this channel
-    let internal getOurFeeBaseMSat (feeEstimator: IFeeEstimator) (FeeRatePerKw feeRatePerKw) (isFunder: bool) =
+    let internal getOurFeeBaseMSat (feeEstimator: IFeeEstimator) (feeRatePerKw: FeeRatePerKw) (isFunder: bool) =
         // for lack of a better metric, we calculate waht it would cost to consolidate the new HTLC
         // output value back into a transaction with the regular channel output:
 
         // the fee cost of the HTLC-success/HTLC-Timout transaction
-        let mutable res = uint64 feeRatePerKw * (max (ChannelConstants.HTLC_TIMEOUT_TX_WEIGHT) (ChannelConstants.HTLC_TIMEOUT_TX_WEIGHT)) |> fun r -> r / 1000UL
+        let mutable res = uint64 feeRatePerKw.Value * (max (ChannelConstants.HTLC_TIMEOUT_TX_WEIGHT) (ChannelConstants.HTLC_TIMEOUT_TX_WEIGHT)) |> fun r -> r / 1000UL
         if (isFunder) then
-            res <- res + uint64 feeRatePerKw * COMMITMENT_TX_WEIGHT_PER_HTLC / 1000UL
+            res <- res + uint64 feeRatePerKw.Value * COMMITMENT_TX_WEIGHT_PER_HTLC / 1000UL
 
         //+ the marginal cost of an input which spends the HTLC-Success/HTLC-Timeout output:
         res <-

src/DotNetLightning.Core/Payment/LSAT/MacaroonIdentifier.fs

@@ -35,7 +35,7 @@ type MacaroonIdentifier =
         | 0us ->
             if (b.Length <> 2 + 32 + 32) then e else
             {
-                PaymentHash = PaymentHash.PaymentHash(uint256(b.[2..33], false))
+                PaymentHash = PaymentHash(uint256(b.[2..33], false))
                 TokenId = uint256(b.[34..], false)
             }
             |> V0

src/DotNetLightning.Core/Payment/PaymentRequest.fs

@@ -258,11 +258,11 @@ type TaggedField =
         | DescriptionHashTaggedField h ->
             let dBase32 = h.ToBytes(false) |> Helpers.convert8BitsTo5
             this.WriteField(writer, dBase32)
-        | NodeIdTaggedField(NodeId pk) ->
-            let dBase32 = pk.ToBytes() |> Helpers.convert8BitsTo5
+        | NodeIdTaggedField(nodeId) ->
+            let dBase32 = nodeId.Value.ToBytes() |> Helpers.convert8BitsTo5
             this.WriteField(writer, dBase32)
-        | MinFinalCltvExpiryTaggedField (BlockHeightOffset32 c) ->
-            let dBase32 = c |> uint64 |> Helpers.uint64ToBase32
+        | MinFinalCltvExpiryTaggedField (blockHeightOffset32) ->
+            let dBase32 = blockHeightOffset32.Value |> uint64 |> Helpers.uint64ToBase32
             this.WriteField(writer, dBase32)
         | ExpiryTaggedField x ->
             let dBase32 = ((x.ToUnixTimeSeconds() |> uint64) - timestamp) |> Helpers.uint64ToBase32

src/DotNetLightning.Core/Peer/PeerChannelEncryptor.fs

@@ -279,11 +279,11 @@ module PeerChannelEncryptor =
 
 
     module PeerChannelEncryptor =
-        let newOutBound (NodeId theirNodeId, ourNodeSecret: Key) =
-            let hashInput = Array.concat[| NOISE_H; theirNodeId.ToBytes()|]
+        let newOutBound (theirNodeId: NodeId, ourNodeSecret: Key) =
+            let hashInput = Array.concat[| NOISE_H; theirNodeId.Value.ToBytes()|]
             let h = uint256(Hashes.SHA256(hashInput))
             {
-                TheirNodeId = Some(NodeId theirNodeId)
+                TheirNodeId = Some(theirNodeId)
                 NoiseState = InProgress {
                         State = PreActOne
                         DirectionalState = OutBound ({ IE = ourNodeSecret })

src/DotNetLightning.Core/Serialize/Msgs/Msgs.fs

@@ -1370,7 +1370,7 @@ type ErrorMsg =
                 this.Data <- ls.ReadWithLen()
             member this.Serialize(ls) =
                 match this.ChannelId with
-                | SpecificChannel (ChannelId id) -> ls.Write(id.ToBytes())
+                | SpecificChannel id -> ls.Write(id.Value.ToBytes())
                 | All -> ls.Write(Array.zeroCreate 32)
                 ls.WriteWithLen(this.Data)
 

src/DotNetLightning.Core/Transactions/Scripts.fs

@@ -14,12 +14,12 @@ module Scripts =
     let multiSigOfM_2 (sort) (pks) =
         PayToMultiSigTemplate.Instance.GenerateScriptPubKey(2, sort, pks)
 
-    let toLocalDelayed  (revocationPubKey: PubKey) (BlockHeightOffset16 toSelfDelay) (localDelayedPaymentPubkey: PubKey): Script =
+    let toLocalDelayed  (revocationPubKey: PubKey) (toSelfDelay: BlockHeightOffset16) (localDelayedPaymentPubkey: PubKey): Script =
         let opList = ResizeArray<Op>()
         opList.Add(!> OpcodeType.OP_IF)
         opList.Add(Op.GetPushOp(revocationPubKey.ToBytes()))
         opList.Add(!> OpcodeType.OP_ELSE)
-        opList.Add(Op.GetPushOp(int64 toSelfDelay))
+        opList.Add(Op.GetPushOp(int64 toSelfDelay.Value))
         opList.Add(!> OpcodeType.OP_CHECKSEQUENCEVERIFY)
         opList.Add(!> OpcodeType.OP_DROP)
         opList.Add(Op.GetPushOp(localDelayedPaymentPubkey.ToBytes()))

src/DotNetLightning.Core/Transactions/Transactions.fs

@@ -176,10 +176,9 @@ type ClosingTx = ClosingTx of PSBT
 
 
 /// Tx already verified and it can be published anytime
-type FinalizedTx =
-    FinalizedTx of Transaction
-    with
-        member this.Value = let (FinalizedTx v) = this in v
+[<Struct>]
+type FinalizedTx(tx: Transaction) =
+    member this.Value = tx
 
 type InputInfo = {
     OutPoint: OutPoint

src/DotNetLightning.Core/Utils/ChannelId.fs

@@ -2,8 +2,8 @@ namespace DotNetLightning.Utils
 
 open NBitcoin
 
-type ChannelId = | ChannelId of uint256 with
-    member x.Value = let (ChannelId v) = x in v
-
+[<Struct>]
+type ChannelId(id: uint256) =
+    member x.Value = id
     static member Zero = uint256.Zero |> ChannelId