bitx-bitcoin-0.11.0.1: A Haskell library for working with the BitX bitcoin exchange.

Copyright2016 Tebello Thejane
LicenseBSD3
MaintainerTebello Thejane <zyxoas+hackage@gmail.com>
StabilityExperimental
Portabilitynon-portable (GHC Extensions)
Safe HaskellNone
LanguageHaskell2010

Network.Bitcoin.BitX.Types

Description

The types used for the various BitX API calls.

Synopsis

Documentation

data Ticker #

The state of a single market, identified by the currency pair. As usual, the ask/sell price is the price of the last filled ask order, and the bid/buy price is the price of the last filled bid order. Necessarily bid <= ask.

Instances

Eq Ticker # 

Methods

(==) :: Ticker -> Ticker -> Bool #

(/=) :: Ticker -> Ticker -> Bool #

Data Ticker # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ticker -> c Ticker #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ticker #

toConstr :: Ticker -> Constr #

dataTypeOf :: Ticker -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Ticker) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ticker) #

gmapT :: (forall b. Data b => b -> b) -> Ticker -> Ticker #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ticker -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ticker -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ticker -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ticker -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ticker -> m Ticker #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ticker -> m Ticker #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ticker -> m Ticker #

Ord Ticker # 
Show Ticker # 
Generic Ticker # 

Associated Types

type Rep Ticker :: * -> * #

Methods

from :: Ticker -> Rep Ticker x #

to :: Rep Ticker x -> Ticker #

NFData Ticker # 

Methods

rnf :: Ticker -> () #

BitXAesRecordConvert Ticker # 

Associated Types

type Aes Ticker :: * #

Methods

aesToRec :: Aes Ticker -> Ticker #

HasTimestamp Ticker UTCTime # 
HasRolling24HourVolume Ticker Scientific # 
HasPair Ticker CcyPair # 
HasLastTrade Ticker (Maybe Int) # 
HasBid Ticker (Maybe Int) # 

Methods

bid :: Lens' Ticker (Maybe Int) #

HasAsk Ticker (Maybe Int) # 

Methods

ask :: Lens' Ticker (Maybe Int) #

BitXAesRecordConvert [Ticker] # 

Associated Types

type Aes [Ticker] :: * #

Methods

aesToRec :: Aes [Ticker] -> [Ticker] #

type Rep Ticker # 
type Aes Ticker # 
type Aes Ticker
type Aes [Ticker] # 
type Aes [Ticker]

data CcyPair #

A currency pair

Constructors

XBTZAR

Bitcoin vs. ZAR

XBTNAD

Bitcoin vs. Namibian Dollar

ZARXBT

ZAR vs. Namibian Dollar

NADXBT

Namibian Dollar vs. Bitcoin

XBTKES

Bitcoin vs. Kenyan Shilling

KESXBT

Kenyan Shilling vs Bitcoin

XBTMYR

Bitcoin vs. Malaysian Ringgit

MYRXBT

Malaysian Ringgit vs. Bitcoin

XBTNGN

Bitcoin vs. Nigerian Naira

NGNXBT

Nigerian Naira vs. Bitcoin

XBTIDR

Bitcoin vs. Indonesian Rupiah

IDRXBT

Indonesian Rupiah vs. Bitcoin

XBTSGD

Bitcoin vs. Singapore Dollar

SGDXBT

Singapore Dollar vs. Bitcoin

Instances

Eq CcyPair # 

Methods

(==) :: CcyPair -> CcyPair -> Bool #

(/=) :: CcyPair -> CcyPair -> Bool #

Data CcyPair # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CcyPair -> c CcyPair #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CcyPair #

toConstr :: CcyPair -> Constr #

dataTypeOf :: CcyPair -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CcyPair) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CcyPair) #

gmapT :: (forall b. Data b => b -> b) -> CcyPair -> CcyPair #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CcyPair -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CcyPair -> r #

gmapQ :: (forall d. Data d => d -> u) -> CcyPair -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CcyPair -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CcyPair -> m CcyPair #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CcyPair -> m CcyPair #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CcyPair -> m CcyPair #

Ord CcyPair # 
Show CcyPair # 
Generic CcyPair # 

Associated Types

type Rep CcyPair :: * -> * #

Methods

from :: CcyPair -> Rep CcyPair x #

to :: Rep CcyPair x -> CcyPair #

FromJSON CcyPair # 
NFData CcyPair # 

Methods

rnf :: CcyPair -> () #

HasPair Ticker CcyPair # 
HasPair PrivateOrder CcyPair # 
HasPair OrderRequest CcyPair # 
HasPair MarketOrderRequest CcyPair # 
HasPair QuoteRequest CcyPair # 
HasPair OrderQuote CcyPair # 
HasPair PrivateTrade CcyPair # 
type Rep CcyPair # 
type Rep CcyPair = D1 (MetaData "CcyPair" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "XBTZAR" PrefixI False) U1) ((:+:) (C1 (MetaCons "XBTNAD" PrefixI False) U1) (C1 (MetaCons "ZARXBT" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "NADXBT" PrefixI False) U1) (C1 (MetaCons "XBTKES" PrefixI False) U1)) ((:+:) (C1 (MetaCons "KESXBT" PrefixI False) U1) (C1 (MetaCons "XBTMYR" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "MYRXBT" PrefixI False) U1) ((:+:) (C1 (MetaCons "XBTNGN" PrefixI False) U1) (C1 (MetaCons "NGNXBT" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "XBTIDR" PrefixI False) U1) (C1 (MetaCons "IDRXBT" PrefixI False) U1)) ((:+:) (C1 (MetaCons "XBTSGD" PrefixI False) U1) (C1 (MetaCons "SGDXBT" PrefixI False) U1)))))

data Orderbook #

The current state of the publically accessible orderbook. Bid orders are requests to buy, ask orders are requests to sell.

Instances

Eq Orderbook # 
Data Orderbook # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Orderbook -> c Orderbook #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Orderbook #

toConstr :: Orderbook -> Constr #

dataTypeOf :: Orderbook -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Orderbook) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Orderbook) #

gmapT :: (forall b. Data b => b -> b) -> Orderbook -> Orderbook #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Orderbook -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Orderbook -> r #

gmapQ :: (forall d. Data d => d -> u) -> Orderbook -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Orderbook -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Orderbook -> m Orderbook #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Orderbook -> m Orderbook #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Orderbook -> m Orderbook #

Ord Orderbook # 
Show Orderbook # 
Generic Orderbook # 

Associated Types

type Rep Orderbook :: * -> * #

NFData Orderbook # 

Methods

rnf :: Orderbook -> () #

BitXAesRecordConvert Orderbook # 

Associated Types

type Aes Orderbook :: * #

HasTimestamp Orderbook UTCTime # 
HasBids Orderbook [Bid] # 

