Mono-hop unidirectional payments

Author: canndrew

src/DotNetLightning.Core/Channel/Channel.fs

@@ -223,7 +223,7 @@ module Channel =
                                     RemoteNextHTLCId = HTLCId.Zero
                                     OriginChannels = Map.empty
                                     // we will receive their next per-commitment point in the next msg, so we temporarily put a random byte array
-                                    RemoteNextCommitInfo = DataEncoders.HexEncoder() .DecodeData("0101010101010101010101010101010101010101010101010101010101010101") |> Key |> fun k -> k.PubKey |> Choice2Of2
+                                    RemoteNextCommitInfo = DataEncoders.HexEncoder() .DecodeData("0101010101010101010101010101010101010101010101010101010101010101") |> Key |> fun k -> k.PubKey |> RemoteNextCommitInfo.Revoked
                                     RemotePerCommitmentSecrets = ShaChain.Zero
                                     ChannelId =
                                         msg.ChannelId }
@@ -316,7 +316,7 @@ module Channel =
                                     LocalNextHTLCId = HTLCId.Zero
                                     RemoteNextHTLCId = HTLCId.Zero
                                     OriginChannels = Map.empty
-                                    RemoteNextCommitInfo = DataEncoders.HexEncoder() .DecodeData("0101010101010101010101010101010101010101010101010101010101010101") |> Key |> fun k -> k.PubKey |> Choice2Of2
+                                    RemoteNextCommitInfo = DataEncoders.HexEncoder() .DecodeData("0101010101010101010101010101010101010101010101010101010101010101") |> Key |> fun k -> k.PubKey |> RemoteNextCommitInfo.Revoked
                                     RemotePerCommitmentSecrets = ShaChain.Zero
                                     ChannelId = channelId }
                 let nextState = { WaitForFundingConfirmedData.Commitments = commitments
@@ -376,7 +376,7 @@ module Channel =
                                                true,
                                                None)
                 let nextState = { NormalData.Buried = true
-                                  Commitments = { state.Commitments with RemoteNextCommitInfo = Choice2Of2(msg.NextPerCommitmentPoint) }
+                                  Commitments = { state.Commitments with RemoteNextCommitInfo = RemoteNextCommitInfo.Revoked(msg.NextPerCommitmentPoint) }
                                   ShortChannelId = state.ShortChannelId
                                   ChannelAnnouncement = None
                                   ChannelUpdate = initialChannelUpdate
@@ -388,6 +388,32 @@ module Channel =
                 [] |> Ok
 
         // ---------- normal operation ---------
+        | ChannelState.Normal state, MonoHopUnidirectionalPayment cmd when state.LocalShutdown.IsSome || state.RemoteShutdown.IsSome ->
+            sprintf "Could not send mono-hop unidirectional payment %A since shutdown is already in progress." cmd
+            |> apiMisuse
+        | ChannelState.Normal state, MonoHopUnidirectionalPayment cmd ->
+            result {
+                let payment: MonoHopUnidirectionalPayment = {
+                    ChannelId = state.Commitments.ChannelId
+                    Amount = cmd.Amount
+                }
+                let commitments1 = state.Commitments.AddLocalProposal(payment)
+
+                let remoteCommit1 =
+                    match commitments1.RemoteNextCommitInfo with
+                    | RemoteNextCommitInfo.WaitingForRevocation info -> info.NextRemoteCommit
+                    | RemoteNextCommitInfo.Revoked _info -> commitments1.RemoteCommit
+                let! reduced = remoteCommit1.Spec.Reduce(commitments1.RemoteChanges.ACKed, commitments1.LocalChanges.Proposed) |> expectTransactionError
+                do! Validation.checkOurMonoHopUnidirectionalPaymentIsAcceptableWithCurrentSpec reduced commitments1 payment
+                return [ WeAcceptedCMDMonoHopUnidirectionalPayment(payment, commitments1) ]
+            }
+        | ChannelState.Normal state, ApplyMonoHopUnidirectionalPayment msg ->
+            result {
+                let commitments1 = state.Commitments.AddRemoteProposal(msg)
+                let! reduced = commitments1.LocalCommit.Spec.Reduce (commitments1.LocalChanges.ACKed, commitments1.RemoteChanges.Proposed) |> expectTransactionError
+                do! Validation.checkTheirMonoHopUnidirectionalPaymentIsAcceptableWithCurrentSpec reduced commitments1 msg
+                return [ WeAcceptedMonoHopUnidirectionalPayment commitments1 ]
+            }
         | ChannelState.Normal state, AddHTLC cmd when state.LocalShutdown.IsSome || state.RemoteShutdown.IsSome ->
             sprintf "Could not add new HTLC %A since shutdown is already in progress." cmd
             |> apiMisuse
@@ -409,8 +435,8 @@ module Channel =
                 // we need to base the next current commitment on the last sig we sent, even if we didn't yet receive their revocation
                 let remoteCommit1 =
                     match commitments1.RemoteNextCommitInfo with
-                    | Choice1Of2 info -> info.NextRemoteCommit
-                    | Choice2Of2 _info -> commitments1.RemoteCommit
+                    | RemoteNextCommitInfo.WaitingForRevocation info -> info.NextRemoteCommit
+                    | RemoteNextCommitInfo.Revoked _info -> commitments1.RemoteCommit
                 let! reduced = remoteCommit1.Spec.Reduce(commitments1.RemoteChanges.ACKed, commitments1.LocalChanges.Proposed) |> expectTransactionError
                 do! Validation.checkOurUpdateAddHTLCIsAcceptableWithCurrentSpec reduced commitments1 add
                 return [ WeAcceptedCMDAddHTLC(add, commitments1) ]
@@ -459,9 +485,9 @@ module Channel =
                 | _ when (cm.LocalHasChanges() |> not) ->
                     // Ignore SignCommitment Command (nothing to sign)
                     return []
-                | Choice2Of2 _ ->
+                | RemoteNextCommitInfo.Revoked _ ->
                     return! cm |> Commitments.sendCommit (cs.Secp256k1Context) (cs.KeysRepository) (cs.Network)
-                | Choice1Of2 _ ->
+                | RemoteNextCommitInfo.WaitingForRevocation _ ->
                     // Already in the process of signing
                     return []
             }
