[DEVOPS-834] withdrawl -> withdrawal

Author: Ben Ford

faucet/src/Cardano/Faucet.hs

@@ -38,8 +38,8 @@ import qualified Cardano.WalletClient as Client
 
 -- | Top level type of the faucet API
 type FaucetAPI = "withdraw" :> Summary "Requests ADA from the faucet"
-                            :> ReqBody '[FormUrlEncoded, JSON] WithdrawlRequest
-                            :> Post '[JSON] WithdrawlResult
+                            :> ReqBody '[FormUrlEncoded, JSON] WithdrawalRequest
+                            :> Post '[JSON] WithdrawalResult
             :<|> "return-address" :> Summary "Get the address to return ADA to"
                                   :> Get '[JSON] (V1 Address)
             :<|> Raw
@@ -48,8 +48,8 @@ type FaucetAPI = "withdraw" :> Summary "Requests ADA from the faucet"
 faucetServerAPI :: Proxy FaucetAPI
 faucetServerAPI = Proxy
 
--- | Handler for the withdrawl of ADA from the faucet
-withdraw :: (MonadFaucet c m) => WithdrawlRequest -> m WithdrawlResult
+-- | Handler for the withdrawal of ADA from the faucet
+withdraw :: (MonadFaucet c m) => WithdrawalRequest -> m WithdrawalResult
 withdraw wr = withSublogger (LoggerName "withdraw") $ do
     logInfo "Attempting to send ADA"
     mCaptchaSecret <- view (feFaucetConfig . fcRecaptchaSecret)
@@ -64,15 +64,15 @@ withdraw wr = withSublogger (LoggerName "withdraw") $ do
     resp <- Client.withdraw (wr ^. wAddress)
     case resp of
         Left _ -> do
-            logError "Withdrawl queue is full"
-            throwError $ err503 { errBody = "Withdrawl queue is full" }
+            logError "Withdrawal queue is full"
+            throwError $ err503 { errBody = "Withdrawal queue is full" }
         Right wdResp -> do
-            for_ (wdResp ^? _WithdrawlSuccess) $ \txn -> do
+            for_ (wdResp ^? _WithdrawalSuccess) $ \txn -> do
               let amount = unV1 $ txAmount txn
               logInfo ((txn ^. to show . packed) <> " withdrew: "
                                                 <> (amount ^. to show . packed))
               incWithDrawn amount
-            for_ (wdResp  ^? _WithdrawlError) $ \err -> do
+            for_ (wdResp  ^? _WithdrawalError) $ \err -> do
                 logError ("Error from wallet: " <> err)
                 throwError $ err503 { errBody = (fromStrict err) ^. re utf8 }
             return wdResp

faucet/src/Cardano/Faucet/Init.hs

@@ -300,15 +300,15 @@ makeInitializedWallet fc client = withSublogger "makeInitializedWallet" $ do
         left = return . Left
 
 --------------------------------------------------------------------------------
--- | Process withdrawls requested from the 'feWithdrawlQ'
+-- | Process withdrawals requested from the 'feWithdrawalQ'
 --
 -- On receiving a 'ProcessorPayload' 'postTransaction' is used to send the
--- 'Payment' and the resulting 'Transaction' is wrapped in a 'WithdrawlResult'
+-- 'Payment' and the resulting 'Transaction' is wrapped in a 'WithdrawalResult'
 -- and put into the provided 'TMVar'
-processWithdrawls :: FaucetEnv -> LoggerNameBox IO ()
-processWithdrawls fEnv = withSublogger "processWithdrawls" $ forever $ do
+processWithdrawals :: FaucetEnv -> LoggerNameBox IO ()
+processWithdrawals fEnv = withSublogger "processWithdrawals" $ forever $ do
     let wc = fEnv ^. feWalletClient
-        pmtQ = fEnv ^. feWithdrawlQ
+        pmtQ = fEnv ^. feWithdrawalQ
     logInfo "Waiting for next payment"
     (ProcessorPayload pmt tVarResult)<- liftIOA $ TBQ.readTBQueue pmtQ
     logInfo "Processing payment"
