diff --git a/haskoin-bitcoind.cabal b/haskoin-bitcoind.cabal
--- a/haskoin-bitcoind.cabal
+++ b/haskoin-bitcoind.cabal
@@ -1,12 +1,12 @@
 name:                haskoin-bitcoind
-version:             0.3.0
+version:             0.4.1
 synopsis:            An adapter for haskoin to network-bitcoin
--- description:
+description:         An adapter for haskoin to network-bitcoin. You can call network-bitcoin functions with haskoin types.
 homepage:            haskoin.com
 license:             BSD3
 license-file:        LICENSE
 author:              Matthew Wraith
-maintainer:          wraithm@gmail.com
+maintainer:          matt@bitnomial.com
 copyright:           2015 Bitnomial, Inc
 category:            Network
 build-type:          Simple
@@ -21,11 +21,11 @@
                  , Network.Bitcoin.Mining.Haskoin
                  , Network.Bitcoin.Wallet.Haskoin
 
-  build-depends: base                >= 4.8 && < 4.12
+  build-depends: base                >= 4.8 && < 4.13
                , base16-bytestring   >= 0.1.1.6
                , bytestring          >= 0.10.6
                , cereal              >= 0.5 && < 0.6
-               , haskoin-core        >= 0.4.3
+               , haskoin-core        >= 0.9.0
                , monad-control       >= 0.1
                , mtl                 >= 2.2
                , network-bitcoin     >= 1.8.2
diff --git a/src/Network/Bitcoin/Haskoin.hs b/src/Network/Bitcoin/Haskoin.hs
--- a/src/Network/Bitcoin/Haskoin.hs
+++ b/src/Network/Bitcoin/Haskoin.hs
@@ -32,10 +32,11 @@
                                               TransactionID, getClient,
                                               getRawTransaction)
 import qualified Network.Bitcoin             as B
