{-# Language PartialTypeSignatures #-}
{-# Language DataKinds #-}
{-# Language ExtendedDefaultRules #-}
{-# Language PatternSynonyms #-}
module EVM.Facts
( File (..)
, Fact (..)
, Data (..)
, Path (..)
, apply
, applyCache
, cacheFacts
, contractFacts
, vmFacts
, factToFile
, fileToFact
) where
import EVM (VM, Contract, Cache)
import EVM (balance, nonce, storage, bytecode, env, contracts, cache, fetchedStorage, fetchedContracts)
import EVM.Types (Addr, W256, Expr(..), num)
import EVM.Expr (writeStorage, litAddr)
import qualified EVM
import Prelude hiding (Word)
import Control.Lens (view, set, at, ix, (&), over, assign)
import Control.Monad.State.Strict (execState, when)
import Data.ByteString (ByteString)
import Data.Ord (comparing)
import Data.Set (Set)
import Data.Map (Map)
import Text.Read (readMaybe)
import qualified Data.ByteString.Base16 as BS16
import qualified Data.ByteString as BS
import qualified Data.ByteString.Char8 as Char8
import qualified Data.Map as Map
import qualified Data.Set as Set
type ASCII = ByteString
default (ASCII)
data Fact
= BalanceFact { Fact -> Addr
addr :: Addr, Fact -> W256
what :: W256 }
| NonceFact { addr :: Addr, what :: W256 }
| StorageFact { addr :: Addr, what :: W256, Fact -> W256
which :: W256 }
| CodeFact { addr :: Addr, Fact -> ASCII
blob :: ByteString }
deriving (Fact -> Fact -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fact -> Fact -> Bool
$c/= :: Fact -> Fact -> Bool
== :: Fact -> Fact -> Bool
$c== :: Fact -> Fact -> Bool
Eq, Int -> Fact -> ShowS
[Fact] -> ShowS
Fact -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fact] -> ShowS
$cshowList :: [Fact] -> ShowS
show :: Fact -> String
$cshow :: Fact -> String
showsPrec :: Int -> Fact -> ShowS
$cshowsPrec :: Int -> Fact -> ShowS
Show)
data Path = Path [ASCII] ASCII
deriving (Path -> Path -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Path -> Path -> Bool
$c/= :: Path -> Path -> Bool
== :: Path -> Path -> Bool
$c== :: Path -> Path -> Bool
Eq, Eq Path
Path -> Path -> Bool
Path -> Path -> Ordering
Path -> Path -> Path
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Path -> Path -> Path
$cmin :: Path -> Path -> Path
max :: Path -> Path -> Path
$cmax :: Path -> Path -> Path
>= :: Path -> Path -> Bool
$c>= :: Path -> Path -> Bool
> :: Path -> Path -> Bool
$c> :: Path -> Path -> Bool
<= :: Path -> Path -> Bool
$c<= :: Path -> Path -> Bool
< :: Path -> Path -> Bool
$c< :: Path -> Path -> Bool
compare :: Path -> Path -> Ordering
$ccompare :: Path -> Path -> Ordering
Ord, Int -> Path -> ShowS
[Path] -> ShowS
Path -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Path] -> ShowS
$cshowList :: [Path] -> ShowS
show :: Path -> String
$cshow :: Path -> String
showsPrec :: Int -> Path -> ShowS
$cshowsPrec :: Int -> Path -> ShowS
Show)
newtype Data = Data { Data -> ASCII
dataASCII :: ASCII }
deriving (Data -> Data -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Data -> Data -> Bool
$c/= :: Data -> Data -> Bool
== :: Data -> Data -> Bool
$c== :: Data -> Data -> Bool
Eq, Eq Data
Data -> Data -> Bool
Data -> Data -> Ordering
Data -> Data -> Data
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Data -> Data -> Data
$cmin :: Data -> Data -> Data
max :: Data -> Data -> Data
$cmax :: Data -> Data -> Data
>= :: Data -> Data -> Bool
$c>= :: Data -> Data -> Bool
> :: Data -> Data -> Bool
$c> :: Data -> Data -> Bool
<= :: Data -> Data -> Bool
$c<= :: Data -> Data -> Bool
< :: Data -> Data -> Bool
$c< :: Data -> Data -> Bool
compare :: Data -> Data -> Ordering
$ccompare :: Data -> Data -> Ordering
Ord, Int -> Data -> ShowS
[Data] -> ShowS
Data -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Data] -> ShowS
$cshowList :: [Data] -> ShowS
show :: Data -> String
$cshow :: Data -> String
showsPrec :: Int -> Data -> ShowS
$cshowsPrec :: Int -> Data -> ShowS
Show)
data File = File { File -> Path
filePath :: Path, File -> Data
fileData :: Data }
deriving (File -> File -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: File -> File -> Bool
$c/= :: File -> File -> Bool
== :: File -> File -> Bool
$c== :: File -> File -> Bool
Eq, Eq File
File -> File -> Bool
File -> File -> Ordering
File -> File -> File
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: File -> File -> File
$cmin :: File -> File -> File
max :: File -> File -> File
$cmax :: File -> File -> File
>= :: File -> File -> Bool
$c>= :: File -> File -> Bool
> :: File -> File -> Bool
$c> :: File -> File -> Bool
<= :: File -> File -> Bool
$c<= :: File -> File -> Bool
< :: File -> File -> Bool
$c< :: File -> File -> Bool
compare :: File -> File -> Ordering
$ccompare :: File -> File -> Ordering
Ord, Int -> File -> ShowS
[File] -> ShowS
File -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [File] -> ShowS
$cshowList :: [File] -> ShowS
show :: File -> String
$cshow :: File -> String
showsPrec :: Int -> File -> ShowS
$cshowsPrec :: Int -> File -> ShowS
Show)
class AsASCII a where
dump :: a -> ASCII
load :: ASCII -> Maybe a
instance AsASCII Addr where
dump :: Addr -> ASCII
dump = String -> ASCII
Char8.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
load :: ASCII -> Maybe Addr
load = forall a. Read a => String -> Maybe a
readMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII -> String
Char8.unpack
instance AsASCII W256 where
dump :: W256 -> ASCII
dump = String -> ASCII
Char8.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show
load :: ASCII -> Maybe W256
load = forall a. Read a => String -> Maybe a
readMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. ASCII -> String
Char8.unpack
instance AsASCII ByteString where
dump :: ASCII -> ASCII
dump ASCII
x = ASCII -> ASCII
BS16.encodeBase16' ASCII
x forall a. Semigroup a => a -> a -> a
<> ASCII
"\n"
load :: ASCII -> Maybe ASCII
load ASCII
x =
case ASCII -> Either Text ASCII
BS16.decodeBase16 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> ASCII -> [ASCII]
BS.split Word8
10 forall a b. (a -> b) -> a -> b
$ ASCII
x of
Right ASCII
y -> forall a. a -> Maybe a
Just ASCII
y
Either Text ASCII
_ -> forall a. Maybe a
Nothing
contractFacts :: Addr -> Contract -> Map W256 (Map W256 W256) -> [Fact]
contractFacts :: Addr -> Contract -> Map W256 (Map W256 W256) -> [Fact]
contractFacts Addr
a Contract
x Map W256 (Map W256 W256)
store = case forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getter Contract (Expr 'Buf)
bytecode Contract
x of
ConcreteBuf ASCII
b ->
Addr -> Map W256 (Map W256 W256) -> [Fact]
storageFacts Addr
a Map W256 (Map W256 W256)
store forall a. [a] -> [a] -> [a]
++
[ Addr -> W256 -> Fact
BalanceFact Addr
a Contract
x._balance
, Addr -> W256 -> Fact
NonceFact Addr
a Contract
x._nonce
, Addr -> ASCII -> Fact
CodeFact Addr
a ASCII
b
]
Expr 'Buf
_ ->
Addr -> Map W256 (Map W256 W256) -> [Fact]
storageFacts Addr
a Map W256 (Map W256 W256)
store forall a. [a] -> [a] -> [a]
++
[ Addr -> W256 -> Fact
BalanceFact Addr
a Contract
x._balance
, Addr -> W256 -> Fact
NonceFact Addr
a Contract
x._nonce
]
storageFacts :: Addr -> Map W256 (Map W256 W256) -> [Fact]
storageFacts :: Addr -> Map W256 (Map W256 W256) -> [Fact]
storageFacts Addr
a Map W256 (Map W256 W256)
store = forall a b. (a -> b) -> [a] -> [b]
map (W256, W256) -> Fact
f (forall k a. Map k a -> [(k, a)]
Map.toList (forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault forall k a. Map k a
Map.empty (forall a b. (Integral a, Num b) => a -> b
num Addr
a) Map W256 (Map W256 W256)
store))
where
f :: (W256, W256) -> Fact
f :: (W256, W256) -> Fact
f (W256
k, W256
v) = StorageFact
{ $sel:addr:BalanceFact :: Addr
addr = Addr
a
, $sel:what:BalanceFact :: W256
what = forall a b. (Integral a, Num b) => a -> b
fromIntegral W256
v
, $sel:which:BalanceFact :: W256
which = forall a b. (Integral a, Num b) => a -> b
fromIntegral W256
k
}
cacheFacts :: Cache -> Set Fact
cacheFacts :: Cache -> Set Fact
cacheFacts Cache
c = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ do
(Addr
k, Contract
v) <- forall k a. Map k a -> [(k, a)]
Map.toList Cache
c._fetchedContracts
Addr -> Contract -> Map W256 (Map W256 W256) -> [Fact]
contractFacts Addr
k Contract
v Cache
c._fetchedStorage
vmFacts :: VM -> Set Fact
vmFacts :: VM -> Set Fact
vmFacts VM
vm = forall a. Ord a => [a] -> Set a
Set.fromList forall a b. (a -> b) -> a -> b
$ do
(Addr
k, Contract
v) <- forall k a. Map k a -> [(k, a)]
Map.toList VM
vm._env._contracts
case VM
vm._env._storage of
Expr 'Storage
EmptyStore -> Addr -> Contract -> Map W256 (Map W256 W256) -> [Fact]
contractFacts Addr
k Contract
v forall k a. Map k a
Map.empty
ConcreteStore Map W256 (Map W256 W256)
s -> Addr -> Contract -> Map W256 (Map W256 W256) -> [Fact]
contractFacts Addr
k Contract
v Map W256 (Map W256 W256)
s
Expr 'Storage
_ -> forall a. HasCallStack => String -> a
error String
"cannot serialize an abstract store"
apply1 :: VM -> Fact -> VM
apply1 :: VM -> Fact -> VM
apply1 VM
vm Fact
fact =
case Fact
fact of
CodeFact {ASCII
Addr
blob :: ASCII
addr :: Addr
$sel:blob:BalanceFact :: Fact -> ASCII
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s a. State s a -> s -> s
execState VM
vm forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
assign (Lens' VM Env
env forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Env (Map Addr Contract)
contracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
at Addr
addr) (forall a. a -> Maybe a
Just (ContractCode -> Contract
EVM.initialContract (RuntimeCode -> ContractCode
EVM.RuntimeCode (ASCII -> RuntimeCode
EVM.ConcreteRuntimeCode ASCII
blob))))
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (VM
vm._state._contract forall a. Eq a => a -> a -> Bool
== Addr
addr) forall a b. (a -> b) -> a -> b
$ Addr -> State VM ()
EVM.loadContract Addr
addr
StorageFact {Addr
W256
which :: W256
what :: W256
addr :: Addr
$sel:which:BalanceFact :: Fact -> W256
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} ->
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over (Lens' VM Env
env forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Env (Expr 'Storage)
storage) (Expr 'EWord
-> Expr 'EWord -> Expr 'EWord -> Expr 'Storage -> Expr 'Storage
writeStorage (Addr -> Expr 'EWord
litAddr Addr
addr) (W256 -> Expr 'EWord
Lit W256
which) (W256 -> Expr 'EWord
Lit W256
what))
BalanceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} ->
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> b -> s -> t
set (Lens' VM Env
env forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Env (Map Addr Contract)
contracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Addr
addr forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Contract W256
balance) W256
what
NonceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} ->
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> b -> s -> t
set (Lens' VM Env
env forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Env (Map Addr Contract)
contracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Addr
addr forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Contract W256
nonce) W256
what
apply2 :: VM -> Fact -> VM
apply2 :: VM -> Fact -> VM
apply2 VM
vm Fact
fact =
case Fact
fact of
CodeFact {ASCII
Addr
blob :: ASCII
addr :: Addr
$sel:blob:BalanceFact :: Fact -> ASCII
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s a. State s a -> s -> s
execState VM
vm forall a b. (a -> b) -> a -> b
$ do
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
assign (Lens' VM Cache
cache forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Cache (Map Addr Contract)
fetchedContracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
at Addr
addr) (forall a. a -> Maybe a
Just (ContractCode -> Contract
EVM.initialContract (RuntimeCode -> ContractCode
EVM.RuntimeCode (ASCII -> RuntimeCode
EVM.ConcreteRuntimeCode ASCII
blob))))
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (VM
vm._state._contract forall a. Eq a => a -> a -> Bool
== Addr
addr) forall a b. (a -> b) -> a -> b
$ Addr -> State VM ()
EVM.loadContract Addr
addr
StorageFact {Addr
W256
which :: W256
what :: W256
addr :: Addr
$sel:which:BalanceFact :: Fact -> W256
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} -> let
store :: Map W256 (Map W256 W256)
store = VM
vm._cache._fetchedStorage
ctrct :: Map W256 W256
ctrct = forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault forall k a. Map k a
Map.empty (forall a b. (Integral a, Num b) => a -> b
num Addr
addr) Map W256 (Map W256 W256)
store
in
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> b -> s -> t
set (Lens' VM Cache
cache forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Cache (Map W256 (Map W256 W256))
fetchedStorage) (forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (forall a b. (Integral a, Num b) => a -> b
num Addr
addr) (forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert W256
which W256
what Map W256 W256
ctrct) Map W256 (Map W256 W256)
store)
BalanceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} ->
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> b -> s -> t
set (Lens' VM Cache
cache forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Cache (Map Addr Contract)
fetchedContracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Addr
addr forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Contract W256
balance) W256
what
NonceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} ->
VM
vm forall a b. a -> (a -> b) -> b
& forall s t a b. ASetter s t a b -> b -> s -> t
set (Lens' VM Cache
cache forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Cache (Map Addr Contract)
fetchedContracts forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Addr
addr forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Contract W256
nonce) W256
what
instance Ord Fact where
compare :: Fact -> Fact -> Ordering
compare = forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing Fact -> (Int, Addr, W256)
f
where
f :: Fact -> (Int, Addr, W256)
f :: Fact -> (Int, Addr, W256)
f (CodeFact Addr
a ASCII
_) = (Int
0, Addr
a, W256
0)
f (BalanceFact Addr
a W256
_) = (Int
1, Addr
a, W256
0)
f (NonceFact Addr
a W256
_) = (Int
2, Addr
a, W256
0)
f (StorageFact Addr
a W256
_ W256
x) = (Int
3, Addr
a, W256
x)
apply :: VM -> Set Fact -> VM
apply :: VM -> Set Fact -> VM
apply =
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl VM -> Fact -> VM
apply1
applyCache :: VM -> Set Fact -> VM
applyCache :: VM -> Set Fact -> VM
applyCache =
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl VM -> Fact -> VM
apply2
factToFile :: Fact -> File
factToFile :: Fact -> File
factToFile Fact
fact = case Fact
fact of
StorageFact {Addr
W256
which :: W256
what :: W256
addr :: Addr
$sel:which:BalanceFact :: Fact -> W256
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a. AsASCII a => [ASCII] -> ASCII -> a -> File
mk [ASCII
"storage"] (forall a. AsASCII a => a -> ASCII
dump W256
which) W256
what
BalanceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a. AsASCII a => [ASCII] -> ASCII -> a -> File
mk [] ASCII
"balance" W256
what
NonceFact {Addr
W256
what :: W256
addr :: Addr
$sel:what:BalanceFact :: Fact -> W256
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a. AsASCII a => [ASCII] -> ASCII -> a -> File
mk [] ASCII
"nonce" W256
what
CodeFact {ASCII
Addr
blob :: ASCII
addr :: Addr
$sel:blob:BalanceFact :: Fact -> ASCII
$sel:addr:BalanceFact :: Fact -> Addr
..} -> forall a. AsASCII a => [ASCII] -> ASCII -> a -> File
mk [] ASCII
"code" ASCII
blob
where
mk :: AsASCII a => [ASCII] -> ASCII -> a -> File
mk :: forall a. AsASCII a => [ASCII] -> ASCII -> a -> File
mk [ASCII]
prefix ASCII
base a
a =
Path -> Data -> File
File ([ASCII] -> ASCII -> Path
Path (forall a. AsASCII a => a -> ASCII
dump Fact
fact.addr forall a. a -> [a] -> [a]
: [ASCII]
prefix) ASCII
base)
(ASCII -> Data
Data forall a b. (a -> b) -> a -> b
$ forall a. AsASCII a => a -> ASCII
dump a
a)
pattern Load :: AsASCII a => a -> ASCII
pattern $mLoad :: forall {r} {a}. AsASCII a => ASCII -> (a -> r) -> ((# #) -> r) -> r
Load x <- (load -> Just x)
fileToFact :: File -> Maybe Fact
fileToFact :: File -> Maybe Fact
fileToFact = \case
File (Path [Load Addr
a] ASCII
"code") (Data (Load ASCII
x))
-> forall a. a -> Maybe a
Just (Addr -> ASCII -> Fact
CodeFact Addr
a ASCII
x)
File (Path [Load Addr
a] ASCII
"balance") (Data (Load W256
x))
-> forall a. a -> Maybe a
Just (Addr -> W256 -> Fact
BalanceFact Addr
a W256
x)
File (Path [Load Addr
a] ASCII
"nonce") (Data (Load W256
x))
-> forall a. a -> Maybe a
Just (Addr -> W256 -> Fact
NonceFact Addr
a W256
x)
File (Path [Load Addr
a, ASCII
"storage"] (Load W256
x)) (Data (Load W256
y))
-> forall a. a -> Maybe a
Just (Addr -> W256 -> W256 -> Fact
StorageFact Addr
a W256
y W256
x)
File
_
-> forall a. Maybe a
Nothing