{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}

module Haskoin.Store.Database.Writer (WriterT, runWriter) where

import Control.Monad.Reader (ReaderT (..))
import qualified Control.Monad.Reader as R
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as M
import Data.List (sortOn)
import Data.Ord (Down (..))
import Data.Tuple (swap)
import Database.RocksDB (BatchOp, DB)
import Database.RocksDB.Query (
    deleteOp,
    deleteOpCF,
    insertOp,
    insertOpCF,
    writeBatch,
 )
import Haskoin (
    Address,
    BlockHash,
    BlockHeight,
    Network,
    OutPoint (..),
    TxHash,
    headerHash,
    txHash,
 )
import Haskoin.Store.Common
import Haskoin.Store.Data
import Haskoin.Store.Database.Reader
import Haskoin.Store.Database.Types
import UnliftIO (
    MonadIO,
    TVar,
    atomically,
    liftIO,
    modifyTVar,
    newTVarIO,
    readTVarIO,
 )

data Writer = Writer
    { Writer -> DatabaseReader
getReader :: !DatabaseReader
    , Writer -> TVar Memory
getState :: !(TVar Memory)
    }

type WriterT = ReaderT Writer

instance MonadIO m => StoreReadBase (WriterT m) where
    getNetwork :: WriterT m Network
getNetwork = WriterT m Network
forall (m :: * -> *). MonadIO m => WriterT m Network
getNetworkI
    getBestBlock :: WriterT m (Maybe BlockHash)
getBestBlock = WriterT m (Maybe BlockHash)
forall (m :: * -> *). MonadIO m => WriterT m (Maybe BlockHash)
getBestBlockI
    getBlocksAtHeight :: BlockHeight -> WriterT m [BlockHash]
getBlocksAtHeight = BlockHeight -> WriterT m [BlockHash]
forall (m :: * -> *).
MonadIO m =>
BlockHeight -> WriterT m [BlockHash]
getBlocksAtHeightI
    getBlock :: BlockHash -> WriterT m (Maybe BlockData)
getBlock = BlockHash -> WriterT m (Maybe BlockData)
forall (m :: * -> *).
MonadIO m =>
BlockHash -> WriterT m (Maybe BlockData)
getBlockI
    getTxData :: TxHash -> WriterT m (Maybe TxData)
getTxData = TxHash -> WriterT m (Maybe TxData)
forall (m :: * -> *).
MonadIO m =>
TxHash -> WriterT m (Maybe TxData)
getTxDataI
    getSpender :: OutPoint -> WriterT m (Maybe Spender)
getSpender = OutPoint -> WriterT m (Maybe Spender)
forall (m :: * -> *).
MonadIO m =>
OutPoint -> WriterT m (Maybe Spender)
getSpenderI
    getUnspent :: OutPoint -> WriterT m (Maybe Unspent)
getUnspent = OutPoint -> WriterT m (Maybe Unspent)
forall (m :: * -> *).
MonadIO m =>
OutPoint -> WriterT m (Maybe Unspent)
getUnspentI
    getBalance :: Address -> WriterT m (Maybe Balance)
getBalance = Address -> WriterT m (Maybe Balance)
forall (m :: * -> *).
MonadIO m =>
Address -> WriterT m (Maybe Balance)
getBalanceI
    getMempool :: WriterT m [(UnixTime, TxHash)]
getMempool = WriterT m [(UnixTime, TxHash)]
forall (m :: * -> *). MonadIO m => WriterT m [(UnixTime, TxHash)]
getMempoolI

data Memory = Memory
    { Memory -> Maybe Network
hNet ::
        !(Maybe Network)
    , Memory -> Maybe (Maybe BlockHash)
hBest ::
        !(Maybe (Maybe BlockHash))
    , Memory -> HashMap BlockHash (Maybe BlockData)
hBlock ::
        !(HashMap BlockHash (Maybe BlockData))
    , Memory -> HashMap BlockHeight [BlockHash]
hHeight ::
        !(HashMap BlockHeight [BlockHash])
    , Memory -> HashMap TxHash (Maybe TxData)
hTx ::
        !(HashMap TxHash (Maybe TxData))
    , Memory -> HashMap OutPoint (Maybe Spender)
hSpender ::
        !(HashMap OutPoint (Maybe Spender))
    , Memory -> HashMap OutPoint (Maybe Unspent)
hUnspent ::
        !(HashMap OutPoint (Maybe Unspent))
    , Memory -> HashMap Address (Maybe Balance)
hBalance ::
        !(HashMap Address (Maybe Balance))
    , Memory -> HashMap (Address, TxRef) (Maybe ())
hAddrTx ::
        !(HashMap (Address, TxRef) (Maybe ()))
    , Memory -> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut ::
        !(HashMap (Address, BlockRef, OutPoint) (Maybe OutVal))
    , Memory -> HashMap TxHash UnixTime
hMempool ::
        !(HashMap TxHash UnixTime)
    }
    deriving (Memory -> Memory -> Bool
(Memory -> Memory -> Bool)
-> (Memory -> Memory -> Bool) -> Eq Memory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Memory -> Memory -> Bool
$c/= :: Memory -> Memory -> Bool
== :: Memory -> Memory -> Bool
$c== :: Memory -> Memory -> Bool
Eq, Int -> Memory -> ShowS
[Memory] -> ShowS
Memory -> String
(Int -> Memory -> ShowS)
-> (Memory -> String) -> ([Memory] -> ShowS) -> Show Memory
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Memory] -> ShowS
$cshowList :: [Memory] -> ShowS
show :: Memory -> String
$cshow :: Memory -> String
showsPrec :: Int -> Memory -> ShowS
$cshowsPrec :: Int -> Memory -> ShowS
Show)

instance MonadIO m => StoreWrite (WriterT m) where
    setBest :: BlockHash -> WriterT m ()
setBest BlockHash
h =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                BlockHash -> Memory -> Memory
setBestH BlockHash
h
    insertBlock :: BlockData -> WriterT m ()
insertBlock BlockData
b =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                BlockData -> Memory -> Memory
insertBlockH BlockData
b
    setBlocksAtHeight :: [BlockHash] -> BlockHeight -> WriterT m ()
setBlocksAtHeight [BlockHash]
h BlockHeight
g =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                [BlockHash] -> BlockHeight -> Memory -> Memory
setBlocksAtHeightH [BlockHash]
h BlockHeight
g
    insertTx :: TxData -> WriterT m ()
insertTx TxData
t =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                TxData -> Memory -> Memory
insertTxH TxData
t
    insertSpender :: OutPoint -> Spender -> WriterT m ()
