IPFS and farcaster

Author: supiket

app/Config.hs

@@ -4,15 +4,14 @@
 
 module Config
   ( Config (..),
-    XConfig (..),
     FarcasterConfig (..),
     IPFSConfig (..),
     loadConfig,
     deserializeInterval,
   )
 where
 
-import Data.Aeson
+import Data.Aeson (FromJSON, decodeFileStrict)
 import qualified Data.Text as T
 import GHC.Generics (Generic)
 import System.Environment (lookupEnv)
@@ -22,27 +21,20 @@ import Text.Read (readMaybe)
 data Config = Config
   { ipfsConfig :: IPFSConfig,
     farcasterConfig :: FarcasterConfig,
-    xConfig :: XConfig,
     intervalMinutes :: T.Text
   }
   deriving (Show, Generic)
 
 data IPFSConfig = IPFSConfig
   { gateway :: T.Text,
-    folderCID :: T.Text
+    folderCID :: T.Text,
+    pinataToken :: T.Text
   }
   deriving (Show, Generic)
 
-newtype FarcasterConfig = FarcasterConfig
-  { authToken :: T.Text
-  }
-  deriving (Show, Generic)
-
-data XConfig = XConfig
-  { apiKey :: T.Text,
-    apiSecret :: T.Text,
-    accessToken :: T.Text,
-    accessSecret :: T.Text
+data FarcasterConfig = FarcasterConfig
+  { neynarApiKey :: T.Text,
+    neynarUuid :: T.Text
   }
   deriving (Show, Generic)
 
@@ -52,8 +44,6 @@ instance FromJSON IPFSConfig
 
 instance FromJSON FarcasterConfig
 
-instance FromJSON XConfig
-
 resolveEnvVar :: T.Text -> IO T.Text
 resolveEnvVar t = case T.stripPrefix "${" t >>= T.stripSuffix "}" of
   Just var -> do
@@ -83,24 +73,18 @@ loadConfig path = do
     IPFSConfig
       <$> resolveEnvVar (gateway $ ipfsConfig rawConfig)
       <*> resolveEnvVar (folderCID $ ipfsConfig rawConfig)
+      <*> resolveEnvVar (pinataToken $ ipfsConfig rawConfig)
 
   resolvedFarcasterConf <-
     FarcasterConfig
-      <$> resolveEnvVar (authToken $ farcasterConfig rawConfig)
-
-  resolvedXConf <-
-    XConfig
-      <$> resolveEnvVar (apiKey $ xConfig rawConfig)
-      <*> resolveEnvVar (apiSecret $ xConfig rawConfig)
-      <*> resolveEnvVar (accessToken $ xConfig rawConfig)
-      <*> resolveEnvVar (accessSecret $ xConfig rawConfig)
+      <$> resolveEnvVar (neynarApiKey $ farcasterConfig rawConfig)
+      <*> resolveEnvVar (neynarUuid $ farcasterConfig rawConfig)
 
   resolvedInterval <- resolveEnvVar (intervalMinutes rawConfig)
 
   return $
     rawConfig
       { ipfsConfig = resolvedIpfsConf,
         farcasterConfig = resolvedFarcasterConf,
-        xConfig = resolvedXConf,
         intervalMinutes = resolvedInterval
       }

app/Farcaster.hs

@@ -0,0 +1,47 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Farcaster (postCastWithImage) where
+
+import Config (FarcasterConfig (..))
+import Control.Exception (SomeException, try)
+import Data.Aeson (Value, encode, object, (.=))
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
+import Network.HTTP.Client (responseBody)
+import Network.HTTP.Simple (Response, getResponseStatusCode, httpLBS, parseRequest, setRequestBodyLBS, setRequestHeader)
+
+postCastWithImage :: FarcasterConfig -> T.Text -> T.Text -> IO Bool
+postCastWithImage cfg castText imgUrl = do
+  let apiKey = neynarApiKey cfg
+  let signerUuid = neynarUuid cfg
+
+  let embedObject = object ["url" .= imgUrl] :: Value
+  let requestBody =
+        encode $
+          object
+            [ "text" .= castText,
+              "signer_uuid" .= signerUuid,
+              "embeds" .= [embedObject]
+            ]
+
+  initReq <- parseRequest "POST https://api.neynar.com/v2/farcaster/cast"
+  let request =
+        setRequestBodyLBS requestBody $
+          setRequestHeader "api_key" [TE.encodeUtf8 apiKey] $
+            setRequestHeader "Content-Type" ["application/json"] initReq
+
+  result <- try (httpLBS request) :: IO (Either SomeException (Response BL.ByteString))
+
+  case result of
+    Right response -> do
+      putStrLn $ "response body: " ++ show (responseBody response)
+      let status = getResponseStatusCode response
+      if status >= 200 && status < 300
+        then return True
+        else do
+          putStrLn $ "failed to post cast. status code: " ++ show status
+          return False
+    Left err -> do
+      putStrLn $ "error sending request: " ++ show err
+      return False

app/IPFS.hs

@@ -1,69 +1,73 @@
 module IPFS
-  ( IPFSFile (..),
-    listIPFSDirectory,
+  ( DirectoryEntry (..),
+    listPinataDirectory,
     makeIPFSUrl,
-    isJPG,
   )
 where
 
 import Config (IPFSConfig (..))
-import Control.Exception (try)
-import Data.Aeson
-import qualified Data.ByteString.Lazy as LBS
+import Data.Aeson (FromJSON, eitherDecode, parseJSON, withObject, (.:))
+import qualified Data.ByteString.Char8 as BC
 import qualified Data.Text as T
 import GHC.Generics (Generic)
-import Network.HTTP.Simple
+import Network.HTTP.Simple (getResponseBody, httpLBS, parseRequest_, setRequestHeader, setRequestMethod)
 
--- file representation matching IPFS directory listing
-data IPFSFile = IPFSFile
-  { name :: T.Text, -- file name with path
-    hash :: T.Text, -- file's CID
-    size :: Integer,
-    type_ :: T.Text -- "File" or "Directory"
+data DirectoryEntry = DirectoryEntry
+  { name :: T.Text,
+    hash :: T.Text,
+    tsize :: Integer
   }
   deriving (Show, Generic)
 
-instance FromJSON IPFSFile where
-  parseJSON = withObject "IPFSFile" $ \v ->
-    IPFSFile
-      <$> v .: "name"
-      <*> v .: "hash"
-      <*> v .: "size"
-      <*> v .: "type"
+newtype IPFSHash = IPFSHash
+  { hashValue :: T.Text
+  }
+  deriving (Show, Generic)
 
--- directory listing from IPFS gateway
-newtype DirectoryListing = DirectoryListing
-  { entries :: [IPFSFile]
+newtype IPFSDirectory = IPFSDirectory
+  { links :: [DirectoryEntry]
   }
   deriving (Show, Generic)
 
-instance FromJSON DirectoryListing
+instance FromJSON IPFSDirectory where
+  parseJSON = withObject "IPFSDirectory" $ \v ->
+    IPFSDirectory
+      <$> v .: "Links"
+
+instance FromJSON IPFSHash where
+  parseJSON = withObject "IPFSHash" $ \v ->
+    IPFSHash
+      <$> v .: "/"
+
+instance FromJSON DirectoryEntry where
+  parseJSON = withObject "DirectoryEntry" $ \v -> do
+    _name <- v .: "Name"
+    hashObj <- v .: "Hash"
+    _hashValue <- hashObj .: "/"
+    _tsize <- v .: "Tsize"
+    return $ DirectoryEntry _name _hashValue _tsize
 
-makeIPFSUrl :: IPFSConfig -> T.Text -> T.Text
-makeIPFSUrl cfg path =
+-- for accessing content - uses the configured gateway
+makeIPFSUrl :: IPFSConfig -> DirectoryEntry -> T.Text
+makeIPFSUrl cfg entry =
   gateway cfg
     <> "/ipfs/"
     <> folderCID cfg
-    <> (if T.null path then "" else "/" <> path)
+    <> "/"
+    <> name entry
 
-isJPG :: T.Text -> Bool
-isJPG filename =
-  any
-    (`T.isSuffixOf` T.toLower filename)
-    [".jpg", ".jpeg"]
+-- for listing directory contents - uses Pinata gateway
+listPinataDirectory :: IPFSConfig -> IO (Either String [DirectoryEntry])
+listPinataDirectory cfg = do
+  let url = "https://gateway.pinata.cloud/ipfs/" <> T.unpack (folderCID cfg) <> "?format=dag-json"
+      request =
+        setRequestMethod "GET" $
+          setRequestHeader "Authorization" [BC.pack $ "Bearer " <> T.unpack (pinataToken cfg)] $
+            setRequestHeader "Accept" ["application/json"] $
+              parseRequest_ url
 
-listIPFSDirectory :: IPFSConfig -> IO [IPFSFile]
-listIPFSDirectory cfg = do
-  let url = gateway cfg <> "/ipfs/" <> folderCID cfg <> "?format=json"
-  request <- parseRequest (T.unpack url)
-  response <- try (httpLBS request) :: IO (Either HttpException (Response LBS.ByteString))
-  case response of
-    Right res -> do
-      case eitherDecode (getResponseBody res) of
-        Right listing -> return $ filter (\f -> type_ f == "File") $ entries listing
-        Left err -> do
-          putStrLn $ "error parsing directory listing: " ++ err
-          return []
-    Left err -> do
-      putStrLn $ "error fetching directory listing: " ++ show err
-      return []
+  response <- httpLBS request
+  let result = eitherDecode $ getResponseBody response
+  pure $ case result of
+    Left err -> Left err
+    Right obj -> Right (links obj)

app/Main.hs

@@ -5,10 +5,11 @@ import Control.Concurrent (threadDelay)
 import Control.Exception (try)
 import Control.Monad (forever)
 import qualified Data.ByteString.Lazy as BL
+import Data.Char (isAlphaNum)
 import qualified Data.Text as T
+import Farcaster
 import IPFS
-import Network.HTTP.Simple
-import Social
+import Network.HTTP.Simple (HttpException, Response, getResponseBody, httpLBS, parseRequest)
 import System.Directory (createDirectoryIfMissing, removeFile)
 import System.FilePath ((</>))
 import System.Random (randomRIO)
@@ -25,28 +26,30 @@ downloadImage url path = do
       putStrLn $ "error downloading image: " ++ show err
       return False
 
-processFile :: Config -> IPFSFile -> IO ()
-processFile cfg file = do
-  let ipfsUrl = makeIPFSUrl (ipfsConfig cfg) (name file)
-  putStrLn $ "processing: " ++ T.unpack (name file)
-  let tempPath = "temp" </> T.unpack (name file)
-  createDirectoryIfMissing True "temp"
+isValidImage :: T.Text -> Bool
+isValidImage fileName =
+  let lowercase = T.toLower fileName
+   in T.isSuffixOf ".jpg" lowercase
+        && not (T.isPrefixOf "." lowercase) -- excludes .DS_Store and other hidden files
+        && not (T.isPrefixOf "_" lowercase) -- excludes _thumb files etc
+        && T.all isAllowedChar fileName -- ensures filename only contains safe characters
+  where
+    isAllowedChar c = isAlphaNum c || c `elem` ['.', '-', '_']
 
+processFile :: Config -> DirectoryEntry -> IO ()
+processFile cfg entry = do
+  let ipfsUrl = makeIPFSUrl (ipfsConfig cfg) entry
+  putStrLn $ "processing: " ++ T.unpack (name entry)
+  let tempPath = "temp" </> T.unpack (name entry)
+  createDirectoryIfMissing True "temp"
   downloadSuccess <- downloadImage ipfsUrl tempPath
   if downloadSuccess
     then do
       let postText = "A bit of Saturn"
 
-      farcasterSuccess <- postToFarcaster (farcasterConfig cfg) postText ipfsUrl
+      farcasterSuccess <- postCastWithImage (farcasterConfig cfg) postText ipfsUrl
       putStrLn $ "farcaster post: " ++ if farcasterSuccess then "success" else "failed"
 
-      mediaIdMaybe <- uploadToX (xConfig cfg) tempPath
-      case mediaIdMaybe of
-        Just mediaId -> do
-          xSuccess <- createXPost (xConfig cfg) postText [mediaId]
-          putStrLn $ "X post: " ++ if xSuccess then "success" else "failed"
-        Nothing -> putStrLn "failed to upload image to X"
-
       removeFile tempPath
     else putStrLn "failed to download image"
 
@@ -59,21 +62,21 @@ sleep minutes = do
 main :: IO ()
 main = forever $ do
   cfg <- loadConfig "config.json"
-
-  files <- listIPFSDirectory (ipfsConfig cfg)
-  let jpgFiles = filter (isJPG . name) files
-
-  putStrLn $ "found " ++ show (length jpgFiles) ++ " JPG files"
-
-  case jpgFiles of
-    [] -> do
-      putStrLn "no files to process"
-      sleep (deserializeInterval (intervalMinutes cfg))
-    bits -> do
-      -- Select a random file
-      randomIndex <- randomRIO (0, length bits - 1)
-      let selectedBit = bits !! randomIndex
-
-      putStrLn $ "randomly selected: " ++ T.unpack (name selectedBit)
-      processFile cfg selectedBit
+  entries <- listPinataDirectory (ipfsConfig cfg)
+  case entries of
+    Left err -> do
+      putStrLn $ "error listing directory: " ++ err
       sleep (deserializeInterval (intervalMinutes cfg))
+    Right entries' -> do
+      let validFiles = filter (isValidImage . name) entries'
+      putStrLn $ "found " ++ show (length validFiles) ++ " valid image files"
+      case validFiles of
+        [] -> do
+          putStrLn "no files to process"
+          sleep (deserializeInterval (intervalMinutes cfg))
+        bits -> do
+          randomIndex <- randomRIO (0, length bits - 1)
+          let selectedBit = bits !! randomIndex
+          putStrLn $ "randomly selected: " ++ T.unpack (name selectedBit)
+          processFile cfg selectedBit
+          sleep (deserializeInterval (intervalMinutes cfg))

app/Main.hs.backup

@@ -0,0 +1,93 @@
+module Main where
+
+import Config
+import Control.Concurrent (threadDelay)
+import Control.Exception (try)
+import Control.Monad (forever)
+import qualified Data.ByteString.Lazy as BL
+import Data.Char (isAlphaNum)
+import qualified Data.Text as T
+import Farcaster
+import IPFS
+import Network.HTTP.Simple
+import System.Directory (createDirectoryIfMissing, removeFile)
+import System.FilePath ((</>))
+import System.Random (randomRIO)
+import X
+
+downloadImage :: T.Text -> FilePath -> IO Bool
+downloadImage url path = do
+  request <- parseRequest (T.unpack url)
+  response <- try $ httpLBS request :: IO (Either HttpException (Response BL.ByteString)) -- Add type annotation
+  case response of
+    Right r -> do
+      BL.writeFile path (getResponseBody r)
+      return True
+    Left err -> do
+      putStrLn $ "error downloading image: " ++ show err
+      return False
+
+isValidImage :: T.Text -> Bool
+isValidImage fileName =
+  let lowercase = T.toLower fileName
+   in T.isSuffixOf ".jpg" lowercase
+        && not (T.isPrefixOf "." lowercase) -- excludes .DS_Store and other hidden files
+        && not (T.isPrefixOf "_" lowercase) -- excludes _thumb files etc
+        && T.all isAllowedChar fileName -- ensures filename only contains safe characters
+  where
+    isAllowedChar c = isAlphaNum c || c `elem` ['.', '-', '_']
+
+processFile :: Config -> DirectoryEntry -> IO ()
+processFile cfg entry = do
+  let ipfsUrl = makeIPFSUrl (ipfsConfig cfg) entry
+  putStrLn $ "processing: " ++ T.unpack (name entry)
+  let tempPath = "temp" </> T.unpack (name entry)
+  createDirectoryIfMissing True "temp"
+  downloadSuccess <- downloadImage ipfsUrl tempPath
+  if downloadSuccess
+    then do
+      let postText = "A bit of Saturn"
+
+      farcasterSuccess <- postCastWithImage (farcasterConfig cfg) postText ipfsUrl
+      putStrLn $ "farcaster post: " ++ if farcasterSuccess then "success" else "failed"
+
+      -- mediaResult <- uploadToX (xConfig cfg) tempPath
+      -- putStrLn $ "media upload: " ++ show mediaResult
+      -- case mediaResult of
+        -- Left err -> putStrLn $ "media upload failed: " ++ show err
+        -- Right mediaId -> do
+          -- postResult <- createXPost (xConfig cfg) postText [mediaId]
+          -- case postResult of
+            -- Left err -> putStrLn $ "x post failed: " ++ show err
+            -- Right () -> putStrLn "x post success"
+
+      removeFile tempPath
+    else putStrLn "failed to download image"
+
+sleep :: Int -> IO ()
+sleep minutes = do
+  let microseconds = minutes * 60 * 1000000
+  putStrLn $ "\nsleeping for " ++ show minutes ++ " minutes..."
+  threadDelay microseconds
+
+main :: IO ()
+main = forever $ do
+  cfg <- loadConfig "config.json"
+  entries <- listPinataDirectory (ipfsConfig cfg)
+  case entries of
+    Left err -> do
+      putStrLn $ "error listing directory: " ++ err
+      sleep (deserializeInterval (intervalMinutes cfg))
+    Right entries' -> do
+      let validFiles = filter (isValidImage . name) entries'
+      putStrLn $ "found " ++ show (length validFiles) ++ " valid image files"
+      case validFiles of
+        [] -> do
+          putStrLn "no files to process"
+          sleep (deserializeInterval (intervalMinutes cfg))
+        bits -> do
+          randomIndex <- randomRIO (0, length bits - 1)
+          let selectedBit = bits !! randomIndex
+          putStrLn $ "randomly selected: " ++ T.unpack (name selectedBit)
+          processFile cfg selectedBit
+          sleep (deserializeInterval (intervalMinutes cfg))

app/Social.hs

@@ -0,0 +1,181 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module X (uploadToX, createXPost, MediaUploadError(..)) where
+
+import Config (XConfig(..))
+import Control.Exception (SomeException, try)
+import GHC.Generics (Generic)
+import Data.Aeson (FromJSON, Value(..), object, (.=), eitherDecode, encode)
+import qualified Data.Aeson.KeyMap as KM
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Lazy.Char8 as BL8
+import qualified Data.ByteString.Char8 as BS8
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as TE
+import Network.HTTP.Client
+import Network.HTTP.Client.MultipartFormData
+import Network.HTTP.Client.TLS (tlsManagerSettings)
+import Network.HTTP.Types (methodPost, status200)
+import System.IO (hPutStrLn, stderr)
+import System.Environment (getEnv, setEnv)
+
+data MediaUploadError
+  = FileReadError
+  | NetworkError String
+  | ParseError String
+  deriving (Show, Eq)
+
+data TokenResponse = TokenResponse
+  { access_token :: T.Text
+  , refresh_token :: T.Text
+  , expires_in :: Int
+  } deriving (Show, Generic)
+
+instance FromJSON TokenResponse
+
+refreshAccessToken :: XConfig -> IO (Either String T.Text)
+refreshAccessToken cfg = do
+  manager <- newManager tlsManagerSettings
+  request <- parseRequest "https://api.x.com/2/oauth2/token"
+
+  let authToken = "Basic " <> TE.encodeUtf8 (xBasicAuthToken cfg)
+
+  let body = BS8.pack $ "client_id=" ++ T.unpack (xClientId cfg)
+                     ++ "&refresh_token=" ++ T.unpack (xRefreshToken cfg)
+                     ++ "&grant_type=refresh_token"
+
+  let request' = request
+        { method = "POST"
+        , requestHeaders =
+            [ ("Content-Type", "application/x-www-form-urlencoded")
+            , ("Authorization", authToken)
+            ]
+        , requestBody = RequestBodyBS body
+        }
+
+  response <- httpLbs request' manager
+  let bodyContent = responseBody response
+
+  print bodyContent -- TODO: remove
+
+  case eitherDecode bodyContent of
+    Left err -> do
+      hPutStrLn stderr $ "failed to refresh token: " ++ err
+      return $ Left err
+    Right tokenResponse -> do
+      token <- getEnv "X_REFRESH_TOKEN"
+      print token
+      setEnv "X_REFRESH_TOKEN" (T.unpack $ refresh_token tokenResponse)
+      token <- getEnv "X_REFRESH_TOKEN"
+      print token
+      return $ Right (access_token tokenResponse)
+
+prepareAuthHeader :: XConfig -> Request -> IO Request
+prepareAuthHeader cfg req = do
+  tokenResult <- refreshAccessToken cfg
+  case tokenResult of
+    Left err -> do
+      hPutStrLn stderr $ "warning: using stale token due to error: " ++ err
+      return req
+    Right token -> return req { requestHeaders = ("Authorization", "Bearer " <> TE.encodeUtf8 token) : requestHeaders req }
+
+uploadToX :: XConfig -> FilePath -> IO (Either MediaUploadError T.Text)
+uploadToX cfg filePath = do
+  imageDataResult <- try $ BS.readFile filePath
+  case imageDataResult of
+    Left (_ :: SomeException) -> return $ Left FileReadError
+    Right imageData -> do
+      manager <- newManager tlsManagerSettings
+
+      -- Step 1: INIT
+      initRequest <- parseRequest "https://api.x.com/2/media/upload"
+
+      let totalBytes = BS.length imageData
+          mediaType = "image/jpeg"
+          mediaCategory = "tweet_image"
+
+      let initRequestWithBody = initRequest { method = "POST" }
+      requestWithBody <- formDataBody
+        [ partBS "command" "INIT"
+        , partBS "media_type" (BS8.pack mediaType)
+        , partBS "total_bytes" (BS8.pack (show totalBytes))
+        , partBS "media_category" (BS8.pack mediaCategory)
+        ] initRequestWithBody
+
+      initRequest' <- prepareAuthHeader cfg requestWithBody
+
+      print initRequest'
+
+      initResponse <- httpLbs initRequest' manager
+      let initResponseBody = responseBody initResponse
+
+      print initResponseBody
+
+      case eitherDecode initResponseBody of
+        Left err -> return $ Left $ ParseError err
+        Right (Object initObj) -> case KM.lookup "media_id" initObj of
+          Just (String mediaId) -> do
+            -- Step 2: APPEND
+            let appendParams = object
+                  [ "command" .= ("APPEND" :: T.Text)
+                  , "media_id" .= mediaId
+                  , "segment_index" .= (0 :: Int)
+                  ]
+
+            appendRequest <- parseRequest "https://api.x.com/2/media/upload"
+            appendRequest' <- prepareAuthHeader cfg appendRequest
+                  { method = methodPost
+                  , requestHeaders = ("Content-Type", "multipart/form-data") : requestHeaders appendRequest
+                  , requestBody = RequestBodyLBS (encode appendParams)
+                  }
+
+            appendResponse <- httpNoBody appendRequest' manager
+            if responseStatus appendResponse /= status200
+              then return $ Left $ NetworkError "APPEND failed"
+              else do
+                -- Step 3: FINALIZE
+                let finalizeParams = object
+                      [ "command" .= ("FINALIZE" :: T.Text)
+                      , "media_id" .= mediaId
+                      ]
+
+                finalizeRequest <- parseRequest "https://api.x.com/2/media/upload"
+                finalizeRequest' <- prepareAuthHeader cfg finalizeRequest
+                      { method = "POST"
+                      , requestHeaders = ("Content-Type", "multipart/form-data") : requestHeaders finalizeRequest
+                      , requestBody = RequestBodyLBS (encode finalizeParams)
+                      }
+
+                finalizeResponse <- httpLbs finalizeRequest' manager
+                let finalizeResponseBody = responseBody finalizeResponse
+                case eitherDecode finalizeResponseBody of
+                  Left err -> return $ Left $ ParseError err
+                  Right (Object finalizeObj) -> case KM.lookup "media_id" finalizeObj of
+                    Just (String finalMediaId) -> return $ Right finalMediaId
+                    _ -> return $ Left $ ParseError "missing media_id in FINALIZE response"
+          _ -> return $ Left $ ParseError "missing media_id in INIT response"
+
+createXPost :: XConfig -> T.Text -> [T.Text] -> IO (Either MediaUploadError ())
+createXPost cfg postText mediaIds = do
+  manager <- newManager tlsManagerSettings
+
+  initialRequest <- parseRequest "https://api.x.com/2/tweets"
+
+  let params = object
+        [ "text" .= postText
+        , "media" .= object [ "media_ids" .= mediaIds ]
+        ]
+
+  request <- prepareAuthHeader cfg initialRequest
+        { method = "POST"
+        , requestHeaders = ("Content-Type", "application/json") : requestHeaders initialRequest
+        , requestBody = RequestBodyLBS (encode params)
+        }
+
+  responseEither <- try $ httpLbs request manager
+  case responseEither of
+    Right response -> do
+      putStrLn $ "Response body: " ++ show (responseBody response)
+      return $ Right ()
+    Left (ex :: SomeException) -> return $ Left $ NetworkError $ show ex

app/X.hs.backup

@@ -16,12 +16,13 @@ executable bits-of-saturn
     main-is:          Main.hs
     other-modules:    Config
                     , IPFS
-                    , Social
+                    , Farcaster
     build-depends:    base ^>= 4.18.0.0
                     , aeson
                     , bytestring
                     , directory
                     , filepath
+                    , http-client
                     , http-conduit
                     , random
                     , text

bitsofsaturn.cabal

@@ -1,16 +1,12 @@
 {
     "ipfsConfig": {
         "gateway": "${IPFS_GATEWAY}",
-        "folderCID": "${IPFS_FOLDER_CID}"
+        "folderCID": "${IPFS_FOLDER_CID}",
+        "pinataToken": "${PINATA_TOKEN}"
     },
     "farcasterConfig": {
-        "authToken": "${FARCASTER_AUTH_TOKEN}"
-    },
-    "xConfig": {
-        "apiKey": "${X_API_KEY}",
-        "apiSecret": "${X_API_SECRET}",
-        "accessToken": "${X_ACCESS_TOKEN}",
-        "accessSecret": "${X_ACCESS_SECRET}"
+        "neynarApiKey": "${NEYNAR_API_KEY}",
+        "neynarUuid": "${NEYNAR_UUID}"
     },
     "intervalMinutes": "${INTERVAL_MINUTES}"
 }