| Safe Haskell | None |
|---|
Network.Bitcoin.Internal
Description
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
- tj :: ToJSON a => a -> Value
- data WrappedBTC = WBTC {}
- newtype AddrAddress = AA (Vector (Address, BTC))
Documentation
module Network.Bitcoin.Types
data Text
A space efficient, packed, unboxed Unicode text type.
data Vector a
Boxed vectors, supporting efficient slicing.
Instances
| Monad Vector | |
| Functor Vector | |
| Typeable1 Vector | |
| MonadPlus Vector | |
| Applicative Vector | |
| Foldable Vector | |
| Traversable Vector | |
| Alternative Vector | |
| MVector (Mutable Vector) a => Vector Vector a | |
| Eq a => Eq (Vector a) | |
| (Typeable (Vector a), Data a) => Data (Vector a) | |
| (Eq (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 use mzero 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
fromJSONfunction that parses to any type which is an instance ofData. - If your compiler has support for the
DeriveGenericandDefaultSignatureslanguage extensions,parseJSONwill have a default generic implementation.
To use this, simply add a deriving clause to your datatype and
declare a GenericFromJSON 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
Instances
Arguments
| :: 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.
data WrappedBTC Source
Used to provide a FromJSON instance for fixed-point bitcoins. This can be removed after https://github.com/bos/aeson/pull/89 gets merged into master, and is released on Hackage.
Instances
newtype AddrAddress Source
A wrapper for a vector of address:amount pairs. The RPC expects that as an object of address:amount pairs, instead of a vector. So that's what we give them with AddrAddress's ToJSON.
Instances