Methods

bids :: Lens' Orderbook [Bid] #

HasAsks Orderbook [Ask] # 

Methods

asks :: Lens' Orderbook [Ask] #

type Rep Orderbook # 
type Rep Orderbook = D1 (MetaData "Orderbook" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "Orderbook" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "orderbookTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UTCTime)) ((:*:) (S1 (MetaSel (Just Symbol "orderbookBids") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Bid])) (S1 (MetaSel (Just Symbol "orderbookAsks") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ask])))))
type Aes Orderbook # 

data Order #

A single placed order in the orderbook

Constructors

Order 

Instances

Eq Order # 

Methods

(==) :: Order -> Order -> Bool #

(/=) :: Order -> Order -> Bool #

Data Order # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Order -> c Order #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Order #

toConstr :: Order -> Constr #

dataTypeOf :: Order -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Order) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Order) #

gmapT :: (forall b. Data b => b -> b) -> Order -> Order #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Order -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Order -> r #

gmapQ :: (forall d. Data d => d -> u) -> Order -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Order -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Order -> m Order #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Order -> m Order #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Order -> m Order #

Ord Order # 

Methods

compare :: Order -> Order -> Ordering #

(<) :: Order -> Order -> Bool #

(<=) :: Order -> Order -> Bool #

(>) :: Order -> Order -> Bool #

(>=) :: Order -> Order -> Bool #

max :: Order -> Order -> Order #

min :: Order -> Order -> Order #

Show Order # 

Methods

showsPrec :: Int -> Order -> ShowS #

show :: Order -> String #

showList :: [Order] -> ShowS #

Generic Order # 

Associated Types

type Rep Order :: * -> * #

Methods

from :: Order -> Rep Order x #

to :: Rep Order x -> Order #

NFData Order # 

Methods

rnf :: Order -> () #

BitXAesRecordConvert Order # 

Associated Types

type Aes Order :: * #

Methods

aesToRec :: Aes Order -> Order #

HasVolume Order Scientific # 
HasPrice Order Int # 

Methods

price :: Lens' Order Int #

HasBids Orderbook [Bid] # 

Methods

bids :: Lens' Orderbook [Bid] #

HasAsks Orderbook [Ask] # 

Methods

asks :: Lens' Orderbook [Ask] #

type Rep Order # 
type Rep Order = D1 (MetaData "Order" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "Order" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "orderVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "orderPrice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))
type Aes Order # 
type Aes Order

type Bid = Order #

Convenient type alias for a bid order

type Ask = Order #

Convenient type alias for an ask order

data Trade #

Instances

Eq Trade # 

Methods

(==) :: Trade -> Trade -> Bool #

(/=) :: Trade -> Trade -> Bool #

Data Trade # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Trade -> c Trade #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Trade #

toConstr :: Trade -> Constr #

dataTypeOf :: Trade -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Trade) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trade) #

gmapT :: (forall b. Data b => b -> b) -> Trade -> Trade #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trade -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trade -> r #

gmapQ :: (forall d. Data d => d -> u) -> Trade -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Trade -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Trade -> m Trade #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Trade -> m Trade #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Trade -> m Trade #

Ord Trade # 

Methods

compare :: Trade -> Trade -> Ordering #

(<) :: Trade -> Trade -> Bool #

(<=) :: Trade -> Trade -> Bool #

(>) :: Trade -> Trade -> Bool #

(>=) :: Trade -> Trade -> Bool #

max :: Trade -> Trade -> Trade #

min :: Trade -> Trade -> Trade #

Show Trade # 

Methods

showsPrec :: Int -> Trade -> ShowS #

show :: Trade -> String #

showList :: [Trade] -> ShowS #

Generic Trade # 

Associated Types

type Rep Trade :: * -> * #

Methods

from :: Trade -> Rep Trade x #

to :: Rep Trade x -> Trade #

NFData Trade # 

Methods

rnf :: Trade -> () #

BitXAesRecordConvert Trade # 

Associated Types

type Aes Trade :: * #

Methods

aesToRec :: Aes Trade -> Trade #

HasTimestamp Trade UTCTime # 
HasVolume Trade Scientific # 
HasPrice Trade Int # 

Methods

price :: Lens' Trade Int #

HasIsBuy Trade Bool # 

Methods

isBuy :: Lens' Trade Bool #

BitXAesRecordConvert [Trade] # 

Associated Types

type Aes [Trade] :: * #

Methods

aesToRec :: Aes [Trade] -> [Trade] #

type Rep Trade # 
type Aes Trade # 
type Aes Trade
type Aes [Trade] # 
type Aes [Trade]

data BitXAuth #

An auth type used by all private API calls, after authorisation.

Constructors

BitXAuth 

Instances

Eq BitXAuth # 
Data BitXAuth # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BitXAuth -> c BitXAuth #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BitXAuth #

toConstr :: BitXAuth -> Constr #

dataTypeOf :: BitXAuth -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BitXAuth) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitXAuth) #

gmapT :: (forall b. Data b => b -> b) -> BitXAuth -> BitXAuth #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitXAuth -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitXAuth -> r #

gmapQ :: (forall d. Data d => d -> u) -> BitXAuth -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BitXAuth -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BitXAuth -> m BitXAuth #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BitXAuth -> m BitXAuth #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BitXAuth -> m BitXAuth #

Ord BitXAuth # 
Show BitXAuth # 
IsString BitXAuth # 
Generic BitXAuth # 

Associated Types

type Rep BitXAuth :: * -> * #

Methods

from :: BitXAuth -> Rep BitXAuth x #

to :: Rep BitXAuth x -> BitXAuth #

NFData BitXAuth # 

Methods

rnf :: BitXAuth -> () #

BitXAesRecordConvert BitXAuth # 

Associated Types

type Aes BitXAuth :: * #

HasSecret BitXAuth Text # 
HasId BitXAuth Text # 

Methods

id :: Lens' BitXAuth Text #

type Rep BitXAuth # 
type Rep BitXAuth = D1 (MetaData "BitXAuth" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "BitXAuth" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "bitXAuthId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) (S1 (MetaSel (Just Symbol "bitXAuthSecret") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))))
type Aes BitXAuth # 

data PrivateOrder #

>>> :set -XOverloadedStrings
>>> "id:secret" :: BitXAuth
BitXAuth {bitXAuthId = "id", bitXAuthSecret = "secret"}
>>> "id:se:cret" :: BitXAuth
BitXAuth {bitXAuthId = "id", bitXAuthSecret = "se:cret"}

A recently placed (private) order, containing a lot more information than is available on the public order book.

Instances

Eq PrivateOrder # 
Data PrivateOrder # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrivateOrder -> c PrivateOrder #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrivateOrder #

toConstr :: PrivateOrder -> Constr #

dataTypeOf :: PrivateOrder -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PrivateOrder) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivateOrder) #

