removes coin selection and conduit dependency

Author: ProofOfKeags

bitcoin.cabal

@@ -101,7 +101,6 @@ library
     , bytes >=0.17
     , bytestring >=0.10.10.0
     , cereal >=0.5.8
-    , conduit >=1.3.1.2
     , containers >=0.6.2.1
     , cryptonite >=0.26
     , deepseq >=1.4.4.0
@@ -158,7 +157,6 @@ test-suite spec
     , bytes >=0.17
     , bytestring >=0.10.10.0
     , cereal >=0.5.8
-    , conduit >=1.3.1.2
     , containers >=0.6.2.1
     , cryptonite >=0.26
     , deepseq >=1.4.4.0

package.yaml

@@ -27,7 +27,6 @@ dependencies:
   - bytes >= 0.17
   - bytestring >= 0.10.10.0
   - cereal >= 0.5.8
-  - conduit >= 1.3.1.2
   - containers >= 0.6.2.1
   - cryptonite >= 0.26
   - deepseq >= 1.4.4.0

src/Bitcoin/Transaction/Builder.hs

@@ -28,12 +28,7 @@ module Bitcoin.Transaction.Builder (
 
     -- * Coin Selection
     Coin (..),
-    chooseCoins,
-    chooseCoinsSink,
-    chooseMSCoins,
-    chooseMSCoinsSink,
     countMulSig,
-    greedyAddSink,
     guessTxFee,
     guessMSTxFee,
     guessTxSize,
@@ -49,14 +44,6 @@ import qualified Data.ByteString as B
 import Data.Bytes.Get
 import Data.Bytes.Put
 import Data.Bytes.Serial
-import Data.Conduit (
-    ConduitT,
-    Void,
-    await,
-    runConduit,
-    (.|),
- )
-import Data.Conduit.List (sourceList)
 import Data.Either (fromRight)
 import Data.List (nub)
 import Data.Maybe (catMaybes, fromJust, isJust)
@@ -92,163 +79,6 @@ class Coin c where
     coinValue :: c -> Word64
 
 
--- | Coin selection algorithm for normal (non-multisig) transactions. This
--- function returns the selected coins together with the amount of change to
--- send back to yourself, taking the fee into account.
-chooseCoins ::
-    Coin c =>
-    -- | value to send
-    Word64 ->
-    -- | fee per byte
-    Word64 ->
-    -- | number of outputs (including change)
-    Int ->
-    -- | try to find better solutions
-    Bool ->
-    -- | list of ordered coins to choose from
-    [c] ->
-    -- | coin selection and change
-    Either String ([c], Word64)
-chooseCoins target fee nOut continue coins =
-    runIdentity . runConduit $
-        sourceList coins .| chooseCoinsSink target fee nOut continue
-
-
--- | Coin selection algorithm for normal (non-multisig) transactions. This
--- function returns the selected coins together with the amount of change to
--- send back to yourself, taking the fee into account. This version uses a Sink
--- for conduit-based coin selection.
-chooseCoinsSink ::
-    (Monad m, Coin c) =>
-    -- | value to send
-    Word64 ->
-    -- | fee per byte
-    Word64 ->
-    -- | number of outputs (including change)
-    Int ->
-    -- | try to find better solution
-    Bool ->
-    -- | coin selection and change
-    ConduitT c Void m (Either String ([c], Word64))
-chooseCoinsSink target fee nOut continue
-    | target > 0 =
-        maybeToEither err
-            <$> greedyAddSink target (guessTxFee fee nOut) continue
-    | otherwise = return $ Left "chooseCoins: Target must be > 0"
-  where
-    err = "chooseCoins: No solution found"
-
-
--- | Coin selection algorithm for multisig transactions. This function returns
--- the selected coins together with the amount of change to send back to
--- yourself, taking the fee into account. This function assumes all the coins
--- are script hash outputs that send funds to a multisignature address.
-chooseMSCoins ::
-    Coin c =>
-    -- | value to send
-    Word64 ->
-    -- | fee per byte
-    Word64 ->
-    -- | m of n multisig
-    (Int, Int) ->
-    -- | number of outputs (including change)
-    Int ->
-    -- | try to find better solution
-    Bool ->
-    [c] ->
-    -- | coin selection change amount
-    Either String ([c], Word64)
-chooseMSCoins target fee ms nOut continue coins =
-    runIdentity . runConduit $
-        sourceList coins .| chooseMSCoinsSink target fee ms nOut continue
-
-
--- | Coin selection algorithm for multisig transactions. This function returns
--- the selected coins together with the amount of change to send back to
--- yourself, taking the fee into account. This function assumes all the coins
--- are script hash outputs that send funds to a multisignature address. This
--- version uses a Sink if you need conduit-based coin selection.
-chooseMSCoinsSink ::
-    (Monad m, Coin c) =>
-    -- | value to send
-    Word64 ->
-    -- | fee per byte
-    Word64 ->
-    -- | m of n multisig
-    (Int, Int) ->
-    -- | number of outputs (including change)
-    Int ->
-    -- | try to find better solution
-    Bool ->
-    -- | coin selection and change
-    ConduitT c Void m (Either String ([c], Word64))
-chooseMSCoinsSink target fee ms nOut continue
-    | target > 0 =
-        maybeToEither err
-            <$> greedyAddSink target (guessMSTxFee fee ms nOut) continue
-    | otherwise = return $ Left "chooseMSCoins: Target must be > 0"
-  where
-    err = "chooseMSCoins: No solution found"
-
-
--- | Select coins greedily by starting from an empty solution. If the 'continue'
--- flag is set, the algorithm will try to find a better solution in the stream
--- after a solution is found. If the next solution found is not strictly better
--- than the previously found solution, the algorithm stops and returns the
--- previous solution. If the continue flag is not set, the algorithm will return
--- the first solution it finds in the stream.
-greedyAddSink ::
-    (Monad m, Coin c) =>
-    -- | value to send
-    Word64 ->
-    -- | coin count to fee function
-    (Int -> Word64) ->
-    -- | try to find better solutions
-    Bool ->
-    -- | coin selection and change
-    ConduitT c Void m (Maybe ([c], Word64))
-greedyAddSink target guessFee continue =
-    go [] 0 [] 0
-  where
-    -- The goal is the value we must reach (including the fee) for a certain
-    -- amount of selected coins.
-    goal c = target + guessFee c
-    go acc aTot ps pTot =
-        await >>= \case
-            -- A coin is available in the stream
-            Just coin -> do
-                let val = coinValue coin
-                -- We have reached the goal using this coin
-                if val + aTot >= goal (length acc + 1)
-                    then -- If we want to continue searching for better solutions
-
-                        if continue
-                            then -- This solution is the first one or
-                            -- This solution is better than the previous one
-
-                                if pTot == 0 || val + aTot < pTot
-                                    then -- Continue searching for better solutions in the stream
-                                        go [] 0 (coin : acc) (val + aTot)
-                                    else -- Otherwise, we stop here and return the previous
-                                    -- solution
-                                        return $ Just (ps, pTot - goal (length ps))
-                            else -- Otherwise, return this solution
-
-                                return $
-                                    Just (coin : acc, val + aTot - goal (length acc + 1))
-                    else -- We have not yet reached the goal. Add the coin to the
-                    -- accumulator
-                        go (coin : acc) (val + aTot) ps pTot
-            -- We reached the end of the stream
-            Nothing ->
-                return $
-                    if null ps
-                        then -- If no solution was found, return Nothing
-                            Nothing
-                        else -- If we have a solution, return it
-                            Just (ps, pTot - goal (length ps))
-
-
 -- | Estimate tranasction fee to pay based on transaction size estimation.
 guessTxFee :: Word64 -> Int -> Int -> Word64
 guessTxFee byteFee nOut nIn =