insertSpender OutPoint
p Spender
s' =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                OutPoint -> Spender -> Memory -> Memory
insertSpenderH OutPoint
p Spender
s'
    deleteSpender :: OutPoint -> WriterT m ()
deleteSpender OutPoint
p =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                OutPoint -> Memory -> Memory
deleteSpenderH OutPoint
p
    insertAddrTx :: Address -> TxRef -> WriterT m ()
insertAddrTx Address
a TxRef
t =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Address -> TxRef -> Memory -> Memory
insertAddrTxH Address
a TxRef
t
    deleteAddrTx :: Address -> TxRef -> WriterT m ()
deleteAddrTx Address
a TxRef
t =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Address -> TxRef -> Memory -> Memory
deleteAddrTxH Address
a TxRef
t
    insertAddrUnspent :: Address -> Unspent -> WriterT m ()
insertAddrUnspent Address
a Unspent
u =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Address -> Unspent -> Memory -> Memory
insertAddrUnspentH Address
a Unspent
u
    deleteAddrUnspent :: Address -> Unspent -> WriterT m ()
deleteAddrUnspent Address
a Unspent
u =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Address -> Unspent -> Memory -> Memory
deleteAddrUnspentH Address
a Unspent
u
    addToMempool :: TxHash -> UnixTime -> WriterT m ()
addToMempool TxHash
x UnixTime
t =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                TxHash -> UnixTime -> Memory -> Memory
addToMempoolH TxHash
x UnixTime
t
    deleteFromMempool :: TxHash -> WriterT m ()
deleteFromMempool TxHash
x =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                TxHash -> Memory -> Memory
deleteFromMempoolH TxHash
x
    setBalance :: Balance -> WriterT m ()
setBalance Balance
b =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Balance -> Memory -> Memory
setBalanceH Balance
b
    insertUnspent :: Unspent -> WriterT m ()
insertUnspent Unspent
h =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                Unspent -> Memory -> Memory
insertUnspentH Unspent
h
    deleteUnspent :: OutPoint -> WriterT m ()
deleteUnspent OutPoint
p =
        (Writer -> m ()) -> WriterT m ()
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m ()) -> WriterT m ())
-> (Writer -> m ()) -> WriterT m ()
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
s} ->
            IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> ((Memory -> Memory) -> IO ()) -> (Memory -> Memory) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. STM () -> IO ()
forall (m :: * -> *) a. MonadIO m => STM a -> m a
atomically (STM () -> IO ())
-> ((Memory -> Memory) -> STM ()) -> (Memory -> Memory) -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TVar Memory -> (Memory -> Memory) -> STM ()
forall a. TVar a -> (a -> a) -> STM ()
modifyTVar TVar Memory
s ((Memory -> Memory) -> m ()) -> (Memory -> Memory) -> m ()
forall a b. (a -> b) -> a -> b
$
                OutPoint -> Memory -> Memory
deleteUnspentH OutPoint
p

getLayered ::
    MonadIO m =>
    (Memory -> Maybe a) ->
    DatabaseReaderT m a ->
    WriterT m a
getLayered :: (Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered Memory -> Maybe a
f DatabaseReaderT m a
g =
    (Writer -> m a) -> WriterT m a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m a) -> WriterT m a) -> (Writer -> m a) -> WriterT m a
forall a b. (a -> b) -> a -> b
$ \Writer{getReader :: Writer -> DatabaseReader
getReader = DatabaseReader
db, getState :: Writer -> TVar Memory
getState = TVar Memory
tmem} ->
        Memory -> Maybe a