gmapT :: (forall b. Data b => b -> b) -> PrivateOrder -> PrivateOrder #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrivateOrder -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrivateOrder -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrivateOrder -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivateOrder -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrivateOrder -> m PrivateOrder #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivateOrder -> m PrivateOrder #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivateOrder -> m PrivateOrder #

Show PrivateOrder # 
Generic PrivateOrder # 

Associated Types

type Rep PrivateOrder :: * -> * #

NFData PrivateOrder # 

Methods

rnf :: PrivateOrder -> () #

BitXAesRecordConvert PrivateOrder # 

Associated Types

type Aes PrivateOrder :: * #

HasPair PrivateOrder CcyPair # 
HasId PrivateOrder OrderID # 
HasState PrivateOrder RequestStatus # 
HasOrderType PrivateOrder OrderType # 
HasLimitVolume PrivateOrder Scientific # 
HasLimitPrice PrivateOrder Int # 
HasFeeCounter PrivateOrder Scientific # 
HasFeeBase PrivateOrder Scientific # 
HasExpirationTimestamp PrivateOrder UTCTime # 
HasCreationTimestamp PrivateOrder UTCTime # 
HasCounter PrivateOrder Scientific # 
HasCompletedTimestamp PrivateOrder UTCTime # 
HasBase PrivateOrder Scientific # 
BitXAesRecordConvert [PrivateOrder] # 

Associated Types

type Aes [PrivateOrder] :: * #

type Rep PrivateOrder # 
type Rep PrivateOrder = D1 (MetaData "PrivateOrder" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "PrivateOrder" PrefixI True) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderBase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderCounter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "privateOrderCreationTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UTCTime)))) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderExpirationTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UTCTime)) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderCompletedTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UTCTime)) (S1 (MetaSel (Just Symbol "privateOrderFeeBase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific))))) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderFeeCounter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderLimitPrice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) (S1 (MetaSel (Just Symbol "privateOrderLimitVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OrderID)) (S1 (MetaSel (Just Symbol "privateOrderPair") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CcyPair))) ((:*:) (S1 (MetaSel (Just Symbol "privateOrderState") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RequestStatus)) (S1 (MetaSel (Just Symbol "privateOrderOrderType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OrderType)))))))
type Aes PrivateOrder # 
type Aes [PrivateOrder] # 

type OrderID = Text #

data OrderType #

The type of a placed order.

Constructors

ASK

A request to sell

BID

A request to buy

Instances

Eq OrderType # 
Data OrderType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderType -> c OrderType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderType #

toConstr :: OrderType -> Constr #

dataTypeOf :: OrderType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OrderType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderType) #

gmapT :: (forall b. Data b => b -> b) -> OrderType -> OrderType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderType -> r #

gmapQ :: (forall d. Data d => d -> u) -> OrderType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderType -> m OrderType #

Ord OrderType # 
Show OrderType # 
Generic OrderType # 

Associated Types

type Rep OrderType :: * -> * #

FromJSON OrderType # 
NFData OrderType # 

Methods

rnf :: OrderType -> () #

HasOrderType PrivateOrder OrderType # 
HasOrderType OrderRequest OrderType # 
HasOrderType MarketOrderRequest OrderType # 
HasOrderType PrivateTrade OrderType # 
type Rep OrderType # 
type Rep OrderType = D1 (MetaData "OrderType" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) (C1 (MetaCons "ASK" PrefixI False) U1) (C1 (MetaCons "BID" PrefixI False) U1))

data RequestStatus #

The state of a (private) placed request -- either an order or a withdrawal request.

Constructors

PENDING

Not yet completed. An order will stay in PENDING state even as it is partially filled, and will move to COMPLETE once it has been completely filled.

COMPLETE

Completed.

CANCELLED

Cancelled. Note that an order cannot be in CANCELLED state, since cancelling an order removes it from the orderbook.

Instances

Eq RequestStatus # 
Data RequestStatus # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RequestStatus -> c RequestStatus #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RequestStatus #

toConstr :: RequestStatus -> Constr #

dataTypeOf :: RequestStatus -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RequestStatus) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RequestStatus) #

gmapT :: (forall b. Data b => b -> b) -> RequestStatus -> RequestStatus #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RequestStatus -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RequestStatus -> r #

gmapQ :: (forall d. Data d => d -> u) -> RequestStatus -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RequestStatus -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RequestStatus -> m RequestStatus #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RequestStatus -> m RequestStatus #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RequestStatus -> m RequestStatus #

Ord RequestStatus # 
Show RequestStatus # 
Generic RequestStatus # 

Associated Types

type Rep RequestStatus :: * -> * #

NFData RequestStatus # 

Methods

rnf :: RequestStatus -> () #

HasState PrivateOrder RequestStatus # 
HasStatus WithdrawalRequest RequestStatus # 
type Rep RequestStatus # 
type Rep RequestStatus = D1 (MetaData "RequestStatus" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) (C1 (MetaCons "PENDING" PrefixI False) U1) ((:+:) (C1 (MetaCons "COMPLETE" PrefixI False) U1) (C1 (MetaCons "CANCELLED" PrefixI False) U1)))

data OrderRequest #

A request to place an order.

Instances

Eq OrderRequest # 
Data OrderRequest # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderRequest -> c OrderRequest #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderRequest #

toConstr :: OrderRequest -> Constr #

dataTypeOf :: OrderRequest -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OrderRequest) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderRequest) #

gmapT :: (forall b. Data b => b -> b) -> OrderRequest -> OrderRequest #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderRequest -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderRequest -> r #

gmapQ :: (forall d. Data d => d -> u) -> OrderRequest -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderRequest -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderRequest -> m OrderRequest #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderRequest -> m OrderRequest #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderRequest -> m OrderRequest #

Ord OrderRequest # 
Show OrderRequest # 
Generic OrderRequest # 

Associated Types

type Rep OrderRequest :: * -> * #

NFData OrderRequest # 

Methods

rnf :: OrderRequest -> () #