@@ -472,17 +498,17 @@ module Channel =
         | ChannelState.Normal state, ApplyRevokeAndACK msg ->
             let cm = state.Commitments
             match cm.RemoteNextCommitInfo with
-            | Choice1Of2 _ when (msg.PerCommitmentSecret.ToPubKey() <> cm.RemoteCommit.RemotePerCommitmentPoint) ->
+            | RemoteNextCommitInfo.WaitingForRevocation _ when (msg.PerCommitmentSecret.ToPubKey() <> cm.RemoteCommit.RemotePerCommitmentPoint) ->
                 let errorMsg = sprintf "Invalid revoke_and_ack %A; must be %A" msg.PerCommitmentSecret cm.RemoteCommit.RemotePerCommitmentPoint
                 invalidRevokeAndACK msg errorMsg
-            | Choice2Of2 _ ->
+            | RemoteNextCommitInfo.Revoked _ ->
                 let errorMsg = sprintf "Unexpected revocation"
                 invalidRevokeAndACK msg errorMsg
-            | Choice1Of2({ NextRemoteCommit = theirNextCommit }) ->
+            | RemoteNextCommitInfo.WaitingForRevocation({ NextRemoteCommit = theirNextCommit }) ->
                 let commitments1 = { cm with LocalChanges = { cm.LocalChanges with Signed = []; ACKed = cm.LocalChanges.ACKed @ cm.LocalChanges.Signed }
                                              RemoteChanges = { cm.RemoteChanges with Signed = [] }
                                              RemoteCommit = theirNextCommit
-                                             RemoteNextCommitInfo = Choice2Of2(msg.NextPerCommitmentPoint)
+                                             RemoteNextCommitInfo = RemoteNextCommitInfo.Revoked(msg.NextPerCommitmentPoint)
                                              RemotePerCommitmentSecrets = cm.RemotePerCommitmentSecrets.AddHash (msg.PerCommitmentSecret.ToByteArray(), 0xffffffffffffUL - cm.RemoteCommit.Index) }
                 let result = [ WeAcceptedRevokeAndACK(commitments1) ]
                 result |> Ok
@@ -528,12 +554,12 @@ module Channel =
                         // Are we in the middle of a signature?
                         match cm.RemoteNextCommitInfo with
                         // yes.
-                        | Choice1Of2 waitingForRevocation ->
+                        | RemoteNextCommitInfo.WaitingForRevocation waitingForRevocation ->
                             let nextCommitments = { state.Commitments with
-                                                        RemoteNextCommitInfo = Choice1Of2({ waitingForRevocation with ReSignASAP = true }) }
+                                                        RemoteNextCommitInfo = RemoteNextCommitInfo.WaitingForRevocation({ waitingForRevocation with ReSignASAP = true }) }
                             return [ AcceptedShutdownWhileWeHaveUnsignedOutgoingHTLCs(msg, nextCommitments) ]
                         // No. let's sign right away.