@@ -319,14 +319,14 @@ processWithdrawls fEnv = withSublogger "processWithdrawls" $ forever $ do
             logError ("Error sending to " <> (showPmt pmt)
                                           <> " error: "
                                           <> txtErr)
-            liftIOA $ putTMVar tVarResult (WithdrawlError txtErr)
+            liftIOA $ putTMVar tVarResult (WithdrawalError txtErr)
         Right withDrawResp -> do
             let txn = wrData withDrawResp
                 amount = unV1 $ txAmount txn
             logInfo ((withDrawResp ^. to (show . wrStatus) . packed)
                     <> " withdrew: "
                     <> (amount ^. to show . packed))
-            liftIOA $ putTMVar tVarResult (WithdrawlSuccess txn)
+            liftIOA $ putTMVar tVarResult (WithdrawalSuccess txn)
     where
       liftIOA = liftIO . atomically
       showPmt = toStrict . encodeToLazyText . pdAddress . NonEmpty.head . pmtDestinations
@@ -339,9 +339,9 @@ initEnv fc store = do
     withSublogger "initEnv" $ logInfo "Initializing environment"
     env <- createEnv
     withSublogger "initEnv" $ logInfo "Created environment"
-    wdTId <- liftLogIO forkIO $ processWithdrawls env
+    wdTId <- liftLogIO forkIO $ processWithdrawals env
     withSublogger "initEnv"