POSTEncodeable OrderRequest # 
HasPair OrderRequest CcyPair # 
HasVolume OrderRequest Scientific # 
HasPrice OrderRequest Int # 
HasOrderType OrderRequest OrderType # 
type Rep OrderRequest # 
type Rep OrderRequest = D1 (MetaData "OrderRequest" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "OrderRequest" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "orderRequestPair") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CcyPair)) (S1 (MetaSel (Just Symbol "orderRequestOrderType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OrderType))) ((:*:) (S1 (MetaSel (Just Symbol "orderRequestVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "orderRequestPrice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))))

data MarketOrderRequest #

Instances

Eq MarketOrderRequest # 
Data MarketOrderRequest # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MarketOrderRequest -> c MarketOrderRequest #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MarketOrderRequest #

toConstr :: MarketOrderRequest -> Constr #

dataTypeOf :: MarketOrderRequest -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MarketOrderRequest) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MarketOrderRequest) #

gmapT :: (forall b. Data b => b -> b) -> MarketOrderRequest -> MarketOrderRequest #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MarketOrderRequest -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MarketOrderRequest -> r #

gmapQ :: (forall d. Data d => d -> u) -> MarketOrderRequest -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MarketOrderRequest -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MarketOrderRequest -> m MarketOrderRequest #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MarketOrderRequest -> m MarketOrderRequest #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MarketOrderRequest -> m MarketOrderRequest #

Ord MarketOrderRequest # 
Show MarketOrderRequest # 
Generic MarketOrderRequest # 
NFData MarketOrderRequest # 

Methods

rnf :: MarketOrderRequest -> () #

POSTEncodeable MarketOrderRequest # 
HasPair MarketOrderRequest CcyPair # 
HasVolume MarketOrderRequest Scientific # 
HasOrderType MarketOrderRequest OrderType # 
type Rep MarketOrderRequest # 
type Rep MarketOrderRequest = D1 (MetaData "MarketOrderRequest" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "MarketOrderRequest" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "marketOrderRequestPair") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CcyPair)) ((:*:) (S1 (MetaSel (Just Symbol "marketOrderRequestOrderType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OrderType)) (S1 (MetaSel (Just Symbol "marketOrderRequestVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))))

data BitXError #

A possible error which the BitX API might return, instead of returning the requested data. Note that as yet there is no exhaustive list of error codes available, so comparisons will have to be done via Text comparisons (as opposed to typed pattern matching). Sorry...

Instances

Eq BitXError # 
Data BitXError # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BitXError -> c BitXError #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BitXError #

toConstr :: BitXError -> Constr #

dataTypeOf :: BitXError -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BitXError) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitXError) #

gmapT :: (forall b. Data b => b -> b) -> BitXError -> BitXError #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitXError -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitXError -> r #

gmapQ :: (forall d. Data d => d -> u) -> BitXError -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BitXError -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BitXError -> m BitXError #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BitXError -> m BitXError #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BitXError -> m BitXError #

Ord BitXError # 
Show BitXError # 
Generic BitXError # 

Associated Types

type Rep BitXError :: * -> * #

NFData BitXError # 

Methods

rnf :: BitXError -> () #

BitXAesRecordConvert BitXError # 

Associated Types

type Aes BitXError :: * #

HasErrorCode BitXError Text # 
HasError BitXError Text # 
type Rep BitXError # 
type Rep BitXError = D1 (MetaData "BitXError" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "BitXError" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "bitXErrorError") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) (S1 (MetaSel (Just Symbol "bitXErrorErrorCode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))))
type Aes BitXError # 

data Asset #

A trade-able asset. Essentially, a currency.

Constructors

ZAR

South African Rand

NAD

Namibian Dollar

XBT

Bitcoin

KES

Kenyan Shilling

MYR

Malaysian Ringgit

NGN

Nigerian Naira

IDR

Indonesian Rupiah

SGD

Singapore Dollar

Instances

Eq Asset # 

Methods

(==) :: Asset -> Asset -> Bool #

(/=) :: Asset -> Asset -> Bool #

Data Asset # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Asset -> c Asset #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Asset #

toConstr :: Asset -> Constr #

dataTypeOf :: Asset -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Asset) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Asset) #

gmapT :: (forall b. Data b => b -> b) -> Asset -> Asset #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asset -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asset -> r #

gmapQ :: (forall d. Data d => d -> u) -> Asset -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Asset -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Asset -> m Asset #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Asset -> m Asset #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Asset -> m Asset #

Ord Asset # 

Methods

compare :: Asset -> Asset -> Ordering #

(<) :: Asset -> Asset -> Bool #

(<=) :: Asset -> Asset -> Bool #

(>) :: Asset -> Asset -> Bool #

(>=) :: Asset -> Asset -> Bool #

max :: Asset -> Asset -> Asset #

min :: Asset -> Asset -> Asset #

Show Asset # 

Methods

showsPrec :: Int -> Asset -> ShowS #

show :: Asset -> String #

showList :: [Asset] -> ShowS #

Generic Asset # 

Associated Types

type Rep Asset :: * -> * #

Methods

from :: Asset -> Rep Asset x #

to :: Rep Asset x -> Asset #

FromJSON Asset # 
NFData Asset # 

Methods

rnf :: Asset -> () #

POSTEncodeable Asset # 
HasCurrency Transaction Asset # 
HasCurrency BitcoinSendRequest Asset # 
HasCurrency Account Asset # 
HasAsset Balance Asset # 
HasAsset FundingAddress Asset # 
type Rep Asset # 
type Rep Asset = D1 (MetaData "Asset" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "ZAR" PrefixI False) U1) (C1 (MetaCons "NAD" PrefixI False) U1)) ((:+:) (C1 (MetaCons "XBT" PrefixI False) U1) (C1 (MetaCons "KES" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "MYR" PrefixI False) U1) (C1 (MetaCons "NGN" PrefixI False) U1)) ((:+:) (C1 (MetaCons "IDR" PrefixI False) U1) (C1 (MetaCons "SGD" PrefixI False) U1))))

data Balance #

The current balance of a private account.

Instances

Eq Balance # 

Methods

(==) :: Balance -> Balance -> Bool #

(/=) :: Balance -> Balance -> Bool #

Data Balance # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Balance -> c Balance #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Balance #

toConstr :: Balance -> Constr #

dataTypeOf :: Balance -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Balance) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Balance) #

gmapT :: (forall b. Data b => b -> b) -> Balance -> Balance #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Balance -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Balance -> r #

gmapQ :: (forall d. Data d => d -> u) -> Balance -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Balance -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Balance -> m Balance #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Balance -> m Balance #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Balance -> m Balance #

Ord Balance # 
Show Balance # 
Generic Balance # 

Associated Types

type Rep Balance :: * -> * #

Methods

from :: Balance -> Rep Balance x #

to :: Rep Balance x -> Balance #

NFData Balance # 

Methods

rnf :: Balance -> () #

BitXAesRecordConvert Balance # 

Associated Types

type Aes Balance :: * #

HasId Balance AccountID # 
HasBalance Balance Scientific # 
HasUnconfirmed Balance Scientific # 
HasReserved Balance Scientific # 
HasAsset Balance Asset # 
BitXAesRecordConvert [Balance] # 

Associated Types

type Aes [Balance] :: * #

Methods

aesToRec :: Aes [Balance] -> [Balance] #

type Rep Balance # 
type Aes Balance # 
type Aes [Balance] # 
type Aes [Balance]

