Coinbase.Exchange.Types

Documentation

data ApiType

Constructors

Sandbox

Live

Instances

Show ApiType

type Endpoint = String

type Path = String

website :: Endpoint

sandboxRest :: Endpoint

sandboxSocket :: Endpoint

liveRest :: Endpoint

liveSocket :: Endpoint

type Key = ByteString

type Secret = ByteString

type Passphrase = ByteString

data Token

key :: Token -> ByteString

secret :: Token -> ByteString

passphrase :: Token -> ByteString

mkToken :: Key -> Secret -> Passphrase -> Either String Token

data ExchangeConf

Constructors

ExchangeConf

Fields

manager :: Manager

authToken :: Maybe Token

apiType :: ApiType

data ExchangeFailure

Constructors

ParseFailure Text

ApiFailure Text

AuthenticationRequiredFailure Text

AuthenticationRequiresByteStrings

Instances

Data ExchangeFailure

Show ExchangeFailure

Generic ExchangeFailure

Exception ExchangeFailure

type Rep ExchangeFailure

type Exchange a = ExchangeT IO a

data ExceptT e m a :: * -> (* -> *) -> * -> *

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

• e - The exception type.
• m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Instances

MonadBaseControl b m => MonadBaseControl b (ExceptT e m)

MonadBase b m => MonadBase b (ExceptT e m)

Monad m => MonadError e (ExceptT e m)

MonadReader r m => MonadReader r (ExceptT e m)

MonadTrans (ExceptT e)

MonadTransControl (ExceptT e)

Monad m => Monad (ExceptT e m)

Functor m => Functor (ExceptT e m)

MonadFix m => MonadFix (ExceptT e m)

(Functor m, Monad m) => Applicative (ExceptT e m)

Foldable f => Foldable (ExceptT e f)

Traversable f => Traversable (ExceptT e f)

(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)

(Monad m, Monoid e) => MonadPlus (ExceptT e m)

MonadThrow m => MonadThrow (ExceptT e m)

Throws exceptions into the base monad.

MonadCatch m => MonadCatch (ExceptT e m)

Catches exceptions from the base monad.

MonadIO m => MonadIO (ExceptT e m)

PrimMonad m => PrimMonad (ExceptT e m)

MonadResource m => MonadResource (ExceptT e m)

(Eq e, Eq1 m) => Eq1 (ExceptT e m)

(Ord e, Ord1 m) => Ord1 (ExceptT e m)

(Read e, Read1 m) => Read1 (ExceptT e m)

(Show e, Show1 m) => Show1 (ExceptT e m)

(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)

(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)

(Read e, Read1 m, Read a) => Read (ExceptT e m a)

(Show e, Show1 m, Show a) => Show (ExceptT e m a)

type StT (ExceptT e) a = Either e a

type PrimState (ExceptT e m) = PrimState m

type StM (ExceptT e m) a = ComposeSt (ExceptT e) m a

runExchange :: ExchangeConf -> Exchange a -> IO (Either ExchangeFailure a)

runExchangeT :: MonadBaseControl IO m => ExchangeConf -> ExchangeT m a -> m (Either ExchangeFailure a)

getManager :: MonadReader ExchangeConf m => m Manager