-                        | Choice2Of2 _ ->
+                        | RemoteNextCommitInfo.Revoked _ ->
                             return [ ChannelStateRequestedSignCommitment; AcceptedShutdownWhileWeHaveUnsignedOutgoingHTLCs(msg, cm) ]
                 else
                     let (localShutdown, sendList) = match state.LocalShutdown with
@@ -600,9 +626,9 @@ module Channel =
             | _ when (not <| cm.LocalHasChanges()) ->
                 // nothing to sign
                 [] |> Ok
-            | Choice2Of2 _ ->
+            | RemoteNextCommitInfo.Revoked _ ->
                 cm |> Commitments.sendCommit (cs.Secp256k1Context) (cs.KeysRepository) (cs.Network)
-            | Choice1Of2 _waitForRevocation ->
+            | RemoteNextCommitInfo.WaitingForRevocation _waitForRevocation ->
                 // Already in the process of signing.
                 [] |> Ok
         | Shutdown state, ApplyCommitmentSigned msg ->
@@ -730,8 +756,12 @@ module Channel =
             { c with State = ChannelState.Normal data }
 
         // ----- normal operation --------
+        | WeAcceptedCMDMonoHopUnidirectionalPayment(_, newCommitments), ChannelState.Normal d ->
+            { c with State = ChannelState.Normal({ d with Commitments = newCommitments }) }
         | WeAcceptedCMDAddHTLC(_, newCommitments), ChannelState.Normal d ->
             { c with State = ChannelState.Normal({ d with Commitments = newCommitments }) }
+        | WeAcceptedMonoHopUnidirectionalPayment(newCommitments), ChannelState.Normal d ->
+            { c with State = ChannelState.Normal({ d with Commitments = newCommitments }) }
         | WeAcceptedUpdateAddHTLC(newCommitments), ChannelState.Normal d ->
             { c with State = ChannelState.Normal({ d with Commitments = newCommitments }) }
 

src/DotNetLightning.Core/Channel/ChannelCommands.fs

@@ -21,6 +21,10 @@ open NBitcoin
 //      Y88b  d88P Y88b. .d88P 888   "   888 888   "   888  d8888888888 888   Y8888 888  .d88P Y88b  d88P
 //       "Y8888P"   "Y88888P"  888       888 888       888 d88P     888 888    Y888 8888888P"   "Y8888P"
 