data FundingAddress #

A registered address for an acocunt.

Instances

Eq FundingAddress # 
Data FundingAddress # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FundingAddress -> c FundingAddress #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FundingAddress #

toConstr :: FundingAddress -> Constr #

dataTypeOf :: FundingAddress -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FundingAddress) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FundingAddress) #

gmapT :: (forall b. Data b => b -> b) -> FundingAddress -> FundingAddress #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FundingAddress -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FundingAddress -> r #

gmapQ :: (forall d. Data d => d -> u) -> FundingAddress -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FundingAddress -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FundingAddress -> m FundingAddress #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FundingAddress -> m FundingAddress #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FundingAddress -> m FundingAddress #

Ord FundingAddress # 
Show FundingAddress # 
Generic FundingAddress # 

Associated Types

type Rep FundingAddress :: * -> * #

NFData FundingAddress # 

Methods

rnf :: FundingAddress -> () #

BitXAesRecordConvert FundingAddress # 

Associated Types

type Aes FundingAddress :: * #

HasAsset FundingAddress Asset # 
HasTotalUnconfirmed FundingAddress Scientific # 
HasTotalReceived FundingAddress Scientific # 
HasAddress FundingAddress Text # 
type Rep FundingAddress # 
type Rep FundingAddress = D1 (MetaData "FundingAddress" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "FundingAddress" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "fundingAddressAsset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Asset)) (S1 (MetaSel (Just Symbol "fundingAddressAddress") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))) ((:*:) (S1 (MetaSel (Just Symbol "fundingAddressTotalReceived") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "fundingAddressTotalUnconfirmed") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))))
type Aes FundingAddress # 

data WithdrawalRequest #

The state of a request to withdraw from an account.

Instances

Eq WithdrawalRequest # 
Data WithdrawalRequest # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithdrawalRequest -> c WithdrawalRequest #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WithdrawalRequest #

toConstr :: WithdrawalRequest -> Constr #

dataTypeOf :: WithdrawalRequest -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c WithdrawalRequest) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WithdrawalRequest) #

gmapT :: (forall b. Data b => b -> b) -> WithdrawalRequest -> WithdrawalRequest #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithdrawalRequest -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithdrawalRequest -> r #

gmapQ :: (forall d. Data d => d -> u) -> WithdrawalRequest -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WithdrawalRequest -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithdrawalRequest -> m WithdrawalRequest #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithdrawalRequest -> m WithdrawalRequest #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithdrawalRequest -> m WithdrawalRequest #

Ord WithdrawalRequest # 
Show WithdrawalRequest # 
Generic WithdrawalRequest # 
NFData WithdrawalRequest # 

Methods

rnf :: WithdrawalRequest -> () #

BitXAesRecordConvert WithdrawalRequest # 
HasId WithdrawalRequest Text # 
HasStatus WithdrawalRequest RequestStatus # 
BitXAesRecordConvert [WithdrawalRequest] # 

Associated Types

type Aes [WithdrawalRequest] :: * #

type Rep WithdrawalRequest # 
type Rep WithdrawalRequest = D1 (MetaData "WithdrawalRequest" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "WithdrawalRequest" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "withdrawalRequestStatus") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RequestStatus)) (S1 (MetaSel (Just Symbol "withdrawalRequestId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text))))
type Aes WithdrawalRequest # 
type Aes [WithdrawalRequest] # 

data NewWithdrawal #

A request to withdraw from an account.

Instances

Eq NewWithdrawal # 
Data NewWithdrawal # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewWithdrawal -> c NewWithdrawal #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewWithdrawal #

toConstr :: NewWithdrawal -> Constr #

dataTypeOf :: NewWithdrawal -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NewWithdrawal) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewWithdrawal) #

gmapT :: (forall b. Data b => b -> b) -> NewWithdrawal -> NewWithdrawal #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewWithdrawal -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewWithdrawal -> r #

gmapQ :: (forall d. Data d => d -> u) -> NewWithdrawal -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NewWithdrawal -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewWithdrawal -> m NewWithdrawal #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewWithdrawal -> m NewWithdrawal #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewWithdrawal -> m NewWithdrawal #

Ord NewWithdrawal # 
Show NewWithdrawal # 
Generic NewWithdrawal # 

Associated Types

type Rep NewWithdrawal :: * -> * #

NFData NewWithdrawal # 

Methods

rnf :: NewWithdrawal -> () #

POSTEncodeable NewWithdrawal # 
HasWithdrawalType NewWithdrawal WithdrawalType # 
HasAmount NewWithdrawal Scientific # 
HasBeneficiaryId NewWithdrawal (Maybe Text) # 
type Rep NewWithdrawal # 
type Rep NewWithdrawal = D1 (MetaData "NewWithdrawal" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "NewWithdrawal" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "newWithdrawalWithdrawalType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 WithdrawalType)) ((:*:) (S1 (MetaSel (Just Symbol "newWithdrawalAmount") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "newWithdrawalBeneficiaryId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text))))))

data WithdrawalType #

The type of a withdrawal request.

Constructors

ZAR_EFT

ZAR by Electronic Funds Transfer

NAD_EFT

Namibian Dollar by EFT

KES_MPESA

Kenyan Shilling by Vodafone MPESA

MYR_IBG

Malaysian Ringgit by Interbank GIRO (?)

IDR_LLG

Indonesian Rupiah by Lalu Lintas Giro (??)

Instances

Eq WithdrawalType # 
Data WithdrawalType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithdrawalType -> c WithdrawalType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WithdrawalType #

toConstr :: WithdrawalType -> Constr #

dataTypeOf :: WithdrawalType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c WithdrawalType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WithdrawalType) #

gmapT :: (forall b. Data b => b -> b) -> WithdrawalType -> WithdrawalType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithdrawalType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithdrawalType -> r #

gmapQ :: (forall d. Data d => d -> u) -> WithdrawalType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WithdrawalType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithdrawalType -> m WithdrawalType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithdrawalType -> m WithdrawalType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithdrawalType -> m WithdrawalType #

Ord WithdrawalType # 
Show WithdrawalType # 
Generic WithdrawalType # 

Associated Types

type Rep WithdrawalType :: * -> * #

FromJSON WithdrawalType # 
NFData WithdrawalType # 

Methods

rnf :: WithdrawalType -> () #

HasWithdrawalType NewWithdrawal WithdrawalType # 
type Rep WithdrawalType # 
type Rep WithdrawalType = D1 (MetaData "WithdrawalType" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) ((:+:) (C1 (MetaCons "ZAR_EFT" PrefixI False) U1) (C1 (MetaCons "NAD_EFT" PrefixI False) U1)) ((:+:) (C1 (MetaCons "KES_MPESA" PrefixI False) U1) ((:+:) (C1 (MetaCons "MYR_IBG" PrefixI False) U1) (C1 (MetaCons "IDR_LLG" PrefixI False) U1))))

