quixotic-payouts.cfg

Setup

      - user creates account & provides payout address
      - inviting user asked to sign a txn that transfers a specific amount of btc from their
      - current payout address to the invitee's payout address

    * Update Payout Address
      - authenticate by asking the user to sign and broadcast a small txn with a specific
      - amount from the old address to the new address

# This file was auto-generated by cabal2nix. Please do NOT edit manually!
{ haskellPackages ? (import <nixpkgs> {}).haskellPackages }:
#{ cabal, aeson, bifunctors, classyPrelude
#, configurator, either, errors, groups, hourglass, hspec, lens
#, MonadCatchIOTransformers, mtl, networkBitcoin
#, optparseApplicative, safe, snapCore, snapServer, sqliteSimple
#, text, time, transformers
#}:
with haskellPackages; cabal.mkDerivation (self: {
  pname = "quixotic";
  version = "0.1";
  src = "./.";
  isLibrary = true;
  isExecutable = true;
  #buildTools = [ cabalInstall ];
  buildDepends = [
    aeson bifunctors classyPrelude configurator either
    errors groups hourglass lens MonadCatchIOTransformers mtl
    networkBitcoin optparseApplicative safe snapCore snapServer
    sqliteSimple text time transformers
  ];
  testDepends = [ aeson hspec text time ];
  meta = {
    description = "The Quixotic Collaboration Platform";
    license = self.stdenv.lib.licenses.unfree;
    platforms = self.ghc.meta.platforms;
  };
})

{-# LANGUAGE ScopedTypeVariables, OverloadedStrings, NoImplicitPrelude #-}
module Main where
import ClassyPrelude 
import Network.Bitcoin
import Control.Concurrent
import qualified Data.Configurator as C
import qualified Data.Vector as V
main :: IO ()
main = do
  cfg <- parseConfig "quixotic-payouts.cfg"
  loop cfg
loop :: QPConfig -> IO ()
loop cfg = do
  threadDelay (pollingInterval cfg)
  distributePayouts cfg
  loop cfg
data QPConfig = QPConfig
  { pollingInterval :: Int
  , bitcoindUrl :: Text
  , bitcoindUser :: Text
  , bitcoindPassword :: Text
  , payoutMinConfirmations :: Int
  } 
parseConfig :: FilePath -> IO QPConfig
parseConfig cfgFile = do 
  cfg <- C.load [C.Required (fpToString cfgFile)]
  QPConfig <$> C.require cfg "pollingInterval" 
           <*> C.require cfg "bitcoindUrl" 
           <*> C.require cfg "bitcoindUser" 
           <*> C.require cfg "bitcoindPassword" 
           <*> C.require cfg "payoutMinConfirmations" 
auth :: QPConfig -> Auth
auth = Auth <$> bitcoindUrl <*> bitcoindUser <*> bitcoindPassword 
distributePayouts :: QPConfig -> IO ()
distributePayouts cfg = do
  -- find unspent transactions
  unspent <- listUnspent (auth cfg) (Just . payoutMinConfirmations $ cfg) Nothing V.empty 
  putStrLn $ tshow unspent
  -- get payouts amounts
  -- create a new txn spending all UTXOs to payouts

pollingInterval = 10000000
bitcoindUrl = "http://localhost:18444/"
bitcoindUser = ""
bitcoindPassword = ""

Cabal-version: >= 1.20

Cabal-version: >= 1.18

    , bifunctors

    , cassandra-cql        >= 0.4.0.1

    , bifunctors

    , classy-prelude

    , bifunctors

    , iso8601-time

    , configurator              == 0.2.*
    , optparse-applicative      >= 0.9.0 && < 0.10

    , configurator              
    , optparse-applicative      

Executable quixotic-payouts
  default-language:   Haskell2010
  ghc-options:        -Wall -Werror
  hs-source-dirs:     payouts
  main-is:            Main.hs
  build-depends:      
      quixotic
    , base
    , classy-prelude            >= 0.10.2
    , containers
    , either
    , mtl                       >= 2     && < 3
    , lens
    , text
    , time
    , vector
    , transformers
    , configurator
    , optparse-applicative
    , bytestring
    , network-bitcoin
  

import Control.Arrow
--import Control.Monad

import Data.Bifunctor as B
import Data.Maybe
--import Data.Monoid

          expected = fmap StartWork $ parseISO8601 "2014-03-22T11:37:08Z"

          expected = fmap (WorkEvent StartWork) $ parseISO8601 "2014-03-22T11:37:08Z"

            [ LogEntry addr (StartWork start'), LogEntry addr (StopWork end') ]

            [ LogEntry addr (WorkEvent StartWork start'), LogEntry addr (WorkEvent StopWork end') ]

          expected = M.map (bimap (fmap event) (fmap workInterval)) expected0

          expected = M.map (bimap (fmap _event) (fmap workInterval)) expected0

      (intervals testLogEntries) `shouldBe` expected

      (workIndex testLogEntries) `shouldBe` expected