-import           Network.Haskoin.Crypto      (Address, addrToBase58,
-                                              base58ToAddr)
-import           Network.Haskoin.Script      (decodeInputBS, decodeOutputBS,
-                                              inputAddress, outputAddress)
+import           Network.Haskoin.Address     (Address, addrToString,
+                                              inputAddress, outputAddress,
+                                              scriptToAddressBS, stringToAddr)
+import           Network.Haskoin.Constants   (Network)
+import           Network.Haskoin.Script      (decodeInputBS)
 import           Network.Haskoin.Transaction (OutPoint (..), Tx (..), TxHash,
                                               TxIn, TxOut, hexToTxHash,
                                               scriptInput, scriptOutput,
@@ -43,19 +44,19 @@
 
 
 transactionOutputAddress :: TxOut -> Either String Address
-transactionOutputAddress = outputAddress <=< decodeOutputBS . scriptOutput
+transactionOutputAddress = scriptToAddressBS . scriptOutput
 
 
-transactionInputAddress :: TxIn -> Either String Address
-transactionInputAddress = inputAddress <=< decodeInputBS . scriptInput
+transactionInputAddress :: Network -> TxIn -> Either String Address
+transactionInputAddress net = maybe (Left "could not decode address") Right . inputAddress <=< decodeInputBS net . scriptInput
 
 
-addressToHex :: Address -> B.Address
-addressToHex = decodeUtf8 . addrToBase58
+addressToHex :: Network -> Address -> B.Address
+addressToHex net = fromMaybe (error "Address encoding error") . addrToString net
 
 
-hexToAddress :: B.Address -> Address
-hexToAddress = fromMaybe (error "Unable to parse address") . base58ToAddr . encodeUtf8
+hexToAddress :: Network -> B.Address -> Address
+hexToAddress net = fromMaybe (error "Unable to parse address") . stringToAddr net
 
 
 -- | TODO Catch bad decodes
@@ -67,11 +68,11 @@
 
 
 hexTxHash :: TxHash -> TransactionID
-hexTxHash = E.decodeUtf8 . txHashToHex
+hexTxHash = txHashToHex
 
 
 transactionIdToTxHash :: TransactionID -> TxHash
-transactionIdToTxHash = fromMaybe (error "Unable to parse txid") . hexToTxHash . encodeUtf8
+transactionIdToTxHash = fromMaybe (error "Unable to parse txid") . hexToTxHash
 
 
 -- | TODO Catch errors from bitcoind
@@ -87,5 +88,5 @@
 outpointAddress c op = transactionOutputAddress <$> getTransactionOutput c op
 
 
-importAddress :: Client -> Address -> Maybe B.Account -> Maybe Bool -> IO ()
-importAddress client addr = B.importAddress client (E.decodeUtf8 $ addrToBase58 addr)
+importAddress :: Client -> Network -> Address -> Maybe B.Account -> Maybe Bool -> IO ()
+importAddress client net addr = B.importAddress client (addressToHex net addr)
diff --git a/src/Network/Bitcoin/Haskoin/Trans.hs b/src/Network/Bitcoin/Haskoin/Trans.hs
--- a/src/Network/Bitcoin/Haskoin/Trans.hs
+++ b/src/Network/Bitcoin/Haskoin/Trans.hs
@@ -8,6 +8,9 @@
 module Network.Bitcoin.Haskoin.Trans
     ( BitcoinT (..)
     , runBitcoinT
+    , newBitcoindClient
+    , getBitcoindClient
+    , BitcoindClient (..)
 
     , -- * Bitcoind operations
       getTransaction
@@ -35,38 +38,58 @@
 import           Control.Monad.IO.Class
 import           Control.Monad.Reader        (MonadReader, ReaderT (..), ask)
 import           Control.Monad.Trans         (MonadTrans (..))
+import           Data.ByteString             (ByteString)
 
 import           Network.Bitcoin             (Account)
 import           Network.Bitcoin.Haskoin     (Client)
 import qualified Network.Bitcoin.Haskoin     as B
-import           Network.Haskoin.Crypto      (Address)
+import           Network.Haskoin.Address     (Address)
+import           Network.Haskoin.Constants   (Network)
 import           Network.Haskoin.Transaction (OutPoint, Tx (..), TxHash,
                                               TxIn (..), TxOut (..))
 
 
-newtype BitcoinT m a = BitcoinT { unBitcoinT :: ReaderT Client m a }
-    deriving (Functor, Applicative, Monad, MonadTrans, MonadIO, MonadReader Client)
+data BitcoindClient = BitcoindClient
+    { bitcoindClient  :: Client
+    , bitcoindNetwork :: Network
+    }
 
 
+newBitcoindClient :: Client -> Network -> BitcoindClient
+newBitcoindClient = BitcoindClient
+
+
+type URL = String
+type User = ByteString
+type Password = ByteString
+
+
+getBitcoindClient :: URL -> User -> Password -> Network -> IO BitcoindClient
+getBitcoindClient url user password net = do
+    client <- B.getClient url user password
+    return $ newBitcoindClient client net
+
+
+-- TODO Add Network to Reader
+newtype BitcoinT m a = BitcoinT { unBitcoinT :: ReaderT BitcoindClient m a }
+    deriving (Functor, Applicative, Monad, MonadTrans, MonadIO, MonadReader BitcoindClient)
+
+
 instance MonadBase b m => MonadBase b (BitcoinT m) where
     liftBase = lift . liftBase
 
 
-runBitcoinT :: Client -> BitcoinT m a -> m a
+runBitcoinT :: BitcoindClient -> BitcoinT m a -> m a
 runBitcoinT c = flip runReaderT c . unBitcoinT
 -- TODO Handle exceptions
 
 
 withClient :: Monad m => (Client -> m a) -> BitcoinT m a
-withClient f = do
-    cl <- ask
-    lift (f cl)
+withClient f = ask >>= lift . f . bitcoindClient
 
 
 withClientIO :: MonadIO m => (Client -> IO a) -> BitcoinT m a
-withClientIO f = do
-    cl <- ask
-    liftIO (f cl)
+withClientIO f = ask >>= liftIO . f . bitcoindClient
 
 
 getTransaction :: MonadIO m => TxHash -> BitcoinT m Tx
@@ -82,9 +105,11 @@
 
 
 importAddress' :: MonadIO m => Address -> Maybe Account -> Maybe Bool -> BitcoinT m ()
-importAddress' addr macct mrescan =
-    withClientIO (\cl -> B.importAddress cl addr macct mrescan)
+importAddress' addr macct mrescan = do
+    BitcoindClient cl net <- ask
+    liftIO $ B.importAddress cl net addr macct mrescan
 
 
+-- TODO Accounts are being removed, remove the account field from network-bitcoind
 importAddress :: MonadIO m => Address -> BitcoinT m ()
 importAddress addr = importAddress' addr (Just "") (Just False)
diff --git a/src/Network/Bitcoin/Mining/Haskoin.hs b/src/Network/Bitcoin/Mining/Haskoin.hs
--- a/src/Network/Bitcoin/Mining/Haskoin.hs
+++ b/src/Network/Bitcoin/Mining/Haskoin.hs
@@ -1,27 +1,21 @@
 module Network.Bitcoin.Mining.Haskoin
   ( generate
+  , generateToAddress
   ) where
 
-import           Data.Fixed                  (Fixed (MkFixed))
-import           Data.Maybe                  (fromMaybe, maybe)
-import           Data.Text                   (Text)
-import           Data.Text.Encoding          (decodeUtf8, encodeUtf8)
-import           Data.Word                   (Word64)
 import           Network.Bitcoin.Haskoin     (addressToHex,
                                               transactionIdToTxHash)
 import qualified Network.Bitcoin.Mining      as NBM
-import qualified Network.Bitcoin.Types       as NBT
 import           Network.Bitcoin.Wallet      (Client)
-import qualified Network.Bitcoin.Wallet      as W
-import           Network.Haskoin.Crypto      (addrToBase58, base58ToAddr)
-import qualified Network.Haskoin.Crypto      as HSK
-import           Network.Haskoin.Transaction (TxHash, hexToTxHash)
+import qualified Network.Haskoin.Address     as HSK
+import           Network.Haskoin.Constants   (Network)
+import           Network.Haskoin.Transaction (TxHash)
 
 
 generate :: Client -> Int -> Maybe Int -> IO [TxHash]
 generate client blocks maxTries = fmap transactionIdToTxHash <$> NBM.generate client blocks maxTries
 
 
-generateToAddress :: Client -> Int -> HSK.Address -> Maybe Int -> IO [TxHash]
-generateToAddress client blocks toAddr maxTries =
-    fmap transactionIdToTxHash <$> NBM.generateToAddress client blocks (addressToHex toAddr) maxTries
+generateToAddress :: Client -> Network -> Int -> HSK.Address -> Maybe Int -> IO [TxHash]
+generateToAddress client net blocks toAddr maxTries =
+    fmap transactionIdToTxHash <$> NBM.generateToAddress client blocks (addressToHex net toAddr) maxTries
diff --git a/src/Network/Bitcoin/Wallet/Haskoin.hs b/src/Network/Bitcoin/Wallet/Haskoin.hs
--- a/src/Network/Bitcoin/Wallet/Haskoin.hs
+++ b/src/Network/Bitcoin/Wallet/Haskoin.hs
@@ -4,30 +4,28 @@
     ) where
 
 import           Data.Fixed                  (Fixed (MkFixed))
-import           Data.Maybe                  (fromMaybe, maybe)
 import           Data.Text                   (Text)
-import           Data.Text.Encoding          (decodeUtf8, encodeUtf8)
 import           Data.Word                   (Word64)
 import           Network.Bitcoin.Haskoin     (addressToHex, hexToAddress,
                                               transactionIdToTxHash)
 import qualified Network.Bitcoin.Types       as NBT
 import           Network.Bitcoin.Wallet      (Client)
 import qualified Network.Bitcoin.Wallet      as W
-import           Network.Haskoin.Crypto      (addrToBase58, base58ToAddr)
-import qualified Network.Haskoin.Crypto      as HSK
-import           Network.Haskoin.Transaction (TxHash, hexToTxHash)
+import qualified Network.Haskoin.Address     as HSK
+import           Network.Haskoin.Constants   (Network)
+import           Network.Haskoin.Transaction (TxHash)
 
 
 type Satoshi = Word64
 
 
-sendToAddress :: Client -> HSK.Address -> Satoshi -> Maybe Text -> Maybe Text -> IO TxHash
-sendToAddress client addr sat cmt cmtTo =
-    transactionIdToTxHash <$> W.sendToAddress client (addressToHex addr) (satToBTC sat) cmt cmtTo
+sendToAddress :: Client -> Network -> HSK.Address -> Satoshi -> Maybe Text -> Maybe Text -> IO TxHash
+sendToAddress client net addr sat cmt cmtTo =
+    transactionIdToTxHash <$> W.sendToAddress client (addressToHex net addr) (satToBTC sat) cmt cmtTo
 
 
-getNewAddress :: Client -> IO HSK.Address
-getNewAddress client = hexToAddress <$> W.getNewAddress client Nothing
+getNewAddress :: Client -> Network -> IO HSK.Address
+getNewAddress client net = hexToAddress net <$> W.getNewAddress client Nothing
 
 
 satToBTC :: Satoshi -> NBT.BTC