data BitcoinSendRequest #

A request to send bitcoin to a bitcoin address or email address.

Instances

Eq BitcoinSendRequest # 
Data BitcoinSendRequest # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BitcoinSendRequest -> c BitcoinSendRequest #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BitcoinSendRequest #

toConstr :: BitcoinSendRequest -> Constr #

dataTypeOf :: BitcoinSendRequest -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BitcoinSendRequest) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BitcoinSendRequest) #

gmapT :: (forall b. Data b => b -> b) -> BitcoinSendRequest -> BitcoinSendRequest #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitcoinSendRequest -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitcoinSendRequest -> r #

gmapQ :: (forall d. Data d => d -> u) -> BitcoinSendRequest -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BitcoinSendRequest -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BitcoinSendRequest -> m BitcoinSendRequest #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BitcoinSendRequest -> m BitcoinSendRequest #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BitcoinSendRequest -> m BitcoinSendRequest #

Ord BitcoinSendRequest # 
Show BitcoinSendRequest # 
Generic BitcoinSendRequest # 
NFData BitcoinSendRequest # 

Methods

rnf :: BitcoinSendRequest -> () #

POSTEncodeable BitcoinSendRequest # 
HasCurrency BitcoinSendRequest Asset # 
HasAddress BitcoinSendRequest Text # 
HasAmount BitcoinSendRequest Scientific # 
HasDescription BitcoinSendRequest (Maybe Text) # 
HasMessage BitcoinSendRequest (Maybe Text) # 
type Rep BitcoinSendRequest # 
type Rep BitcoinSendRequest = D1 (MetaData "BitcoinSendRequest" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "BitcoinSendRequest" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "bitcoinSendRequestAmount") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "bitcoinSendRequestCurrency") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Asset))) ((:*:) (S1 (MetaSel (Just Symbol "bitcoinSendRequestAddress") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) ((:*:) (S1 (MetaSel (Just Symbol "bitcoinSendRequestDescription") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text))) (S1 (MetaSel (Just Symbol "bitcoinSendRequestMessage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Text)))))))

data QuoteRequest #

A request to lock in a quote.

Instances

Eq QuoteRequest # 
Data QuoteRequest # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QuoteRequest -> c QuoteRequest #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QuoteRequest #

toConstr :: QuoteRequest -> Constr #

dataTypeOf :: QuoteRequest -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c QuoteRequest) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteRequest) #

gmapT :: (forall b. Data b => b -> b) -> QuoteRequest -> QuoteRequest #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QuoteRequest -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QuoteRequest -> r #

gmapQ :: (forall d. Data d => d -> u) -> QuoteRequest -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QuoteRequest -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QuoteRequest -> m QuoteRequest #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteRequest -> m QuoteRequest #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteRequest -> m QuoteRequest #

Ord QuoteRequest # 
Show QuoteRequest # 
Generic QuoteRequest # 

Associated Types

type Rep QuoteRequest :: * -> * #

NFData QuoteRequest # 

Methods

rnf :: QuoteRequest -> () #

POSTEncodeable QuoteRequest # 
HasPair QuoteRequest CcyPair # 
HasQuoteType QuoteRequest QuoteType # 
HasBaseAmount QuoteRequest Scientific # 
type Rep QuoteRequest # 
type Rep QuoteRequest = D1 (MetaData "QuoteRequest" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "QuoteRequest" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "quoteRequestQuoteType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 QuoteType)) ((:*:) (S1 (MetaSel (Just Symbol "quoteRequestPair") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CcyPair)) (S1 (MetaSel (Just Symbol "quoteRequestBaseAmount") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))))

data OrderQuote #

A temporarily locked-in quote.

Instances

Eq OrderQuote # 
Data OrderQuote # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OrderQuote -> c OrderQuote #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OrderQuote #

toConstr :: OrderQuote -> Constr #

dataTypeOf :: OrderQuote -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OrderQuote) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OrderQuote) #

gmapT :: (forall b. Data b => b -> b) -> OrderQuote -> OrderQuote #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OrderQuote -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OrderQuote -> r #

gmapQ :: (forall d. Data d => d -> u) -> OrderQuote -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OrderQuote -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OrderQuote -> m OrderQuote #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderQuote -> m OrderQuote #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OrderQuote -> m OrderQuote #

Ord OrderQuote # 
Show OrderQuote # 
Generic OrderQuote # 

Associated Types

type Rep OrderQuote :: * -> * #

NFData OrderQuote # 

Methods

rnf :: OrderQuote -> () #

BitXAesRecordConvert OrderQuote # 

Associated Types

type Aes OrderQuote :: * #

HasPair OrderQuote CcyPair # 
HasId OrderQuote Text # 
HasQuoteType OrderQuote QuoteType # 
HasBaseAmount OrderQuote Scientific # 
HasExpiresAt OrderQuote UTCTime # 
HasExercised OrderQuote Bool # 
HasDiscarded OrderQuote Bool # 
HasCreatedAt OrderQuote UTCTime # 
HasCounterAmount OrderQuote Scientific # 
type Rep OrderQuote # 
type Aes OrderQuote # 

data QuoteType #

Constructors

BUY 
SELL 

Instances

Eq QuoteType # 
Data QuoteType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QuoteType -> c QuoteType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QuoteType #

toConstr :: QuoteType -> Constr #

dataTypeOf :: QuoteType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c QuoteType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteType) #

gmapT :: (forall b. Data b => b -> b) -> QuoteType -> QuoteType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QuoteType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QuoteType -> r #

gmapQ :: (forall d. Data d => d -> u) -> QuoteType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QuoteType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteType -> m QuoteType #

Ord QuoteType # 
Show QuoteType # 
Generic QuoteType # 

Associated Types

type Rep QuoteType :: * -> * #

FromJSON QuoteType # 
NFData QuoteType # 

Methods

rnf :: QuoteType -> () #

HasQuoteType QuoteRequest QuoteType # 
HasQuoteType OrderQuote QuoteType # 
type Rep QuoteType # 
type Rep QuoteType = D1 (MetaData "QuoteType" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) ((:+:) (C1 (MetaCons "BUY" PrefixI False) U1) (C1 (MetaCons "SELL" PrefixI False) U1))

data Transaction #

A transaction on a private user account.

Instances

Eq Transaction # 
Data Transaction # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Transaction -> c Transaction #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Transaction #

toConstr :: Transaction -> Constr #

dataTypeOf :: Transaction -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Transaction) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Transaction) #

gmapT :: (forall b. Data b => b -> b) -> Transaction -> Transaction #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Transaction -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Transaction -> r #