-        $ logInfo ( "Forked thread for processing withdrawls:"
+        $ logInfo ( "Forked thread for processing withdrawals:"
                  <> show wdTId ^. packed)
     monTId <- liftLogIO forkIO $ monitorWalletBalance env
     withSublogger "initEnv"

faucet/src/Cardano/Faucet/Metrics.hs

@@ -28,7 +28,7 @@ import           Cardano.Faucet.Types
 import           Pos.Core (Coin (..))
 
 --------------------------------------------------------------------------------
--- | Record a withdrawl
+-- | Record a withdrawal
 --
 -- * Adds to 'feWithDrawn' 'Counter'
 -- * Increments 'feNumWithDrawn' 'Counter'

faucet/src/Cardano/Faucet/Types/API.hs

@@ -11,12 +11,12 @@
 {-# LANGUAGE TypeFamilies          #-}
 {-# OPTIONS_GHC -Wall #-}
 module Cardano.Faucet.Types.API (
-   WithdrawlRequest(..), wAddress, gRecaptchaResponse
- , WithdrawlResult(..), _WithdrawlError, _WithdrawlSuccess
+   WithdrawalRequest(..), wAddress, gRecaptchaResponse
+ , WithdrawalResult(..), _WithdrawalError, _WithdrawalSuccess
  , DepositRequest(..), dWalletId, dAmount
  , DepositResult(..)
  , GCaptchaResponse(..)
- , WithdrawlQFull(..)
+ , WithdrawalQFull(..)
   ) where
 
 import           Control.Exception
@@ -48,80 +48,80 @@ instance IsString GCaptchaResponse where
 
 --------------------------------------------------------------------------------
 -- | A request to withdraw ADA from the faucet wallet
-data WithdrawlRequest = WithdrawlRequest {
+data WithdrawalRequest = WithdrawalRequest {
     -- | The address to send the ADA to
     _wAddress           :: !(V1 Address)
     -- | The "g-recaptcha-response" field sent by the form
   , _gRecaptchaResponse :: !GCaptchaResponse
   } deriving (Show, Typeable, Generic)
 
-makeLenses ''WithdrawlRequest
+makeLenses ''WithdrawalRequest
 
-instance FromJSON WithdrawlRequest where
-  parseJSON = withObject "WithdrawlRequest" $ \v -> WithdrawlRequest
+instance FromJSON WithdrawalRequest where
+  parseJSON = withObject "WithdrawalRequest" $ \v -> WithdrawalRequest
     <$> v .: "address"
     <*> (GCaptchaResponse <$> v .: "g-recaptcha-response")
 
-instance FromForm WithdrawlRequest where
-    fromForm f = WithdrawlRequest
+instance FromForm WithdrawalRequest where
+    fromForm f = WithdrawalRequest
       <$> parseUnique "address" f
       <*> (GCaptchaResponse <$> parseUnique "g-recaptcha-response" f)
 
-instance ToSchema WithdrawlRequest where
+instance ToSchema WithdrawalRequest where
     declareNamedSchema _ = do
         addrSchema <- declareSchemaRef (Proxy :: Proxy (V1 Address))
         recaptchaSchema <- declareSchemaRef (Proxy :: Proxy Text)
-        return $ NamedSchema (Just "WithdrawlRequest") $ mempty
+        return $ NamedSchema (Just "WithdrawalRequest") $ mempty
           & type_ .~ SwaggerObject
           & properties .~ (mempty & at "address" ?~ addrSchema
                                   & at "g-recaptcha-response" ?~ recaptchaSchema)
           & required .~ ["address", "g-recaptcha-response"]
 
-instance ToJSON WithdrawlRequest where
-    toJSON (WithdrawlRequest w g) =
+instance ToJSON WithdrawalRequest where
+    toJSON (WithdrawalRequest w g) =
         object [ "address" .= w
                , "g-recaptcha-response" .= (g ^. _Wrapped)]
 
 
 --------------------------------------------------------------------------------
-data WithdrawlQFull = WithdrawlQFull deriving (Show, Generic, Exception)
+data WithdrawalQFull = WithdrawalQFull deriving (Show, Generic, Exception)
 
-instance ToJSON WithdrawlQFull where
+instance ToJSON WithdrawalQFull where
   toJSON _ =
-      object [ "error" .= ("Withdrawl queue is full" :: Text)
+      object [ "error" .= ("Withdrawal queue is full" :: Text)
              , "status" .= ("error" :: Text) ]
 
-instance ToSchema WithdrawlQFull where
+instance ToSchema WithdrawalQFull where
     declareNamedSchema _ = do
         strSchema <- declareSchemaRef (Proxy :: Proxy Text)
-        return $ NamedSchema (Just "WithdrawlQFull") $ mempty
+        return $ NamedSchema (Just "WithdrawalQFull") $ mempty
           & type_ .~ SwaggerObject
           & properties .~ (mempty
               & at "status" ?~ strSchema
               & at "error" ?~ strSchema)
           & required .~ ["status"]
 
 --------------------------------------------------------------------------------
-data WithdrawlResult =
-    WithdrawlError Text   -- ^ Error with http client error
-  | WithdrawlSuccess Transaction -- ^ Success with transaction details
+data WithdrawalResult =
+    WithdrawalError Text   -- ^ Error with http client error
+  | WithdrawalSuccess Transaction -- ^ Success with transaction details
   deriving (Show, Typeable, Generic)
 
-makePrisms ''WithdrawlResult
+makePrisms ''WithdrawalResult
 
-instance ToJSON WithdrawlResult where
-    toJSON (WithdrawlSuccess txn) =
+instance ToJSON WithdrawalResult where
+    toJSON (WithdrawalSuccess txn) =
         object ["success" .= txn]
-    toJSON (WithdrawlError err) =
+    toJSON (WithdrawalError err) =
         object ["error" .= err]
 
 wdDesc :: Text
 wdDesc = "An object with either a success field containing the transaction or "
       <> "an error field containing the ClientError from the wallet as a string"
 
-instance ToSchema WithdrawlResult where
+instance ToSchema WithdrawalResult where
     declareNamedSchema = genericDeclareNamedSchema defaultSchemaOptions
-      { constructorTagModifier = map Char.toLower . drop (length ("Withdrawl" :: String)) }
+      { constructorTagModifier = map Char.toLower . drop (length ("Withdrawal" :: String)) }
       & mapped.mapped.schema.description ?~ wdDesc
 
 --------------------------------------------------------------------------------

faucet/src/Cardano/Faucet/Types/Config.hs

@@ -151,7 +151,7 @@ data FaucetConfig = FaucetConfig {
   , _fcWalletApiPort       :: !Int
     -- | Port to serve the faucet on
   , _fcPort                :: !Int
-    -- | Distribution for withdrawls (default to 1000 and 500)
+    -- | Distribution for withdrawals (default to 1000 and 500)
   , _fcPaymentDistribution :: !PaymentDistribution
     -- | Statsd server details
   , _fcStatsdOpts          :: !FaucetStatsdOpts
@@ -235,7 +235,7 @@ instance Exception InitFaucetError
 --------------------------------------------------------------------------------
 data ProcessorPayload = ProcessorPayload {
     _ppQueue  :: !Payment
-  , _ppResult :: !(TMVar WithdrawlResult)
+  , _ppResult :: !(TMVar WithdrawalResult)
   }
 
 makeLenses ''ProcessorPayload
@@ -244,7 +244,7 @@ makeLenses ''ProcessorPayload
 data FaucetEnv = FaucetEnv {
     -- | Counter for total amount withdawn from a wallet while faucet is running
     _feWithdrawn     :: !Counter
-    -- | Counter for number of withdrawls made
+    -- | Counter for number of withdrawals made
   , _feNumWithdrawn  :: !Counter
     -- | Gauge for wallet balance
   , _feWalletBalance :: !Gauge
@@ -258,8 +258,8 @@ data FaucetEnv = FaucetEnv {
   , _feFaucetConfig  :: !FaucetConfig
     -- | Client for communicating with wallet API
   , _feWalletClient  :: !(WalletClient IO)
-    -- | Lock to ensure only one withdrawl at a time
-  , _feWithdrawlQ    :: !(TBQueue ProcessorPayload)
+    -- | Lock to ensure only one withdrawal at a time
+  , _feWithdrawalQ    :: !(TBQueue ProcessorPayload)
   }
 
 makeClassy ''FaucetEnv

faucet/src/Cardano/WalletClient.hs

@@ -39,12 +39,12 @@ randomAmount (PaymentDistribution (getCoin -> amt) (getCoin -> var))= do
 --
 -- Simply sends a 'randomAmount' of ADA (units in lovelace )to the supplied
 -- 'Address'
-withdraw :: (MonadFaucet c m) => V1 Address -> m (Either WithdrawlQFull WithdrawlResult)
+withdraw :: (MonadFaucet c m) => V1 Address -> m (Either WithdrawalQFull WithdrawalResult)
 withdraw addr = withSublogger "WalletClient.withdraw" $ do
     paymentSource <- view (feSourceWallet . to cfgToPaymentSource)
     spendingPassword <- view (feSourceWallet . srcSpendingPassword)
     coin <- randomAmount =<< view (feFaucetConfig . fcPaymentDistribution)
-    q <- view feWithdrawlQ
+    q <- view feWithdrawalQ
     let paymentDist = (V1.PaymentDistribution addr coin :| [])
         sp =  spendingPassword <&> view (re utf8 . to hashPwd . to V1)
         payment = Payment paymentSource paymentDist Nothing sp
@@ -60,15 +60,15 @@ withdraw addr = withSublogger "WalletClient.withdraw" $ do
 -- | Sends the 'Payment' to the processor queue
 --
 -- Returns a 'TMVar' to wait on for the response from the node
--- See 'Cardano.Faucet.Init.processWithdrawls'
+-- See 'Cardano.Faucet.Init.processWithdrawals'
 sendToQueue
     :: TBQ.TBQueue ProcessorPayload
     -> Payment
-    -> IO (Either WithdrawlQFull (TMVar WithdrawlResult))
+    -> IO (Either WithdrawalQFull (TMVar WithdrawalResult))
 sendToQueue q payment = atomically $ do
         isFull <- TBQ.isFullTBQueue q
         if isFull
-           then return $ Left WithdrawlQFull
+           then return $ Left WithdrawalQFull
            else do
             resTMVar <- newEmptyTMVar
             TBQ.writeTBQueue q  (ProcessorPayload payment resTMVar)