+type CMDMonoHopUnidirectionalPayment = {
+    Amount: LNMoney
+}
+
 type CMDAddHTLC = {
     AmountMSat: LNMoney
     PaymentHash: PaymentHash
@@ -206,6 +210,8 @@ type ChannelCommand =
     | CreateChannelReestablish
 
     // normal
+    | MonoHopUnidirectionalPayment of CMDMonoHopUnidirectionalPayment
+    | ApplyMonoHopUnidirectionalPayment of msg: MonoHopUnidirectionalPayment
     | AddHTLC of CMDAddHTLC
     | ApplyUpdateAddHTLC of msg: UpdateAddHTLC * currentHeight: BlockHeight
     | FulfillHTLC of CMDFulfillHTLC
@@ -229,4 +235,4 @@ type ChannelCommand =
     // else
     | ForceClose
     | GetState
-    | GetStateData
+    | GetStateData

src/DotNetLightning.Core/Channel/ChannelError.fs

@@ -36,6 +36,7 @@ type ChannelError =
     // --- case they sent unacceptable msg ---
     | InvalidOpenChannel of InvalidOpenChannelError
     | InvalidAcceptChannel of InvalidAcceptChannelError
+    | InvalidMonoHopUnidirectionalPayment of InvalidMonoHopUnidirectionalPaymentError
     | InvalidUpdateAddHTLC of InvalidUpdateAddHTLCError
     | InvalidRevokeAndACK of InvalidRevokeAndACKError
     | InvalidUpdateFee of InvalidUpdateFeeError
@@ -69,6 +70,7 @@ type ChannelError =
         | TheyCannotAffordFee (_, _, _) -> Close
         | InvalidOpenChannel _ -> DistrustPeer
         | InvalidAcceptChannel _ -> DistrustPeer
+        | InvalidMonoHopUnidirectionalPayment _ -> Close
         | InvalidUpdateAddHTLC _ -> Close
         | InvalidRevokeAndACK _ -> Close
         | InvalidUpdateFee _ -> Close
@@ -145,6 +147,15 @@ and InvalidAcceptChannelError = {
         Errors = e
     }
 
+and InvalidMonoHopUnidirectionalPaymentError = {
+    Msg: MonoHopUnidirectionalPayment
+    Errors: string list
+}
+    with
+    static member Create msg e = {
+        Msg = msg
+        Errors = e
+    }
 and InvalidUpdateAddHTLCError = {
     Msg: UpdateAddHTLC
     Errors: string list
@@ -458,6 +469,18 @@ module internal AcceptChannelMsgValidation =
 
         (check1 |> Validation.ofResult) *^> check2 *^> check3 *^> check4 *^> check5 *^> check6 *^> check7
 
+module UpdateMonoHopUnidirectionalPaymentWithContext =
+    let internal checkWeHaveSufficientFunds (state: Commitments) (currentSpec) =
+        let fees = if (state.LocalParams.IsFunder) then (Transactions.commitTxFee (state.RemoteParams.DustLimitSatoshis) currentSpec) else Money.Zero
+        let missing = currentSpec.ToRemote.ToMoney() - state.RemoteParams.ChannelReserveSatoshis - fees
+        if (missing < Money.Zero) then
+            sprintf "We don't have sufficient funds to send mono-hop unidirectional payment. current to_remote amount is: %A. Remote Channel Reserve is: %A. and fee is %A"
+                    (currentSpec.ToRemote.ToMoney())
+                    (state.RemoteParams.ChannelReserveSatoshis)
+                    (fees)
+            |> Error
+        else
+            Ok()
 
 module UpdateAddHTLCValidation =
     let internal checkExpiryIsNotPast (current: BlockHeight) (expiry) =
@@ -472,7 +495,23 @@ module UpdateAddHTLCValidation =
     let internal checkAmountIsLargerThanMinimum (htlcMinimum: LNMoney) (amount) =
         check (amount) (<) (htlcMinimum) "htlc value (%A) is too small. must be greater or equal to %A"
 
-    
+module internal MonoHopUnidirectionalPaymentValidationWithContext =
+    let checkWeHaveSufficientFunds (state: Commitments) (currentSpec) =
+        let fees =
+            if state.LocalParams.IsFunder then
+                Transactions.commitTxFee state.RemoteParams.DustLimitSatoshis currentSpec
+            else
+                Money.Zero
+        let missing = currentSpec.ToRemote.ToMoney() - state.RemoteParams.ChannelReserveSatoshis - fees
+        if (missing < Money.Zero) then
+            sprintf "We don't have sufficient funds to send mono-hop unidirectional payment. current to_remote amount is: %A. Remote Channel Reserve is: %A. and fee is %A"
+                    (currentSpec.ToRemote.ToMoney())
+                    (state.RemoteParams.ChannelReserveSatoshis)
+                    (fees)
+            |> Error
+        else
+            Ok()
+
 module internal UpdateAddHTLCValidationWithContext =
     let checkLessThanHTLCValueInFlightLimit (currentSpec: CommitmentSpec) (limit) (add: UpdateAddHTLC) =
         let htlcValueInFlight = currentSpec.HTLCs |> Map.toSeq |> Seq.sumBy (fun (_, v) -> v.Add.AmountMSat)

src/DotNetLightning.Core/Channel/ChannelTypes.fs

@@ -264,6 +264,9 @@ type ChannelEvent =
     | BothFundingLocked of nextState: Data.NormalData
 
     // -------- normal operation ------
+    | WeAcceptedCMDMonoHopUnidirectionalPayment of msg: MonoHopUnidirectionalPayment * newCommitments: Commitments
+    | WeAcceptedMonoHopUnidirectionalPayment of newCommitments: Commitments
+
     | WeAcceptedCMDAddHTLC of msg: UpdateAddHTLC * newCommitments: Commitments
     | WeAcceptedUpdateAddHTLC of newCommitments: Commitments
 

src/DotNetLightning.Core/Channel/ChannelValidation.fs

@@ -169,6 +169,13 @@ module internal Validation =
         *> AcceptChannelMsgValidation.checkConfigPermits conf.PeerChannelConfigLimits msg
         |> Result.mapError(InvalidAcceptChannelError.Create msg >> InvalidAcceptChannel)
 
+    let checkOurMonoHopUnidirectionalPaymentIsAcceptableWithCurrentSpec (currentSpec) (state: Commitments) (payment: MonoHopUnidirectionalPayment) =
+        Validation.ofResult(MonoHopUnidirectionalPaymentValidationWithContext.checkWeHaveSufficientFunds state currentSpec)
+        |> Result.mapError(InvalidMonoHopUnidirectionalPaymentError.Create payment >> InvalidMonoHopUnidirectionalPayment)
+
+    let checkTheirMonoHopUnidirectionalPaymentIsAcceptableWithCurrentSpec (currentSpec) (state: Commitments) (payment: MonoHopUnidirectionalPayment) =
+        Validation.ofResult(MonoHopUnidirectionalPaymentValidationWithContext.checkWeHaveSufficientFunds state currentSpec)
+        |> Result.mapError(InvalidMonoHopUnidirectionalPaymentError.Create payment >> InvalidMonoHopUnidirectionalPayment)
 
     let checkCMDAddHTLC (state: NormalData) (cmd: CMDAddHTLC) =
         Validation.ofResult(UpdateAddHTLCValidation.checkExpiryIsNotPast cmd.CurrentHeight cmd.Expiry)

src/DotNetLightning.Core/Channel/Commitments.fs

@@ -88,6 +88,30 @@ type WaitingForRevocation = {
             (fun w -> w.ReSignASAP),
             (fun v w -> { w with ReSignASAP = v })
 
+type RemoteNextCommitInfo =
+    | WaitingForRevocation of WaitingForRevocation
+    | Revoked of PubKey
+    with
+        static member WaitingForRevocation_: Prism<RemoteNextCommitInfo, WaitingForRevocation> =
+            (fun remoteNextCommitInfo ->
+                match remoteNextCommitInfo with
+                | WaitingForRevocation waitingForRevocation -> Some waitingForRevocation
+                | Revoked _ -> None),
+            (fun waitingForRevocation remoteNextCommitInfo ->
+                match remoteNextCommitInfo with
+                | WaitingForRevocation _ -> WaitingForRevocation waitingForRevocation
+                | Revoked _ -> remoteNextCommitInfo)
+
+        static member Revoked_: Prism<RemoteNextCommitInfo, PubKey> =
+            (fun remoteNextCommitInfo ->
+                match remoteNextCommitInfo with
+                | WaitingForRevocation _ -> None
+                | Revoked pubKey -> Some pubKey),
+            (fun pubKey remoteNextCommitInfo ->
+                match remoteNextCommitInfo with
+                | WaitingForRevocation _ -> remoteNextCommitInfo
+                | Revoked pubKey -> Revoked pubKey)
+
 type Commitments = {
     LocalParams: LocalParams
     RemoteParams: RemoteParams
@@ -100,7 +124,7 @@ type Commitments = {
     LocalNextHTLCId: HTLCId
     RemoteNextHTLCId: HTLCId
     OriginChannels: Map<HTLCId, HTLCSource>
-    RemoteNextCommitInfo: Choice<WaitingForRevocation, PubKey>
+    RemoteNextCommitInfo: RemoteNextCommitInfo
     RemotePerCommitmentSecrets: ShaChain
     ChannelId: ChannelId
 }
@@ -140,15 +164,18 @@ type Commitments = {
             this.RemoteChanges.Proposed |> List.exists(fun p -> match p with | :? UpdateAddHTLC -> true | _ -> false)
 
         member internal this.HasNoPendingHTLCs() =
-            this.LocalCommit.Spec.HTLCs.IsEmpty && this.RemoteCommit.Spec.HTLCs.IsEmpty && (this.RemoteNextCommitInfo |> function Choice1Of2 _ -> false | Choice2Of2 _ -> true)
+            this.LocalCommit.Spec.HTLCs.IsEmpty && this.RemoteCommit.Spec.HTLCs.IsEmpty && (this.RemoteNextCommitInfo |> function WaitingForRevocation _ -> false | Revoked _ -> true)
 
         member internal this.GetHTLCCrossSigned(directionRelativeToLocal: Direction, htlcId: HTLCId): UpdateAddHTLC option =
             let remoteSigned =
                 this.LocalCommit.Spec.HTLCs
                 |> Map.tryPick (fun k v -> if v.Direction = directionRelativeToLocal && v.Add.HTLCId = htlcId then Some v else None)
 
             let localSigned =
-                let lens = Commitments.RemoteNextCommitInfo_ >-> Choice.choice1Of2_ >?> WaitingForRevocation.NextRemoteCommit_
+                let lens =
+                    Commitments.RemoteNextCommitInfo_
+                    >-> RemoteNextCommitInfo.WaitingForRevocation_
+                    >?> WaitingForRevocation.NextRemoteCommit_
                 match Optic.get lens this with
                 | Some v -> v
                 | None -> this.RemoteCommit