gmapQ :: (forall d. Data d => d -> u) -> Transaction -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Transaction -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Transaction -> m Transaction #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Transaction -> m Transaction #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Transaction -> m Transaction #

Ord Transaction # 
Show Transaction # 
Generic Transaction # 

Associated Types

type Rep Transaction :: * -> * #

NFData Transaction # 

Methods

rnf :: Transaction -> () #

BitXAesRecordConvert Transaction # 

Associated Types

type Aes Transaction :: * #

HasTimestamp Transaction UTCTime # 
HasRowIndex Transaction Int # 
HasDescription Transaction Text # 
HasCurrency Transaction Asset # 
HasBalanceDelta Transaction Scientific # 
HasBalance Transaction Scientific # 
HasAvailableDelta Transaction Scientific # 
HasAvailable Transaction Scientific # 
BitXAesRecordConvert [Transaction] # 

Associated Types

type Aes [Transaction] :: * #

type Rep Transaction # 
type Aes Transaction # 
type Aes [Transaction] # 

data Account #

A registered account.

Constructors

Account 

Instances

Eq Account # 

Methods

(==) :: Account -> Account -> Bool #

(/=) :: Account -> Account -> Bool #

Data Account # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Account -> c Account #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Account #

toConstr :: Account -> Constr #

dataTypeOf :: Account -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Account) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Account) #

gmapT :: (forall b. Data b => b -> b) -> Account -> Account #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Account -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Account -> r #

gmapQ :: (forall d. Data d => d -> u) -> Account -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Account -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Account -> m Account #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Account -> m Account #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Account -> m Account #

Ord Account # 
Show Account # 
Generic Account # 

Associated Types

type Rep Account :: * -> * #

Methods

from :: Account -> Rep Account x #

to :: Rep Account x -> Account #

NFData Account # 

Methods

rnf :: Account -> () #

POSTEncodeable Account # 
BitXAesRecordConvert Account # 

Associated Types

type Aes Account :: * #

HasId Account Text # 

Methods

id :: Lens' Account Text #

HasCurrency Account Asset # 
HasName Account Text # 

Methods

name :: Lens' Account Text #

type Rep Account # 
type Rep Account = D1 (MetaData "Account" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "Account" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "accountId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) ((:*:) (S1 (MetaSel (Just Symbol "accountName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) (S1 (MetaSel (Just Symbol "accountCurrency") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Asset)))))
type Aes Account # 

data PrivateTrade #

A private trade, containing a lot more information than is avaiable when inspecting trades via the public API.

Instances

Eq PrivateTrade # 
Data PrivateTrade # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrivateTrade -> c PrivateTrade #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrivateTrade #

toConstr :: PrivateTrade -> Constr #

dataTypeOf :: PrivateTrade -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PrivateTrade) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrivateTrade) #

gmapT :: (forall b. Data b => b -> b) -> PrivateTrade -> PrivateTrade #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrivateTrade -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrivateTrade -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrivateTrade -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrivateTrade -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrivateTrade -> m PrivateTrade #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivateTrade -> m PrivateTrade #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrivateTrade -> m PrivateTrade #

Ord PrivateTrade # 
Show PrivateTrade # 
Generic PrivateTrade # 

Associated Types

type Rep PrivateTrade :: * -> * #

NFData PrivateTrade # 

Methods

rnf :: PrivateTrade -> () #

BitXAesRecordConvert PrivateTrade # 

Associated Types

type Aes PrivateTrade :: * #

HasTimestamp PrivateTrade UTCTime # 
HasPair PrivateTrade CcyPair # 
HasVolume PrivateTrade Scientific # 
HasPrice PrivateTrade Int # 
HasIsBuy PrivateTrade Bool # 
HasOrderType PrivateTrade OrderType # 
HasFeeCounter PrivateTrade Scientific # 
HasFeeBase PrivateTrade Scientific # 
HasCounter PrivateTrade Scientific # 
HasBase PrivateTrade Scientific # 
HasOrderId PrivateTrade Text # 
BitXAesRecordConvert [PrivateTrade] # 

Associated Types

type Aes [PrivateTrade] :: * #

