Mono-hop unidirectional payments

Author: canndrew

.github/workflows/ci.yml

@@ -36,7 +36,8 @@ jobs:
     - name: Upload nuget packages (BouncyCastle and native)
       run: |
         cd $GITHUB_WORKSPACE/src/DotNetLightning.Core
-        if [ ${{ secrets.NUGET_API_KEY }} ] && [ $GITHUB_REF == "refs/heads/master" ]; then
-            dotnet nuget push ./bin/Release/DotNetLightning.1*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json
-            dotnet nuget push ./bin/Release/DotNetLightning.Core.1*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json
+        if [ ${{ secrets.NUGET_API_KEY }} ]; then
+            dotnet nuget push ./bin/Release/DotNetLightning.Kiss.1*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json
+            #dotnet nuget push ./bin/Release/DotNetLightning.1*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json
+            #dotnet nuget push ./bin/Release/DotNetLightning.Core.1*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json
         fi

fsc.props

@@ -14,7 +14,7 @@
     <FscToolPath>/Library/Frameworks/Mono.framework/Versions/Current/Commands</FscToolPath>
     <FscToolExe>fsharpc</FscToolExe>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(IsLinux)' == 'true' AND Exists('/usr/bin/fsharpc')">
+  <PropertyGroup Condition="'$(IsLinux)' == 'true' AND Exists('/usr/bin/fsharpc') AND !Exists('/usr/share/dotnet/dotnet')">
     <FscToolPath>/usr/bin</FscToolPath>
     <FscToolExe>fsharpc</FscToolExe>
   </PropertyGroup>

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
 
@@ -355,6 +358,26 @@ type ChannelState =
             (fun v cc -> match cc with
                          | Normal _ -> Normal v
                          | _ -> cc )
+        member this.ChannelId: Option<ChannelId> =
+            match this with
+            | WaitForInitInternal
+            | WaitForOpenChannel _
+            | WaitForAcceptChannel _
+            | WaitForFundingCreated _ -> None
+            | WaitForFundingSigned data -> Some data.ChannelId
+            | WaitForFundingConfirmed data -> Some data.ChannelId
+            | WaitForFundingLocked data -> Some data.ChannelId
+            | Normal data -> Some data.ChannelId
+            | Shutdown data -> Some data.ChannelId
+            | Negotiating data -> Some data.ChannelId
+            | Closing data -> Some data.ChannelId
+            | Closed _
+            | Offline _
+            | Syncing _
+            | ErrFundingLost _
+            | ErrFundingTimeOut _
+            | ErrInformationLeak _ -> None
+
         member this.Phase =
             match this with
             | WaitForInitInternal

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)