Documentation

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.

type Ticker =
    [record|
        {ask :: Decimal,
         timestamp :: UTCTime,
         bid :: Decimal,
         rolling24HourVolume :: Decimal,
         lastTrade :: Decimal,
         pair :: CcyPair} |]
 

A currency pair

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

type Orderbook =
    [record|
        {timestamp :: UTCTime,
         bids :: [Bid],
         asks :: [Ask]} |]
 

A single placed order in the orderbook

type Order =
    [record|
        {volume :: Decimal,
         price :: Decimal} |]
 

Convenient type alias for a bid order

Convenient type alias for an ask order

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

type BitXAuth =
    [record|
        {id :: Text,
         secret :: Text} |]
 

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

type PrivateOrder =
    [record|
        {base :: Decimal,
         counter :: Decimal,
         creationTimestamp :: UTCTime,
         expirationTimestamp :: UTCTime,
         feeBase :: Decimal,
         feeCounter :: Decimal,
         limitPrice :: Decimal,
         limitVolume :: Decimal,
         id :: OrderID,
         pair :: CcyPair,
         state :: RequestStatus,
         type :: OrderType } |]
 

The type of a placed order.

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

A request to place an order.

type OrderRequest =
    [record|
        {pair :: CcyPair,
         type :: OrderType,
         volume :: Decimal,
         price :: Decimal } |]
 

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...

type BitXError =
    [record|
        {error :: Text,
         errorCode :: Text} |]
 

A recently placed (private) order, containing a lot more information than is available on the public order book, together with details of any trades which have (partially) filled it.

type PrivateOrderWithTrades =
    [record|
        {base :: Decimal,
         counter :: Decimal,
         creationTimestamp :: UTCTime,
         expirationTimestamp :: UTCTime,
         feeBase :: Decimal,
         feeCounter :: Decimal,
         limitPrice :: Decimal,
         limitVolume :: Decimal,
         id :: OrderID,
         pair :: CcyPair,
         state :: RequestStatus,
         type :: OrderType,
         trades :: [Trade] } |]
 

A trade-able asset. Essentially, a currency.

The current balance of a private account.

type Balance =
    [record|
        {id :: AccountID,
         asset :: Asset,
         balance :: Decimal,
         reserved :: Decimal,
         unconfirmed :: Decimal } |]
 

A registered address for an acocunt.

type FundingAddress =
    [record|
        {asset :: Asset,
         address :: Text,
         totalReceived :: Decimal,
         totalUnconfirmed :: Decimal} |]
 

The state of a request to withdraw from an account.

type WithdrawalRequest =
    [record|
        {status :: RequestStatus,
         id :: Text } |]
 

A request to withdraw from an account.

type NewWithdrawal =
    [record|
        {type :: WithdrawalType,
         amount :: Decimal } |]
 

The type of a withdrawal request.

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

type BitcoinSendRequest =
    [record|
        {amount :: Decimal,
         currency :: Asset,
         address :: Text,
         description :: Maybe Text,
         message :: Maybe Text} |]
 

A request to lock in a quote.

type QuoteRequest =
    [record|
        {type :: QuoteType,
         pair :: CcyPair,
         baseAmount :: Decimal} |]
 

A temporarily locked in quote.

type OrderQuote =
    [record|
        {id :: Text,
         type :: QuoteType,
         pair :: CcyPair,
         baseAmount :: Decimal,
         counterAmount :: Decimal,
         createdAt :: UTCTime,
         expiresAt :: UTCTime,
         discarded :: Bool,
         exercised :: Bool} |]
 

A transaction on a private user account.

type Transaction =
    [record|
        {rowIndex :: Int,
         timestamp :: UTCTime,
         balance :: Decimal,
         available :: Decimal,
         balanceDelta :: Decimal,
         availableDelta :: Decimal,
         currency :: Asset,
         description :: Text}|]