type Rep PrivateTrade # 
type Rep PrivateTrade = D1 (MetaData "PrivateTrade" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "PrivateTrade" PrefixI True) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeBase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "privateTradeCounter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific))) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeFeeBase") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeFeeCounter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "privateTradeIsBuy") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))))) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeOrderId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)) ((:*:) (S1 (MetaSel (Just Symbol "privateTradePair") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 CcyPair)) (S1 (MetaSel (Just Symbol "privateTradePrice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeTimestamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 UTCTime)) ((:*:) (S1 (MetaSel (Just Symbol "privateTradeOrderType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OrderType)) (S1 (MetaSel (Just Symbol "privateTradeVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))))))
type Aes PrivateTrade # 
type Aes [PrivateTrade] # 

data FeeInfo #

Fee information

Instances

Eq FeeInfo # 

Methods

(==) :: FeeInfo -> FeeInfo -> Bool #

(/=) :: FeeInfo -> FeeInfo -> Bool #

Data FeeInfo # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FeeInfo -> c FeeInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FeeInfo #

toConstr :: FeeInfo -> Constr #

dataTypeOf :: FeeInfo -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FeeInfo) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FeeInfo) #

gmapT :: (forall b. Data b => b -> b) -> FeeInfo -> FeeInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FeeInfo -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FeeInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> FeeInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FeeInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FeeInfo -> m FeeInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FeeInfo -> m FeeInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FeeInfo -> m FeeInfo #

Ord FeeInfo # 
Show FeeInfo # 
Generic FeeInfo # 

Associated Types

type Rep FeeInfo :: * -> * #

Methods

from :: FeeInfo -> Rep FeeInfo x #

to :: Rep FeeInfo x -> FeeInfo #

BitXAesRecordConvert FeeInfo # 

Associated Types

type Aes FeeInfo :: * #

HasThirtyDayVolume FeeInfo Scientific # 
HasTakerFee FeeInfo Scientific # 
HasMakerFee FeeInfo Scientific # 
type Rep FeeInfo # 
type Rep FeeInfo = D1 (MetaData "FeeInfo" "Network.Bitcoin.BitX.Types" "bitx-bitcoin-0.11.0.1-7JezUSL5BfYId9lV6fvWa1" False) (C1 (MetaCons "FeeInfo" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "feeInfoMakerFee") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) ((:*:) (S1 (MetaSel (Just Symbol "feeInfoTakerFee") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)) (S1 (MetaSel (Just Symbol "feeInfoThirtyDayVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Scientific)))))
type Aes FeeInfo # 

Convenient constructors for records which serve as input parameters to functions. These are not completely safe (since you can forget to set a field and the Haskell compiler won't notice), but they are a bit more convenient than dealing with the raw records directly, as long as you're careful.

mkBitXAuth :: BitXAuth #

mkBitXAuth = BitXAuth "" ""

mkAccount :: Account #

mkAccount = Account "" "" ZAR

mkBitcoinSendRequest :: BitcoinSendRequest #

mkBitcoinSendRequest = BitcoinSendRequest 0 ZAR "" Nothing Nothing

mkOrderRequest :: OrderRequest #

mkOrderRequest = OrderRequest ZARXBT BID 0 0

mkQuoteRequest :: QuoteRequest #

mkQuoteRequest = QuoteRequest BUY ZARXBT 0

mkNewWithdrawal :: NewWithdrawal #

mkNewWithdrawal = NewWithdrawal ZAR_EFT 0

mkMarketOrderRequest :: MarketOrderRequest #

mkMarketOrderRequest = MarketOrderRequest ZARXBT BID 0

Lens Has* instances for convenient record accessors and mutators.

For a broader view of how these function (and why you can generally ignore them) see the documentation for lens's makeFields.

Essentially, an instance declaration of the form

instance HasFoo MyRecord Int

implies that we can pretend that the data type MyRecord has a field called Foo of type Int (although in reality the field would be called myRecordFoo or such), and that there exists a lens called foo which can be used -- among other things -- as a setter and getter on MyRecord.

class HasError s a | s -> a where #

Minimal complete definition

error

Methods

error :: Lens' s a #

class HasErrorCode s a | s -> a where #

Minimal complete definition

errorCode

Methods

errorCode :: Lens' s a #

class HasBid s a | s -> a where #

Minimal complete definition

bid

Methods

bid :: Lens' s a #

Instances

class HasAsk s a | s -> a where #

Minimal complete definition

ask

Methods

ask :: Lens' s a #

Instances

class HasLastTrade s a | s -> a where #

Minimal complete definition

lastTrade

Methods

lastTrade :: Lens' s a #

class HasRolling24HourVolume s a | s -> a where #

Minimal complete definition

rolling24HourVolume

class HasPrice s a | s -> a where #

Minimal complete definition

price

Methods

price :: Lens' s a #

class HasBids s a | s -> a where #

Minimal complete definition

bids

Methods

bids :: Lens' s a #

Instances

class HasAsks s a | s -> a where #

Minimal complete definition

asks

Methods

asks :: Lens' s a #

Instances

class HasSecret s a | s -> a where #

Minimal complete definition

secret

Methods

secret :: Lens' s a #

class HasId s a | s -> a where #

Minimal complete definition

id

Methods

id :: Lens' s a #

class HasBase s a | s -> a where #

Minimal complete definition

base

Methods

base :: Lens' s a #

class HasCounter s a | s -> a where #

Minimal complete definition

counter

Methods

counter :: Lens' s a #

class HasCreationTimestamp s a | s -> a where #

Minimal complete definition

creationTimestamp

Methods

creationTimestamp :: Lens' s a #

class HasFeeBase s a | s -> a where #

Minimal complete definition

feeBase

Methods

feeBase :: Lens' s a #

class HasLimitPrice s a | s -> a where #

Minimal complete definition

limitPrice

Methods

limitPrice :: Lens' s a #

class HasState s a | s -> a where #

Minimal complete definition

state

Methods

state :: Lens' s a #

class HasLimitVolume s a | s -> a where #

Minimal complete definition

limitVolume

Methods

limitVolume :: Lens' s a #

class HasRowIndex s a | s -> a where #

Minimal complete definition

rowIndex

Methods

rowIndex :: Lens' s a #

class HasBalance s a | s -> a where #

Minimal complete definition

balance

Methods

balance :: Lens' s a #

class HasAvailable s a | s -> a where #

Minimal complete definition

available

Methods

available :: Lens' s a #

class HasBalanceDelta s a | s -> a where #

Minimal complete definition

balanceDelta

Methods

balanceDelta :: Lens' s a #

class HasAvailableDelta s a | s -> a where #

Minimal complete definition

availableDelta

Methods

availableDelta :: Lens' s a #

class HasAsset s a | s -> a where #

Minimal complete definition

asset

Methods

asset :: Lens' s a #

class HasReserved s a | s -> a where #

Minimal complete definition

reserved

Methods

reserved :: Lens' s a #

class HasUnconfirmed s a | s -> a where #

Minimal complete definition

unconfirmed

Methods

unconfirmed :: Lens' s a #

class HasAddress s a | s -> a where #

Minimal complete definition

address

Methods

address :: Lens' s a #

class HasTotalReceived s a | s -> a where #

Minimal complete definition

totalReceived

Methods

totalReceived :: Lens' s a #

class HasAmount s a | s -> a where #

Minimal complete definition

amount

Methods

amount :: Lens' s a #

class HasWithdrawalType s a | s -> a where #

Minimal complete definition

withdrawalType

Methods

withdrawalType :: Lens' s a #

class HasMessage s a | s -> a where #

Minimal complete definition

message

Methods

message :: Lens' s a #

class HasQuoteType s a | s -> a where #

Minimal complete definition

quoteType

Methods

quoteType :: Lens' s a #

class HasCounterAmount s a | s -> a where #

Minimal complete definition

counterAmount

Methods

counterAmount :: Lens' s a #

class HasCreatedAt s a | s -> a where #

Minimal complete definition

createdAt

Methods

createdAt :: Lens' s a #

class HasExpiresAt s a | s -> a where #

Minimal complete definition

expiresAt

Methods

expiresAt :: Lens' s a #

class HasDiscarded s a | s -> a where #

Minimal complete definition

discarded

Methods

discarded :: Lens' s a #

class HasExercised s a | s -> a where #

Minimal complete definition

exercised

Methods

exercised :: Lens' s a #

class HasName s a | s -> a where #

Minimal complete definition

name

Methods

name :: Lens' s a #

Instances

class HasIsBuy s a | s -> a where #

Minimal complete definition

isBuy

Methods

isBuy :: Lens' s a #

class HasStatus s a | s -> a where #

Minimal complete definition

status

Methods

status :: Lens' s a #

class HasBeneficiaryId s a | s -> a where #

Minimal complete definition

beneficiaryId

Methods

beneficiaryId :: Lens' s a #

class HasOrderId s a | s -> a where #

Minimal complete definition

orderId

Methods

orderId :: Lens' s a #

class HasMakerFee s a | s -> a where #

Minimal complete definition

makerFee

Methods

makerFee :: Lens' s a #

class HasTakerFee s a | s -> a where #

Minimal complete definition

takerFee

Methods

takerFee :: Lens' s a #

class HasThirtyDayVolume s a | s -> a where #

Minimal complete definition

thirtyDayVolume

Methods

thirtyDayVolume :: Lens' s a #