f (Memory -> Maybe a) -> m Memory -> m (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TVar Memory -> m Memory
forall (m :: * -> *) a. MonadIO m => TVar a -> m a
readTVarIO TVar Memory
tmem m (Maybe a) -> (Maybe a -> m a) -> m a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            Just a
x -> a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
            Maybe a
Nothing -> DatabaseReaderT m a -> DatabaseReader -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT DatabaseReaderT m a
g DatabaseReader
db

runWriter ::
    MonadIO m =>
    DatabaseReader ->
    WriterT m a ->
    m a
runWriter :: DatabaseReader -> WriterT m a -> m a
runWriter bdb :: DatabaseReader
bdb@DatabaseReader{databaseHandle :: DatabaseReader -> DB
databaseHandle = DB
db} WriterT m a
f = do
    [(UnixTime, TxHash)]
mem <- ReaderT DatabaseReader m [(UnixTime, TxHash)]
-> DatabaseReader -> m [(UnixTime, TxHash)]
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT DatabaseReader m [(UnixTime, TxHash)]
forall (m :: * -> *). StoreReadBase m => m [(UnixTime, TxHash)]
getMempool DatabaseReader
bdb
    TVar Memory
hm <- Memory -> m (TVar Memory)
forall (m :: * -> *) a. MonadIO m => a -> m (TVar a)
newTVarIO ([(UnixTime, TxHash)] -> Memory
newMemory [(UnixTime, TxHash)]
mem)
    a
x <- WriterT m a -> Writer -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
R.runReaderT WriterT m a
f Writer :: DatabaseReader -> TVar Memory -> Writer
Writer{getReader :: DatabaseReader
getReader = DatabaseReader
bdb, getState :: TVar Memory
getState = TVar Memory
hm}
    Memory
mem' <- TVar Memory -> m Memory
forall (m :: * -> *) a. MonadIO m => TVar a -> m a
readTVarIO TVar Memory
hm
    let ops :: [BatchOp]
ops = DB -> Memory -> [BatchOp]
hashMapOps DB
db Memory
mem'
    DB -> [BatchOp] -> m ()
forall (m :: * -> *). MonadIO m => DB -> [BatchOp] -> m ()
writeBatch DB
db [BatchOp]
ops
    a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x

hashMapOps :: DB -> Memory -> [BatchOp]
hashMapOps :: DB -> Memory -> [BatchOp]
hashMapOps DB
db Memory
mem =
    Maybe (Maybe BlockHash) -> [BatchOp]
bestBlockOp (Memory -> Maybe (Maybe BlockHash)
hBest Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap BlockHash (Maybe BlockData) -> [BatchOp]
blockHashOps DB
db (Memory -> HashMap BlockHash (Maybe BlockData)
hBlock Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap BlockHeight [BlockHash] -> [BatchOp]
blockHeightOps DB
db (Memory -> HashMap BlockHeight [BlockHash]
hHeight Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap TxHash (Maybe TxData) -> [BatchOp]
txOps DB
db (Memory -> HashMap TxHash (Maybe TxData)
hTx Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap OutPoint (Maybe Spender) -> [BatchOp]
spenderOps DB
db (Memory -> HashMap OutPoint (Maybe Spender)
hSpender Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap Address (Maybe Balance) -> [BatchOp]
balOps DB
db (Memory -> HashMap Address (Maybe Balance)
hBalance Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap (Address, TxRef) (Maybe ()) -> [BatchOp]
addrTxOps DB
db (Memory -> HashMap (Address, TxRef) (Maybe ())
hAddrTx Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> [BatchOp]
addrOutOps DB
db (Memory -> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> HashMap TxHash UnixTime -> [BatchOp]
mempoolOp (Memory -> HashMap TxHash UnixTime
hMempool Memory
mem)
        [BatchOp] -> [BatchOp] -> [BatchOp]
forall a. Semigroup a => a -> a -> a
<> DB -> HashMap OutPoint (Maybe Unspent) -> [BatchOp]
unspentOps DB
db (Memory -> HashMap OutPoint (Maybe Unspent)
hUnspent Memory
mem)

bestBlockOp :: Maybe (Maybe BlockHash) -> [BatchOp]
bestBlockOp :: Maybe (Maybe BlockHash) -> [BatchOp]
bestBlockOp Maybe (Maybe BlockHash)
Nothing = []
bestBlockOp (Just Maybe BlockHash
Nothing) = [BestKey -> BatchOp
forall key. (Key key, Serialize key) => key -> BatchOp
deleteOp BestKey
BestKey]
bestBlockOp (Just (Just BlockHash
b)) = [BestKey -> BlockHash -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
key -> value -> BatchOp
insertOp BestKey
BestKey BlockHash
b]

blockHashOps :: DB -> HashMap BlockHash (Maybe BlockData) -> [BatchOp]
blockHashOps :: DB -> HashMap BlockHash (Maybe BlockData) -> [BatchOp]
blockHashOps DB
db = ((BlockHash, Maybe BlockData) -> BatchOp)
-> [(BlockHash, Maybe BlockData)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((BlockHash -> Maybe BlockData -> BatchOp)
-> (BlockHash, Maybe BlockData) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry BlockHash -> Maybe BlockData -> BatchOp
forall value.
(KeyValue BlockKey value, Serialize value) =>
BlockHash -> Maybe value -> BatchOp
f) ([(BlockHash, Maybe BlockData)] -> [BatchOp])
-> (HashMap BlockHash (Maybe BlockData)
    -> [(BlockHash, Maybe BlockData)])
-> HashMap BlockHash (Maybe BlockData)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap BlockHash (Maybe BlockData)
-> [(BlockHash, Maybe BlockData)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: BlockHash -> Maybe value -> BatchOp
f BlockHash
k (Just value
d) = ColumnFamily -> BlockKey -> value -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
blockCF DB
db) (BlockHash -> BlockKey
BlockKey BlockHash
k) value
d
    f BlockHash
k Maybe value
Nothing = ColumnFamily -> BlockKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
blockCF DB
db) (BlockHash -> BlockKey
BlockKey BlockHash
k)

blockHeightOps :: DB -> HashMap BlockHeight [BlockHash] -> [BatchOp]
blockHeightOps :: DB -> HashMap BlockHeight [BlockHash] -> [BatchOp]
blockHeightOps DB
db = ((BlockHeight, [BlockHash]) -> BatchOp)
-> [(BlockHeight, [BlockHash])] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((BlockHeight -> [BlockHash] -> BatchOp)
-> (BlockHeight, [BlockHash]) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry BlockHeight -> [BlockHash] -> BatchOp
f) ([(BlockHeight, [BlockHash])] -> [BatchOp])
-> (HashMap BlockHeight [BlockHash]
    -> [(BlockHeight, [BlockHash])])
-> HashMap BlockHeight [BlockHash]
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap BlockHeight [BlockHash] -> [(BlockHeight, [BlockHash])]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: BlockHeight -> [BlockHash] -> BatchOp
f = ColumnFamily -> HeightKey -> [BlockHash] -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
heightCF DB
db) (HeightKey -> [BlockHash] -> BatchOp)
-> (BlockHeight -> HeightKey)
-> BlockHeight
-> [BlockHash]
-> BatchOp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BlockHeight -> HeightKey
HeightKey

txOps :: DB -> HashMap TxHash (Maybe TxData) -> [BatchOp]
txOps :: DB -> HashMap TxHash (Maybe TxData) -> [BatchOp]
txOps DB
db = ((TxHash, Maybe TxData) -> BatchOp)
-> [(TxHash, Maybe TxData)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((TxHash -> Maybe TxData -> BatchOp)
-> (TxHash, Maybe TxData) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry TxHash -> Maybe TxData -> BatchOp
forall value.
(KeyValue TxKey value, Serialize value) =>
TxHash -> Maybe value -> BatchOp
f) ([(TxHash, Maybe TxData)] -> [BatchOp])
-> (HashMap TxHash (Maybe TxData) -> [(TxHash, Maybe TxData)])
-> HashMap TxHash (Maybe TxData)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap TxHash (Maybe TxData) -> [(TxHash, Maybe TxData)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: TxHash -> Maybe value -> BatchOp
f TxHash
k (Just value
t) = ColumnFamily -> TxKey -> value -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
txCF DB
db) (TxHash -> TxKey
TxKey TxHash
k) value
t
    f TxHash
k Maybe value
Nothing = ColumnFamily -> TxKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
txCF DB
db) (TxHash -> TxKey
TxKey TxHash
k)

spenderOps :: DB -> HashMap OutPoint (Maybe Spender) -> [BatchOp]
spenderOps :: DB -> HashMap OutPoint (Maybe Spender) -> [BatchOp]
spenderOps DB
db = ((OutPoint, Maybe Spender) -> BatchOp)
-> [(OutPoint, Maybe Spender)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((OutPoint -> Maybe Spender -> BatchOp)
-> (OutPoint, Maybe Spender) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry OutPoint -> Maybe Spender -> BatchOp
forall value.
(KeyValue SpenderKey value, Serialize value) =>
OutPoint -> Maybe value -> BatchOp
f) ([(OutPoint, Maybe Spender)] -> [BatchOp])
-> (HashMap OutPoint (Maybe Spender)
    -> [(OutPoint, Maybe Spender)])
-> HashMap OutPoint (Maybe Spender)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap OutPoint (Maybe Spender) -> [(OutPoint, Maybe Spender)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: OutPoint -> Maybe value -> BatchOp
f OutPoint
o (Just value
s) = ColumnFamily -> SpenderKey -> value -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
spenderCF DB
db) (OutPoint -> SpenderKey
SpenderKey OutPoint
o) value
s
    f OutPoint
o Maybe value
Nothing = ColumnFamily -> SpenderKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
spenderCF DB
db) (OutPoint -> SpenderKey
SpenderKey OutPoint
o)

balOps :: DB -> HashMap Address (Maybe Balance) -> [BatchOp]
balOps :: DB -> HashMap Address (Maybe Balance) -> [BatchOp]
balOps DB
db = ((Address, Maybe Balance) -> BatchOp)
-> [(Address, Maybe Balance)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((Address -> Maybe Balance -> BatchOp)
-> (Address, Maybe Balance) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Address -> Maybe Balance -> BatchOp
f) ([(Address, Maybe Balance)] -> [BatchOp])
-> (HashMap Address (Maybe Balance) -> [(Address, Maybe Balance)])
-> HashMap Address (Maybe Balance)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Address (Maybe Balance) -> [(Address, Maybe Balance)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: Address -> Maybe Balance -> BatchOp
f Address
a (Just Balance
b) = ColumnFamily -> BalKey -> BalVal -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
balanceCF DB
db) (Address -> BalKey
BalKey Address
a) (Balance -> BalVal
balanceToVal Balance
b)
    f Address
a Maybe Balance
Nothing = ColumnFamily -> BalKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
balanceCF DB
db) (Address -> BalKey
BalKey Address
a)

addrTxOps :: DB -> HashMap (Address, TxRef) (Maybe ()) -> [BatchOp]
addrTxOps :: DB -> HashMap (Address, TxRef) (Maybe ()) -> [BatchOp]
addrTxOps DB
db = (((Address, TxRef), Maybe ()) -> BatchOp)
-> [((Address, TxRef), Maybe ())] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map (((Address, TxRef) -> Maybe () -> BatchOp)
-> ((Address, TxRef), Maybe ()) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (Address, TxRef) -> Maybe () -> BatchOp
f) ([((Address, TxRef), Maybe ())] -> [BatchOp])
-> (HashMap (Address, TxRef) (Maybe ())
    -> [((Address, TxRef), Maybe ())])
-> HashMap (Address, TxRef) (Maybe ())
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap (Address, TxRef) (Maybe ())
-> [((Address, TxRef), Maybe ())]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: (Address, TxRef) -> Maybe () -> BatchOp
f (Address
a, TxRef
t) (Just ()) = ColumnFamily -> AddrTxKey -> () -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
addrTxCF DB
db) (Address -> TxRef -> AddrTxKey
AddrTxKey Address
a TxRef
t) ()
    f (Address
a, TxRef
t) Maybe ()
Nothing = ColumnFamily -> AddrTxKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
addrTxCF DB
db) (Address -> TxRef -> AddrTxKey
AddrTxKey Address
a TxRef
t)

addrOutOps ::
    DB ->
    HashMap (Address, BlockRef, OutPoint) (Maybe OutVal) ->
    [BatchOp]
addrOutOps :: DB
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> [BatchOp]
addrOutOps DB
db = (((Address, BlockRef, OutPoint), Maybe OutVal) -> BatchOp)
-> [((Address, BlockRef, OutPoint), Maybe OutVal)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map (((Address, BlockRef, OutPoint) -> Maybe OutVal -> BatchOp)
-> ((Address, BlockRef, OutPoint), Maybe OutVal) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (Address, BlockRef, OutPoint) -> Maybe OutVal -> BatchOp
forall value.
(KeyValue AddrOutKey value, Serialize value) =>
(Address, BlockRef, OutPoint) -> Maybe value -> BatchOp
f) ([((Address, BlockRef, OutPoint), Maybe OutVal)] -> [BatchOp])
-> (HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
    -> [((Address, BlockRef, OutPoint), Maybe OutVal)])
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> [((Address, BlockRef, OutPoint), Maybe OutVal)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: (Address, BlockRef, OutPoint) -> Maybe value -> BatchOp
f (Address
a, BlockRef
b, OutPoint
p) (Just value
l) =
        ColumnFamily -> AddrOutKey -> value -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF
            (DB -> ColumnFamily
addrOutCF DB
db)
            ( AddrOutKey :: Address -> BlockRef -> OutPoint -> AddrOutKey
AddrOutKey
                { addrOutKeyA :: Address
addrOutKeyA = Address
a
                , addrOutKeyB :: BlockRef
addrOutKeyB = BlockRef
b
                , addrOutKeyP :: OutPoint
addrOutKeyP = OutPoint
p
                }
            )
            value
l
    f (Address
a, BlockRef
b, OutPoint
p) Maybe value
Nothing =
        ColumnFamily -> AddrOutKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF
            (DB -> ColumnFamily
addrOutCF DB
db)
            AddrOutKey :: Address -> BlockRef -> OutPoint -> AddrOutKey
AddrOutKey
                { addrOutKeyA :: Address
addrOutKeyA = Address
a
                , addrOutKeyB :: BlockRef
addrOutKeyB = BlockRef
b
                , addrOutKeyP :: OutPoint
addrOutKeyP = OutPoint
p
                }

mempoolOp :: HashMap TxHash UnixTime -> [BatchOp]
mempoolOp :: HashMap TxHash UnixTime -> [BatchOp]
mempoolOp = BatchOp -> [BatchOp]
forall (m :: * -> *) a. Monad m => a -> m a
return (BatchOp -> [BatchOp])
-> (HashMap TxHash UnixTime -> BatchOp)
-> HashMap TxHash UnixTime
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MemKey -> [(UnixTime, TxHash)] -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
key -> value -> BatchOp
insertOp MemKey
MemKey ([(UnixTime, TxHash)] -> BatchOp)
-> (HashMap TxHash UnixTime -> [(UnixTime, TxHash)])
-> HashMap TxHash UnixTime
-> BatchOp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((UnixTime, TxHash) -> Down (UnixTime, TxHash))
-> [(UnixTime, TxHash)] -> [(UnixTime, TxHash)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (UnixTime, TxHash) -> Down (UnixTime, TxHash)
forall a. a -> Down a
Down ([(UnixTime, TxHash)] -> [(UnixTime, TxHash)])
-> (HashMap TxHash UnixTime -> [(UnixTime, TxHash)])
-> HashMap TxHash UnixTime
-> [(UnixTime, TxHash)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxHash, UnixTime) -> (UnixTime, TxHash))
-> [(TxHash, UnixTime)] -> [(UnixTime, TxHash)]
forall a b. (a -> b) -> [a] -> [b]
map (TxHash, UnixTime) -> (UnixTime, TxHash)
forall a b. (a, b) -> (b, a)
swap ([(TxHash, UnixTime)] -> [(UnixTime, TxHash)])
-> (HashMap TxHash UnixTime -> [(TxHash, UnixTime)])
-> HashMap TxHash UnixTime
-> [(UnixTime, TxHash)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap TxHash UnixTime -> [(TxHash, UnixTime)]
forall k v. HashMap k v -> [(k, v)]
M.toList

unspentOps :: DB -> HashMap OutPoint (Maybe Unspent) -> [BatchOp]
unspentOps :: DB -> HashMap OutPoint (Maybe Unspent) -> [BatchOp]
unspentOps DB
db = ((OutPoint, Maybe Unspent) -> BatchOp)
-> [(OutPoint, Maybe Unspent)] -> [BatchOp]
forall a b. (a -> b) -> [a] -> [b]
map ((OutPoint -> Maybe Unspent -> BatchOp)
-> (OutPoint, Maybe Unspent) -> BatchOp
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry OutPoint -> Maybe Unspent -> BatchOp
f) ([(OutPoint, Maybe Unspent)] -> [BatchOp])
-> (HashMap OutPoint (Maybe Unspent)
    -> [(OutPoint, Maybe Unspent)])
-> HashMap OutPoint (Maybe Unspent)
-> [BatchOp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap OutPoint (Maybe Unspent) -> [(OutPoint, Maybe Unspent)]
forall k v. HashMap k v -> [(k, v)]
M.toList
  where
    f :: OutPoint -> Maybe Unspent -> BatchOp
f OutPoint
p (Just Unspent
u) =
        ColumnFamily -> UnspentKey -> UnspentVal -> BatchOp
forall key value.
(KeyValue key value, Serialize key, Serialize value) =>
ColumnFamily -> key -> value -> BatchOp
insertOpCF (DB -> ColumnFamily
unspentCF DB
db) (OutPoint -> UnspentKey
UnspentKey OutPoint
p) ((OutPoint, UnspentVal) -> UnspentVal
forall a b. (a, b) -> b
snd (Unspent -> (OutPoint, UnspentVal)
unspentToVal Unspent
u))
    f OutPoint
p Maybe Unspent
Nothing =
        ColumnFamily -> UnspentKey -> BatchOp
forall key.
(Key key, Serialize key) =>
ColumnFamily -> key -> BatchOp
deleteOpCF (DB -> ColumnFamily
unspentCF DB
db) (OutPoint -> UnspentKey
UnspentKey OutPoint
p)

getNetworkI :: MonadIO m => WriterT m Network
getNetworkI :: WriterT m Network
getNetworkI = (Memory -> Maybe Network)
-> DatabaseReaderT m Network -> WriterT m Network
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered Memory -> Maybe Network
hNet DatabaseReaderT m Network
forall (m :: * -> *). StoreReadBase m => m Network
getNetwork

getBestBlockI :: MonadIO m => WriterT m (Maybe BlockHash)
getBestBlockI :: WriterT m (Maybe BlockHash)
getBestBlockI = (Memory -> Maybe (Maybe BlockHash))
-> DatabaseReaderT m (Maybe BlockHash)
-> WriterT m (Maybe BlockHash)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered Memory -> Maybe (Maybe BlockHash)
getBestBlockH DatabaseReaderT m (Maybe BlockHash)
forall (m :: * -> *). StoreReadBase m => m (Maybe BlockHash)
getBestBlock

getBlocksAtHeightI :: MonadIO m => BlockHeight -> WriterT m [BlockHash]
getBlocksAtHeightI :: BlockHeight -> WriterT m [BlockHash]
getBlocksAtHeightI BlockHeight
bh =
    (Memory -> Maybe [BlockHash])
-> DatabaseReaderT m [BlockHash] -> WriterT m [BlockHash]
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (BlockHeight -> Memory -> Maybe [BlockHash]
getBlocksAtHeightH BlockHeight
bh) (BlockHeight -> DatabaseReaderT m [BlockHash]
forall (m :: * -> *).
StoreReadBase m =>
BlockHeight -> m [BlockHash]
getBlocksAtHeight BlockHeight
bh)

getBlockI :: MonadIO m => BlockHash -> WriterT m (Maybe BlockData)
getBlockI :: BlockHash -> WriterT m (Maybe BlockData)
getBlockI BlockHash
bh = (Memory -> Maybe (Maybe BlockData))
-> DatabaseReaderT m (Maybe BlockData)
-> WriterT m (Maybe BlockData)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (BlockHash -> Memory -> Maybe (Maybe BlockData)
getBlockH BlockHash
bh) (BlockHash -> DatabaseReaderT m (Maybe BlockData)
forall (m :: * -> *).
StoreReadBase m =>
BlockHash -> m (Maybe BlockData)
getBlock BlockHash
bh)

getTxDataI :: MonadIO m => TxHash -> WriterT m (Maybe TxData)
getTxDataI :: TxHash -> WriterT m (Maybe TxData)
getTxDataI TxHash
th = (Memory -> Maybe (Maybe TxData))
-> DatabaseReaderT m (Maybe TxData) -> WriterT m (Maybe TxData)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (TxHash -> Memory -> Maybe (Maybe TxData)
getTxDataH TxHash
th) (TxHash -> DatabaseReaderT m (Maybe TxData)
forall (m :: * -> *). StoreReadBase m => TxHash -> m (Maybe TxData)
getTxData TxHash
th)

getSpenderI :: MonadIO m => OutPoint -> WriterT m (Maybe Spender)
getSpenderI :: OutPoint -> WriterT m (Maybe Spender)
getSpenderI OutPoint
op = (Memory -> Maybe (Maybe Spender))
-> DatabaseReaderT m (Maybe Spender) -> WriterT m (Maybe Spender)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (OutPoint -> Memory -> Maybe (Maybe Spender)
getSpenderH OutPoint
op) (OutPoint -> DatabaseReaderT m (Maybe Spender)
forall (m :: * -> *).
StoreReadBase m =>
OutPoint -> m (Maybe Spender)
getSpender OutPoint
op)

getBalanceI :: MonadIO m => Address -> WriterT m (Maybe Balance)
getBalanceI :: Address -> WriterT m (Maybe Balance)
getBalanceI Address
a = (Memory -> Maybe (Maybe Balance))
-> DatabaseReaderT m (Maybe Balance) -> WriterT m (Maybe Balance)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (Address -> Memory -> Maybe (Maybe Balance)
getBalanceH Address
a) (Address -> DatabaseReaderT m (Maybe Balance)
forall (m :: * -> *).
StoreReadBase m =>
Address -> m (Maybe Balance)
getBalance Address
a)

getUnspentI :: MonadIO m => OutPoint -> WriterT m (Maybe Unspent)
getUnspentI :: OutPoint -> WriterT m (Maybe Unspent)
getUnspentI OutPoint
op = (Memory -> Maybe (Maybe Unspent))
-> DatabaseReaderT m (Maybe Unspent) -> WriterT m (Maybe Unspent)
forall (m :: * -> *) a.
MonadIO m =>
(Memory -> Maybe a) -> DatabaseReaderT m a -> WriterT m a
getLayered (OutPoint -> Memory -> Maybe (Maybe Unspent)
getUnspentH OutPoint
op) (OutPoint -> DatabaseReaderT m (Maybe Unspent)
forall (m :: * -> *).
StoreReadBase m =>
OutPoint -> m (Maybe Unspent)
getUnspent OutPoint
op)

getMempoolI :: MonadIO m => WriterT m [(UnixTime, TxHash)]
getMempoolI :: WriterT m [(UnixTime, TxHash)]
getMempoolI =
    (Writer -> m [(UnixTime, TxHash)])
-> WriterT m [(UnixTime, TxHash)]
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((Writer -> m [(UnixTime, TxHash)])
 -> WriterT m [(UnixTime, TxHash)])
-> (Writer -> m [(UnixTime, TxHash)])
-> WriterT m [(UnixTime, TxHash)]
forall a b. (a -> b) -> a -> b
$ \Writer{getState :: Writer -> TVar Memory
getState = TVar Memory
tmem} ->
        Memory -> [(UnixTime, TxHash)]
getMempoolH (Memory -> [(UnixTime, TxHash)])
-> m Memory -> m [(UnixTime, TxHash)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TVar Memory -> m Memory
forall (m :: * -> *) a. MonadIO m => TVar a -> m a
readTVarIO TVar Memory
tmem

newMemory :: [(UnixTime, TxHash)] -> Memory
newMemory :: [(UnixTime, TxHash)] -> Memory
newMemory [(UnixTime, TxHash)]
mem =
    Memory :: Maybe Network
-> Maybe (Maybe BlockHash)
-> HashMap BlockHash (Maybe BlockData)
-> HashMap BlockHeight [BlockHash]
-> HashMap TxHash (Maybe TxData)
-> HashMap OutPoint (Maybe Spender)
-> HashMap OutPoint (Maybe Unspent)
-> HashMap Address (Maybe Balance)
-> HashMap (Address, TxRef) (Maybe ())
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> HashMap TxHash UnixTime
-> Memory
Memory
        { hNet :: Maybe Network
hNet = Maybe Network
forall a. Maybe a
Nothing
        , hBest :: Maybe (Maybe BlockHash)
hBest = Maybe (Maybe BlockHash)
forall a. Maybe a
Nothing
        , hBlock :: HashMap BlockHash (Maybe BlockData)
hBlock = HashMap BlockHash (Maybe BlockData)
forall k v. HashMap k v
M.empty
        , hHeight :: HashMap BlockHeight [BlockHash]
hHeight = HashMap BlockHeight [BlockHash]
forall k v. HashMap k v
M.empty
        , hTx :: HashMap TxHash (Maybe TxData)
hTx = HashMap TxHash (Maybe TxData)
forall k v. HashMap k v
M.empty
        , hSpender :: HashMap OutPoint (Maybe Spender)
hSpender = HashMap OutPoint (Maybe Spender)
forall k v. HashMap k v
M.empty
        , hUnspent :: HashMap OutPoint (Maybe Unspent)
hUnspent = HashMap OutPoint (Maybe Unspent)
forall k v. HashMap k v
M.empty
        , hBalance :: HashMap Address (Maybe Balance)
hBalance = HashMap Address (Maybe Balance)
forall k v. HashMap k v
M.empty
        , hAddrTx :: HashMap (Address, TxRef) (Maybe ())
hAddrTx = HashMap (Address, TxRef) (Maybe ())
forall k v. HashMap k v
M.empty
        , hAddrOut :: HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut = HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
forall k v. HashMap k v
M.empty
        , hMempool :: HashMap TxHash UnixTime
hMempool = [(TxHash, UnixTime)] -> HashMap TxHash UnixTime
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList (((UnixTime, TxHash) -> (TxHash, UnixTime))
-> [(UnixTime, TxHash)] -> [(TxHash, UnixTime)]
forall a b. (a -> b) -> [a] -> [b]
map (UnixTime, TxHash) -> (TxHash, UnixTime)
forall a b. (a, b) -> (b, a)
swap [(UnixTime, TxHash)]
mem)
        }

getBestBlockH :: Memory -> Maybe (Maybe BlockHash)
getBestBlockH :: Memory -> Maybe (Maybe BlockHash)
getBestBlockH = Memory -> Maybe (Maybe BlockHash)
hBest

getBlocksAtHeightH :: BlockHeight -> Memory -> Maybe [BlockHash]
getBlocksAtHeightH :: BlockHeight -> Memory -> Maybe [BlockHash]
getBlocksAtHeightH BlockHeight
h = BlockHeight -> HashMap BlockHeight [BlockHash] -> Maybe [BlockHash]
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup BlockHeight
h (HashMap BlockHeight [BlockHash] -> Maybe [BlockHash])
-> (Memory -> HashMap BlockHeight [BlockHash])
-> Memory
-> Maybe [BlockHash]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Memory -> HashMap BlockHeight [BlockHash]
hHeight

getBlockH :: BlockHash -> Memory -> Maybe (Maybe BlockData)
getBlockH :: BlockHash -> Memory -> Maybe (Maybe BlockData)
getBlockH BlockHash
h = BlockHash
-> HashMap BlockHash (Maybe BlockData) -> Maybe (Maybe BlockData)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup BlockHash
h (HashMap BlockHash (Maybe BlockData) -> Maybe (Maybe BlockData))
-> (Memory -> HashMap BlockHash (Maybe BlockData))
-> Memory
-> Maybe (Maybe BlockData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Memory -> HashMap BlockHash (Maybe BlockData)
hBlock

getTxDataH :: TxHash -> Memory -> Maybe (Maybe TxData)
getTxDataH :: TxHash -> Memory -> Maybe (Maybe TxData)
getTxDataH TxHash
t = TxHash -> HashMap TxHash (Maybe TxData) -> Maybe (Maybe TxData)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup TxHash
t (HashMap TxHash (Maybe TxData) -> Maybe (Maybe TxData))
-> (Memory -> HashMap TxHash (Maybe TxData))
-> Memory
-> Maybe (Maybe TxData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Memory -> HashMap TxHash (Maybe TxData)
hTx

getSpenderH :: OutPoint -> Memory -> Maybe (Maybe Spender)
getSpenderH :: OutPoint -> Memory -> Maybe (Maybe Spender)
getSpenderH OutPoint
op Memory
db = OutPoint
-> HashMap OutPoint (Maybe Spender) -> Maybe (Maybe Spender)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup OutPoint
op (Memory -> HashMap OutPoint (Maybe Spender)
hSpender Memory
db)

getBalanceH :: Address -> Memory -> Maybe (Maybe Balance)
getBalanceH :: Address -> Memory -> Maybe (Maybe Balance)
getBalanceH Address
a = Address -> HashMap Address (Maybe Balance) -> Maybe (Maybe Balance)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup Address
a (HashMap Address (Maybe Balance) -> Maybe (Maybe Balance))
-> (Memory -> HashMap Address (Maybe Balance))
-> Memory
-> Maybe (Maybe Balance)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Memory -> HashMap Address (Maybe Balance)
hBalance

getMempoolH :: Memory -> [(UnixTime, TxHash)]
getMempoolH :: Memory -> [(UnixTime, TxHash)]
getMempoolH = ((UnixTime, TxHash) -> Down (UnixTime, TxHash))
-> [(UnixTime, TxHash)] -> [(UnixTime, TxHash)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (UnixTime, TxHash) -> Down (UnixTime, TxHash)
forall a. a -> Down a
Down ([(UnixTime, TxHash)] -> [(UnixTime, TxHash)])
-> (Memory -> [(UnixTime, TxHash)])
-> Memory
-> [(UnixTime, TxHash)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TxHash, UnixTime) -> (UnixTime, TxHash))
-> [(TxHash, UnixTime)] -> [(UnixTime, TxHash)]
forall a b. (a -> b) -> [a] -> [b]
map (TxHash, UnixTime) -> (UnixTime, TxHash)
forall a b. (a, b) -> (b, a)
swap ([(TxHash, UnixTime)] -> [(UnixTime, TxHash)])
-> (Memory -> [(TxHash, UnixTime)])
-> Memory
-> [(UnixTime, TxHash)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap TxHash UnixTime -> [(TxHash, UnixTime)]
forall k v. HashMap k v -> [(k, v)]
M.toList (HashMap TxHash UnixTime -> [(TxHash, UnixTime)])
-> (Memory -> HashMap TxHash UnixTime)
-> Memory
-> [(TxHash, UnixTime)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Memory -> HashMap TxHash UnixTime
hMempool

setBestH :: BlockHash -> Memory -> Memory
setBestH :: BlockHash -> Memory -> Memory
setBestH BlockHash
h Memory
db = Memory
db{hBest :: Maybe (Maybe BlockHash)
hBest = Maybe BlockHash -> Maybe (Maybe BlockHash)
forall a. a -> Maybe a
Just (BlockHash -> Maybe BlockHash
forall a. a -> Maybe a
Just BlockHash
h)}

insertBlockH :: BlockData -> Memory -> Memory
insertBlockH :: BlockData -> Memory -> Memory
insertBlockH BlockData
bd Memory
db =
    Memory
db
        { hBlock :: HashMap BlockHash (Maybe BlockData)
hBlock =
            BlockHash
-> Maybe BlockData
-> HashMap BlockHash (Maybe BlockData)
-> HashMap BlockHash (Maybe BlockData)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert
                (BlockHeader -> BlockHash
headerHash (BlockData -> BlockHeader
blockDataHeader BlockData
bd))
                (BlockData -> Maybe BlockData
forall a. a -> Maybe a
Just BlockData
bd)
                (Memory -> HashMap BlockHash (Maybe BlockData)
hBlock Memory
db)
        }

setBlocksAtHeightH :: [BlockHash] -> BlockHeight -> Memory -> Memory
setBlocksAtHeightH :: [BlockHash] -> BlockHeight -> Memory -> Memory
setBlocksAtHeightH [BlockHash]
hs BlockHeight
g Memory
db =
    Memory
db{hHeight :: HashMap BlockHeight [BlockHash]
hHeight = BlockHeight
-> [BlockHash]
-> HashMap BlockHeight [BlockHash]
-> HashMap BlockHeight [BlockHash]
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert BlockHeight
g [BlockHash]
hs (Memory -> HashMap BlockHeight [BlockHash]
hHeight Memory
db)}

insertTxH :: TxData -> Memory -> Memory
insertTxH :: TxData -> Memory -> Memory
insertTxH TxData
tx Memory
db =
    Memory
db{hTx :: HashMap TxHash (Maybe TxData)
hTx = TxHash
-> Maybe TxData
-> HashMap TxHash (Maybe TxData)
-> HashMap TxHash (Maybe TxData)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Tx -> TxHash
txHash (TxData -> Tx
txData TxData
tx)) (TxData -> Maybe TxData
forall a. a -> Maybe a
Just TxData
tx) (Memory -> HashMap TxHash (Maybe TxData)
hTx Memory
db)}

insertSpenderH :: OutPoint -> Spender -> Memory -> Memory
insertSpenderH :: OutPoint -> Spender -> Memory -> Memory
insertSpenderH OutPoint
op Spender
s Memory
db =
    Memory
db{hSpender :: HashMap OutPoint (Maybe Spender)
hSpender = OutPoint
-> Maybe Spender
-> HashMap OutPoint (Maybe Spender)
-> HashMap OutPoint (Maybe Spender)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert OutPoint
op (Spender -> Maybe Spender
forall a. a -> Maybe a
Just Spender
s) (Memory -> HashMap OutPoint (Maybe Spender)
hSpender Memory
db)}

deleteSpenderH :: OutPoint -> Memory -> Memory
deleteSpenderH :: OutPoint -> Memory -> Memory
deleteSpenderH OutPoint
op Memory
db =
    Memory
db{hSpender :: HashMap OutPoint (Maybe Spender)
hSpender = OutPoint
-> Maybe Spender
-> HashMap OutPoint (Maybe Spender)
-> HashMap OutPoint (Maybe Spender)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert OutPoint
op Maybe Spender
forall a. Maybe a
Nothing (Memory -> HashMap OutPoint (Maybe Spender)
hSpender Memory
db)}

setBalanceH :: Balance -> Memory -> Memory
setBalanceH :: Balance -> Memory -> Memory
setBalanceH Balance
bal Memory
db =
    Memory
db{hBalance :: HashMap Address (Maybe Balance)
hBalance = Address
-> Maybe Balance
-> HashMap Address (Maybe Balance)
-> HashMap Address (Maybe Balance)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Balance -> Address
balanceAddress Balance
bal) (Balance -> Maybe Balance
forall a. a -> Maybe a
Just Balance
bal) (Memory -> HashMap Address (Maybe Balance)
hBalance Memory
db)}

insertAddrTxH :: Address -> TxRef -> Memory -> Memory
insertAddrTxH :: Address -> TxRef -> Memory -> Memory
insertAddrTxH Address
a TxRef
tr Memory
db =
    Memory
db{hAddrTx :: HashMap (Address, TxRef) (Maybe ())
hAddrTx = (Address, TxRef)
-> Maybe ()
-> HashMap (Address, TxRef) (Maybe ())
-> HashMap (Address, TxRef) (Maybe ())
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Address
a, TxRef
tr) (() -> Maybe ()
forall a. a -> Maybe a
Just ()) (Memory -> HashMap (Address, TxRef) (Maybe ())
hAddrTx Memory
db)}

deleteAddrTxH :: Address -> TxRef -> Memory -> Memory
deleteAddrTxH :: Address -> TxRef -> Memory -> Memory
deleteAddrTxH Address
a TxRef
tr Memory
db =
    Memory
db{hAddrTx :: HashMap (Address, TxRef) (Maybe ())
hAddrTx = (Address, TxRef)
-> Maybe ()
-> HashMap (Address, TxRef) (Maybe ())
-> HashMap (Address, TxRef) (Maybe ())
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Address
a, TxRef
tr) Maybe ()
forall a. Maybe a
Nothing (Memory -> HashMap (Address, TxRef) (Maybe ())
hAddrTx Memory
db)}

insertAddrUnspentH :: Address -> Unspent -> Memory -> Memory
insertAddrUnspentH :: Address -> Unspent -> Memory -> Memory
insertAddrUnspentH Address
a Unspent
u Memory
db =
    let k :: (Address, BlockRef, OutPoint)
k = (Address
a, Unspent -> BlockRef
unspentBlock Unspent
u, Unspent -> OutPoint
unspentPoint Unspent
u)
        v :: OutVal
v =
            OutVal :: UnixTime -> ByteString -> OutVal
OutVal
                { outValAmount :: UnixTime
outValAmount = Unspent -> UnixTime
unspentAmount Unspent
u
                , outValScript :: ByteString
outValScript = Unspent -> ByteString
unspentScript Unspent
u
                }
     in Memory
db{hAddrOut :: HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut = (Address, BlockRef, OutPoint)
-> Maybe OutVal
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Address, BlockRef, OutPoint)
k (OutVal -> Maybe OutVal
forall a. a -> Maybe a
Just OutVal
v) (Memory -> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut Memory
db)}

deleteAddrUnspentH :: Address -> Unspent -> Memory -> Memory
deleteAddrUnspentH :: Address -> Unspent -> Memory -> Memory
deleteAddrUnspentH Address
a Unspent
u Memory
db =
    let k :: (Address, BlockRef, OutPoint)
k = (Address
a, Unspent -> BlockRef
unspentBlock Unspent
u, Unspent -> OutPoint
unspentPoint Unspent
u)
     in Memory
db{hAddrOut :: HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut = (Address, BlockRef, OutPoint)
-> Maybe OutVal
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
-> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert (Address, BlockRef, OutPoint)
k Maybe OutVal
forall a. Maybe a
Nothing (Memory -> HashMap (Address, BlockRef, OutPoint) (Maybe OutVal)
hAddrOut Memory
db)}

addToMempoolH :: TxHash -> UnixTime -> Memory -> Memory
addToMempoolH :: TxHash -> UnixTime -> Memory -> Memory
addToMempoolH TxHash
h UnixTime
t Memory
db =
    Memory
db{hMempool :: HashMap TxHash UnixTime
hMempool = TxHash
-> UnixTime -> HashMap TxHash UnixTime -> HashMap TxHash UnixTime
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert TxHash
h UnixTime
t (Memory -> HashMap TxHash UnixTime
hMempool Memory
db)}

deleteFromMempoolH :: TxHash -> Memory -> Memory
deleteFromMempoolH :: TxHash -> Memory -> Memory
deleteFromMempoolH TxHash
h Memory
db =
    Memory
db{hMempool :: HashMap TxHash UnixTime
hMempool = TxHash -> HashMap TxHash UnixTime -> HashMap TxHash UnixTime
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> HashMap k v
M.delete TxHash
h (Memory -> HashMap TxHash UnixTime
hMempool Memory
db)}

getUnspentH :: OutPoint -> Memory -> Maybe (Maybe Unspent)
getUnspentH :: OutPoint -> Memory -> Maybe (Maybe Unspent)
getUnspentH OutPoint
op Memory
db = OutPoint
-> HashMap OutPoint (Maybe Unspent) -> Maybe (Maybe Unspent)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
M.lookup OutPoint
op (Memory -> HashMap OutPoint (Maybe Unspent)
hUnspent Memory
db)

insertUnspentH :: Unspent -> Memory -> Memory
insertUnspentH :: Unspent -> Memory -> Memory
insertUnspentH Unspent
u Memory
db =
    let k :: OutPoint
k = (OutPoint, UnspentVal) -> OutPoint
forall a b. (a, b) -> a
fst (Unspent -> (OutPoint, UnspentVal)
unspentToVal Unspent
u)
     in Memory
db{hUnspent :: HashMap OutPoint (Maybe Unspent)
hUnspent = OutPoint
-> Maybe Unspent
-> HashMap OutPoint (Maybe Unspent)
-> HashMap OutPoint (Maybe Unspent)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert OutPoint
k (Unspent -> Maybe Unspent
forall a. a -> Maybe a
Just Unspent
u) (Memory -> HashMap OutPoint (Maybe Unspent)
hUnspent Memory
db)}

deleteUnspentH :: OutPoint -> Memory -> Memory
deleteUnspentH :: OutPoint -> Memory -> Memory
deleteUnspentH OutPoint
op Memory
db =
    Memory
db{hUnspent :: HashMap OutPoint (Maybe Unspent)
hUnspent = OutPoint
-> Maybe Unspent
-> HashMap OutPoint (Maybe Unspent)
-> HashMap OutPoint (Maybe Unspent)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
M.insert OutPoint
op Maybe Unspent
forall a. Maybe a
Nothing (Memory -> HashMap OutPoint (Maybe Unspent)
hUnspent Memory
db)}