Allow building with GHC 9.6

While maintaining the build with the old package set, which is
still needed by obelisk projects, like block-explorer

chainweb-api.cabal

@@ -22,20 +22,20 @@ library
 
   build-depends:
       Decimal               >= 0.4.2 && < 0.6
-    , aeson                 ^>=1.4
+    , aeson                 >=1.4
     , attoparsec            >= 0.13.0.2 && < 0.15
     , base                  >=4.7  && <5
-    , base16-bytestring     ^>=0.1
-    , base64-bytestring     ^>=1.0
-    , bytestring            ^>=0.10
+    , base16-bytestring     >=0.1
+    , base64-bytestring     >=1.0
+    , bytestring            >=0.10
     , cereal                ^>=0.5
     , containers            ^>=0.6
     , data-default          ^>=0.7
-    , hashable              >=1.2 && < 1.4
+    , hashable              >=1.2
     , readable              ^>=0.3
     , scientific
-    , servant               >= 0.16 && < 0.19
-    , text                  ^>=1.2
+    , servant               >= 0.16
+    , text                  >=1.2
     , time                  >=1.8 && < 1.11
     , unordered-containers  ^>=0.2
     , vector                >= 0.11.0.0 && < 0.13

lib/Chainweb/Api/BytesLE.hs

@@ -1,3 +1,5 @@
+{-# LANGUAGE CPP #-}
+
 module Chainweb.Api.BytesLE where
 
 ------------------------------------------------------------------------------
@@ -16,13 +18,22 @@ newtype BytesLE = BytesLE
   { unBytesLE :: ByteString
   } deriving (Eq,Ord,Show)
 
+#if MIN_VERSION_base16_bytestring(1,0,0)
+-- Newer version of base16-bytestring
+hexToBytesLE :: Text -> Either String BytesLE
+hexToBytesLE t = case B16.decode $ T.encodeUtf8 t of
+  Right decoded -> Right $ BytesLE decoded
+  Left _ -> Left $ "Invalid hex string: " <> T.unpack t
+#else
+-- Older version of base16-bytestring
 hexToBytesLE :: Text -> Either String BytesLE
 hexToBytesLE t =
     if B.null invalid
       then Right $ BytesLE decoded
       else Left $ "Invalid hex string: " <> T.unpack t
   where
     (decoded, invalid) = B16.decode $ T.encodeUtf8 t
+#endif
 
 hexFromBytesLE :: BytesLE -> Text
 hexFromBytesLE = T.decodeUtf8 . B16.encode . unBytesLE

lib/Chainweb/Api/Guard.hs

@@ -8,6 +8,7 @@ import           Control.Applicative
 import           Data.Aeson
 import           Data.Maybe
 import           Data.Set (Set)
+import           Data.String (IsString)
 import           Data.Text (Text)
 ------------------------------------------------------------------------------
 
@@ -19,7 +20,7 @@ data Guard
   | GUser UserGuard
   deriving (Eq,Show)
 
-keyNamef :: Text
+keyNamef :: IsString s => s
 keyNamef = "keysetref"
 
 instance ToJSON Guard where

lib/Chainweb/Api/Hash.hs

@@ -8,7 +8,9 @@ import           Data.Aeson.Encoding
 import           Data.Aeson.Types
 import           Data.ByteString (ByteString)
 import qualified Data.ByteString.Base16 as B16
+import           Data.String (fromString)
 import           Data.Text (Text)
+import qualified Data.Text as T
 import qualified Data.Text.Encoding as T
 ------------------------------------------------------------------------------
 import           Chainweb.Api.Base64Url
@@ -18,7 +20,7 @@ newtype Hash = Hash { unHash :: ByteString }
   deriving (Eq,Ord,Show,Read)
 
 instance ToJSONKey Hash where
-  toJSONKey = ToJSONKeyText hashB64U (text . hashB64U)
+  toJSONKey = ToJSONKeyText (fromString . T.unpack . hashB64U) (text . hashB64U)
 
 instance FromJSONKey Hash where
   fromJSONKey = FromJSONKeyTextParser hashParser

lib/Chainweb/Api/Payload.hs

@@ -1,11 +1,11 @@
+{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RecordWildCards #-}
 
 module Chainweb.Api.Payload where
 
 ------------------------------------------------------------------------------
 import           Data.Aeson
-import qualified Data.HashMap.Strict as HM
 import           Data.Text (Text)
 ------------------------------------------------------------------------------
 
@@ -58,11 +58,12 @@ instance ToJSON Payload where
   toJSON (ContPayload cont) = Object $ "cont" .= toJSON cont
 
 instance FromJSON Payload where
-  parseJSON = withObject "Payload" $ \o -> case HM.lookup "exec" o of
-    Just v | v /= Null -> ExecPayload <$> parseJSON v
-    _ -> case HM.lookup "cont" o of
-                 Nothing -> fail "Payload must be exec or cont"
-                 Just v  -> ContPayload <$> parseJSON v
+  parseJSON = withObject "Payload" $ \o -> do
+    o .: "exec" >>= \case
+      Nothing -> o .: "cont" >>= \case
+        Nothing -> fail "Payload must be exec or cont"
+        Just cont -> return $ ContPayload cont
+      Just exec -> return $ ExecPayload exec
 
 payloadCode :: Payload -> Text
 payloadCode (ExecPayload e) = _exec_code e