Safe Haskell | None |
---|
The API exposed in this module should be considered unstable, and is subject to change between minor revisions.
If the version number is a.b.c.d, and either a or b changes, then the module's whole API may have changed (if only b changes, then it was probably a minor change).
If c changed, then only the internal API may change. The rest of the module is guaranteed to be stable.
If only d changes, then there were no user-facing code changes made.
- module Network.Bitcoin.Types
- data Text
- data Vector a
- class FromJSON a where
- callApi :: FromJSON v => Auth -> Text -> [Value] -> IO v
- callApi' :: Auth -> ByteString -> IO ByteString
- data Nil = Nil {
- unNil :: ()
- tj :: ToJSON a => a -> Value
- newtype AddrAddress = AA (Vector (Address, BTC))
- data BitcoinRpcResponse a = BitcoinRpcResponse {}
Documentation
module Network.Bitcoin.Types
data Text
A space efficient, packed, unboxed Unicode text type.
data Vector a
Boxed vectors, supporting efficient slicing.
Monad Vector | |
Functor Vector | |
Typeable1 Vector | |
MonadPlus Vector | |
Applicative Vector | |
Foldable Vector | |
Traversable Vector | |
Alternative Vector | |
Vector Vector a | |
Eq a => Eq (Vector a) | |
Data a => Data (Vector a) | |
Ord a => Ord (Vector a) | |
Read a => Read (Vector a) | |
Show a => Show (Vector a) | |
ToJSON a => ToJSON (Vector a) | |
FromJSON a => FromJSON (Vector a) | |
Monoid (Vector a) | |
NFData a => NFData (Vector a) |
class FromJSON a where
A type that can be converted from JSON, with the possibility of failure.
When writing an instance, use empty
, mzero
, or fail
to make a
conversion fail, e.g. if an Object
is missing a required key, or
the value is of the wrong type.
An example type and instance:
{-# LANGUAGE OverloadedStrings #-} data Coord { x :: Double, y :: Double } instance FromJSON Coord where parseJSON (Object
v) = Coord<$>
v.:
"x"<*>
v.:
"y" -- A non-Object
value is of the wrong type, so usemzero
to fail. parseJSON _ =mzero
Note the use of the OverloadedStrings
language extension which enables
Text
values to be written as string literals.
Instead of manually writing your FromJSON
instance, there are three options
to do it automatically:
- Data.Aeson.TH provides template-haskell functions which will derive an instance at compile-time. The generated instance is optimized for your type so will probably be more efficient than the following two options:
- Data.Aeson.Generic provides a generic
fromJSON
function that parses to any type which is an instance ofData
. - If your compiler has support for the
DeriveGeneric
andDefaultSignatures
language extensions,parseJSON
will have a default generic implementation.
To use this, simply add a deriving
clause to your datatype and
declare a Generic
FromJSON
instance for your datatype without giving a definition
for parseJSON
.
For example the previous example can be simplified to just:
{-# LANGUAGE DeriveGeneric #-} import GHC.Generics data Coord { x :: Double, y :: Double } deriving Generic instance FromJSON Coord
Note that, instead of using DefaultSignatures
, it's also possible
to parameterize the generic decoding using genericParseJSON
applied
to your encoding/decoding Options
:
instance FromJSON Coord where parseJSON =genericParseJSON
defaultOptions
:: FromJSON v | |
=> Auth | authentication credentials for bitcoind |
-> Text | command name |
-> [Value] | command arguments |
-> IO v |
callApi
is a low-level interface for making authenticated API
calls to a Bitcoin daemon. The first argument specifies
authentication details (URL, username, password) and is often
curried for convenience:
callBtc = callApi $ Auth "http://127.0.0.1:8332" "user" "password"
The second argument is the command name. The third argument provides parameters for the API call.
let result = callBtc "getbalance" [ tj "account-name", tj 6 ]
On error, throws a BitcoinException
.
callApi' :: Auth -> ByteString -> IO ByteStringSource
The no conversion needed implementation of callApi. THis lets us inline and specialize callApi for its parameters, while keeping the bulk of the work in this function shared.
newtype AddrAddress Source
data BitcoinRpcResponse a Source
A response from bitcoind will contain the result of the JSON-RPC call, and an error. The error should be null if a valid response was received.
Eq a => Eq (BitcoinRpcResponse a) | |
Ord a => Ord (BitcoinRpcResponse a) | |
Read a => Read (BitcoinRpcResponse a) | |
Show a => Show (BitcoinRpcResponse a) | |
FromJSON a => FromJSON (BitcoinRpcResponse a) |