Merge branch 'rvv001' of git.vergara.tech:Vergara_Tech/zenith into rvv001

.gitignore

@@ -5,3 +5,7 @@ zenith.db
 zenith.log
 zenith.db-shm
 zenith.db-wal
+test.db
+test.db-shm
+test.db-wal
+

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "zcash-haskell"]
 	path = zcash-haskell
 	url = https://git.vergara.tech/Vergara_Tech/zcash-haskell.git
-	branch = milestone2
+	branch = master

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.7.0.0-beta]
 
 ### Added
 
@@ -20,13 +20,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 	- `getnewaccount` RPC method
 	- `getnewaddress` RPC method
 	- `getoperationstatus` RPC method
+	- `sendmany` RPC method
 - Function `prepareTxV2` implementing `PrivacyPolicy`
+- Support for TEX addresses
+- Functionality to shield transparent balance
+- Functionality to de-shield shielded notes
+- Native commitment trees
+	- Batch append to trees in O(log n)
 
 ### Changed
 
 - Detection of changes in database schema for automatic re-scan
 - Block tracking for chain re-org detection
 - Refactored `ZcashPool`
+- Preventing write operations to occur during wallet sync
 
 
 ## [0.6.0.0-beta]

app/Main.hs

@@ -210,9 +210,18 @@ main = do
   zebraPort <- require config "zebraPort"
   zebraHost <- require config "zebraHost"
   nodePort <- require config "nodePort"
+  currencyCode <- require config "currencyCode"
   dbFP <- getZenithPath
   let dbFilePath = T.pack $ dbFP ++ dbFileName
-  let myConfig = Config dbFilePath zebraHost zebraPort nodeUser nodePwd nodePort
+  let myConfig =
+        Config
+          dbFilePath
+          zebraHost
+          zebraPort
+          nodeUser
+          nodePwd
+          nodePort
+          currencyCode
   if not (null args)
     then do
       case head args

app/Server.hs

@@ -2,28 +2,51 @@
 
 module Server where
 
-import Control.Exception (throwIO, try)
+import Control.Concurrent (forkIO, threadDelay)
-import Control.Monad (when)
+import Control.Exception (throwIO, throwTo, try)
+import Control.Monad (forever, when)
+import Control.Monad.Logger (runNoLoggingT)
 import Data.Configurator
+import qualified Data.Text as T
 import Network.Wai.Handler.Warp (run)
 import Servant
+import System.Exit
+import System.Posix.Signals
 import ZcashHaskell.Types (ZebraGetBlockChainInfo(..), ZebraGetInfo(..))
 import Zenith.Core (checkBlockChain, checkZebra)
-import Zenith.DB (initDb)
+import Zenith.DB (getWallets, initDb, initPool)
-import Zenith.RPC (State(..), ZenithRPC(..), authenticate, zenithServer)
+import Zenith.RPC
+  ( State(..)
+  , ZenithRPC(..)
+  , authenticate
+  , scanZebra
+  , zenithServer
+  )
 import Zenith.Scanner (rescanZebra)
 import Zenith.Types (Config(..))
+import Zenith.Utils (getZenithPath)
 
 main :: IO ()
 main = do
   config <- load ["$(HOME)/Zenith/zenith.cfg"]
-  dbFilePath <- require config "dbFilePath"
+  dbFileName <- require config "dbFileName"
   nodeUser <- require config "nodeUser"
   nodePwd <- require config "nodePwd"
   zebraPort <- require config "zebraPort"
   zebraHost <- require config "zebraHost"
   nodePort <- require config "nodePort"
-  let myConfig = Config dbFilePath zebraHost zebraPort nodeUser nodePwd nodePort
+  currencyCode <- require config "currencyCode"
+  dbFP <- getZenithPath
+  let dbFilePath = T.pack $ dbFP ++ dbFileName
+  let myConfig =
+        Config
+          dbFilePath
+          zebraHost
+          zebraPort
+          nodeUser
+          nodePwd
+          nodePort
+          currencyCode
   let ctx = authenticate myConfig :. EmptyContext
   w <- try $ checkZebra zebraHost zebraPort :: IO (Either IOError ZebraGetInfo)
   case w of
@@ -39,16 +62,39 @@ main = do
             Left e2 -> throwIO $ userError e2
             Right x' -> do
               when x' $ rescanZebra zebraHost zebraPort dbFilePath
-              let myState =
+              pool <- runNoLoggingT $ initPool dbFilePath
-                    State
+              walList <- getWallets pool $ zgb_net chainInfo
-                      (zgb_net chainInfo)
+              if not (null walList)
-                      zebraHost
+                then do
-                      zebraPort
+                  scanThread <-
-                      dbFilePath
+                    forkIO $
-                      (zgi_build zebra)
+                    forever $ do
-                      (zgb_blocks chainInfo)
+                      _ <-
-              run nodePort $
+                        scanZebra
-                serveWithContext
+                          dbFilePath
-                  (Proxy :: Proxy ZenithRPC)
+                          zebraHost
-                  ctx
+                          zebraPort
-                  (zenithServer myState)
+                          (zgb_net chainInfo)
+                      threadDelay 90000000
+                  putStrLn "Zenith RPC Server 0.7.0.0-beta"
+                  putStrLn "------------------------------"
+                  putStrLn $
+                    "Connected to " ++
+                    show (zgb_net chainInfo) ++
+                    " Zebra " ++
+                    T.unpack (zgi_build zebra) ++ " on port " ++ show zebraPort
+                  let myState =
+                        State
+                          (zgb_net chainInfo)
+                          zebraHost
+                          zebraPort
+                          dbFilePath
+                          (zgi_build zebra)
+                          (zgb_blocks chainInfo)
+                  run nodePort $
+                    serveWithContext
+                      (Proxy :: Proxy ZenithRPC)
+                      ctx
+                      (zenithServer myState)
+                else putStrLn
+                       "No wallets available. Please start Zenith interactively to create a wallet"

src/Zenith/RPC.hs

@@ -8,21 +8,28 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE DerivingStrategies #-}
 
 module Zenith.RPC where
 
+import Control.Concurrent (forkIO)
 import Control.Exception (try)
+import Control.Monad (unless, when)
 import Control.Monad.IO.Class (liftIO)
-import Control.Monad.Logger (runNoLoggingT)
+import Control.Monad.Logger (runFileLoggingT, runNoLoggingT, runStderrLoggingT)
 import Data.Aeson
+import qualified Data.HexString as H
 import Data.Int
 import Data.Scientific (floatingOrInteger)
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as E
+import Data.Time.Clock (getCurrentTime)
 import qualified Data.UUID as U
+import Data.UUID.V4 (nextRandom)
 import qualified Data.Vector as V
 import Database.Esqueleto.Experimental
-  ( entityKey
+  ( ConnectionPool
+  , entityKey
   , entityVal
   , fromSqlKey
   , toSqlKey
@@ -31,43 +38,73 @@ import Servant
 import Text.Read (readMaybe)
 import ZcashHaskell.Keys (generateWalletSeedPhrase)
 import ZcashHaskell.Orchard (parseAddress)
-import ZcashHaskell.Types (RpcError(..), Scope(..), ZcashNet(..))
+import ZcashHaskell.Types
-import Zenith.Core (createCustomWalletAddress, createZcashAccount)
+  ( BlockResponse(..)
+  , RpcError(..)
+  , Scope(..)
+  , ZcashNet(..)
+  , ZebraGetBlockChainInfo(..)
+  )
+import ZcashHaskell.Utils (getBlockTime, makeZebraCall)
+import Zenith.Core
+  ( checkBlockChain
+  , createCustomWalletAddress
+  , createZcashAccount
+  , prepareTxV2
+  , syncWallet
+  , updateCommitmentTrees
+  )
 import Zenith.DB
   ( Operation(..)
   , ZcashAccount(..)
+  , ZcashBlock(..)
   , ZcashWallet(..)
+  , completeSync
+  , finalizeOperation
   , findNotesByAddress
   , getAccountById
   , getAccounts
   , getAddressById
   , getAddresses
   , getExternalAddresses
+  , getLastSyncBlock
   , getMaxAccount
   , getMaxAddress
+  , getMaxBlock
+  , getMinBirthdayHeight
   , getOperation
   , getPoolBalance
   , getUnconfPoolBalance
   , getWalletNotes
   , getWallets
   , initPool
+  , isSyncing
+  , rewindWalletData
   , saveAccount
   , saveAddress
+  , saveBlock
+  , saveOperation
   , saveWallet
+  , startSync
   , toZcashAccountAPI
   , toZcashAddressAPI
   , toZcashWalletAPI
   , walletExists
   )
+import Zenith.Scanner (checkIntegrity, processTx, updateConfs)
 import Zenith.Types
   ( AccountBalance(..)
   , Config(..)
+  , HexStringDB(..)
   , PhraseDB(..)
+  , PrivacyPolicy(..)
+  , ProposedNote(..)
   , ZcashAccountAPI(..)
   , ZcashAddressAPI(..)
   , ZcashNetDB(..)
   , ZcashNoteAPI(..)
   , ZcashWalletAPI(..)
+  , ZenithStatus(..)
   , ZenithUuid(..)
   )
 import Zenith.Utils (jsonNumber)
@@ -83,6 +120,7 @@ data ZenithMethod
   | GetNewAccount
   | GetNewAddress
   | GetOperationStatus
+  | SendMany
   | UnknownMethod
   deriving (Eq, Prelude.Show)
 
@@ -97,6 +135,7 @@ instance ToJSON ZenithMethod where
   toJSON GetNewAccount = Data.Aeson.String "getnewaccount"
   toJSON GetNewAddress = Data.Aeson.String "getnewaddress"
   toJSON GetOperationStatus = Data.Aeson.String "getoperationstatus"
+  toJSON SendMany = Data.Aeson.String "sendmany"
   toJSON UnknownMethod = Data.Aeson.Null
 
 instance FromJSON ZenithMethod where
@@ -112,6 +151,7 @@ instance FromJSON ZenithMethod where
       "getnewaccount" -> pure GetNewAccount
       "getnewaddress" -> pure GetNewAddress
       "getoperationstatus" -> pure GetOperationStatus
+      "sendmany" -> pure SendMany
       _ -> pure UnknownMethod
 
 data ZenithParams
@@ -125,6 +165,7 @@ data ZenithParams
   | NameIdParams !T.Text !Int
   | NewAddrParams !Int !T.Text !Bool !Bool
   | OpParams !ZenithUuid
+  | SendParams !Int ![ProposedNote] !PrivacyPolicy
   | TestParams !T.Text
   deriving (Eq, Prelude.Show)
 
@@ -148,6 +189,8 @@ instance ToJSON ZenithParams where
     [Data.Aeson.String "ExcludeTransparent" | t]
   toJSON (OpParams i) =
     Data.Aeson.Array $ V.fromList [Data.Aeson.String $ U.toText $ getUuid i]
+  toJSON (SendParams i ns p) =
+    Data.Aeson.Array $ V.fromList [jsonNumber i, toJSON ns, toJSON p]
 
 data ZenithResponse
   = InfoResponse !T.Text !ZenithInfo
@@ -159,6 +202,7 @@ data ZenithResponse
   | NewItemResponse !T.Text !Int64
   | NewAddrResponse !T.Text !ZcashAddressAPI
   | OpResponse !T.Text !Operation
+  | SendResponse !T.Text !U.UUID
   | ErrorResponse !T.Text !Double !T.Text
   deriving (Eq, Prelude.Show)
 
@@ -179,6 +223,7 @@ instance ToJSON ZenithResponse where
   toJSON (NewItemResponse i ix) = packRpcResponse i ix
   toJSON (NewAddrResponse i a) = packRpcResponse i a
   toJSON (OpResponse i u) = packRpcResponse i u
+  toJSON (SendResponse i o) = packRpcResponse i o
 
 instance FromJSON ZenithResponse where
   parseJSON =
@@ -258,6 +303,10 @@ instance FromJSON ZenithResponse where
                       case floatingOrInteger k of
                         Left _e -> fail "Unknown value"
                         Right k' -> pure $ NewItemResponse i k'
+                    String s -> do
+                      case U.fromText s of
+                        Nothing -> fail "Unknown value"
+                        Just u -> pure $ SendResponse i u
                     _anyOther -> fail "Malformed JSON"
             Just e1 -> pure $ ErrorResponse i (ecode e1) (emessage e1)
 
@@ -416,6 +465,30 @@ instance FromJSON RpcCall where
                     Nothing -> pure $ RpcCall v i GetOperationStatus BadParams
                 else pure $ RpcCall v i GetOperationStatus BadParams
             _anyOther -> pure $ RpcCall v i GetOperationStatus BadParams
+        SendMany -> do
+          p <- obj .: "params"
+          case p of
+            Array a ->
+              if V.length a >= 2
+                then do
+                  acc <- parseJSON $ a V.! 0
+                  x <- parseJSON $ a V.! 1
+                  case x of
+                    String _ -> do
+                      x' <- parseJSON $ a V.! 1
+                      y <- parseJSON $ a V.! 2
+                      if not (null y)
+                        then pure $ RpcCall v i SendMany (SendParams acc y x')
+                        else pure $ RpcCall v i SendMany BadParams
+                    Array _ -> do
+                      x' <- parseJSON $ a V.! 1
+                      if not (null x')
+                        then pure $
+                             RpcCall v i SendMany (SendParams acc x' Full)
+                        else pure $ RpcCall v i SendMany BadParams
+                    _anyOther -> pure $ RpcCall v i SendMany BadParams
+                else pure $ RpcCall v i SendMany BadParams
+            _anyOther -> pure $ RpcCall v i SendMany BadParams
 
 type ZenithRPC
   = "status" :> Get '[ JSON] Value :<|> BasicAuth "zenith-realm" Bool :> ReqBody
@@ -573,27 +646,35 @@ zenithServer state = getinfo :<|> handleRPC
           case parameters req of
             NameParams t -> do
               let dbPath = w_dbPath state
-              sP <- liftIO generateWalletSeedPhrase
               pool <- liftIO $ runNoLoggingT $ initPool dbPath
-              r <-
+              syncChk <- liftIO $ isSyncing pool
-                liftIO $
+              if syncChk
-                saveWallet pool $
+                then return $
-                ZcashWallet
+                     ErrorResponse
-                  t
+                       (callId req)
-                  (ZcashNetDB $ w_network state)
+                       (-32012)
-                  (PhraseDB sP)
+                       "The Zenith server is syncing, please try again later."
-                  (w_startBlock state)
+                else do
-                  0
+                  sP <- liftIO generateWalletSeedPhrase
-              case r of
+                  r <-
-                Nothing ->
+                    liftIO $
-                  return $
+                    saveWallet pool $
-                  ErrorResponse
+                    ZcashWallet
-                    (callId req)
+                      t
-                    (-32007)
+                      (ZcashNetDB $ w_network state)
-                    "Entity with that name already exists."
+                      (PhraseDB sP)
-                Just r' ->
+                      (w_startBlock state)
-                  return $
+                      0
-                  NewItemResponse (callId req) $ fromSqlKey $ entityKey r'
+                  case r of
+                    Nothing ->
+                      return $
+                      ErrorResponse
+                        (callId req)
+                        (-32007)
+                        "Entity with that name already exists."
+                    Just r' ->
+                      return $
+                      NewItemResponse (callId req) $ fromSqlKey $ entityKey r'
             _anyOtherParams ->
               return $ ErrorResponse (callId req) (-32602) "Invalid params"
         GetNewAccount ->
@@ -601,34 +682,45 @@ zenithServer state = getinfo :<|> handleRPC
             NameIdParams t i -> do
               let dbPath = w_dbPath state
               pool <- liftIO $ runNoLoggingT $ initPool dbPath
-              w <- liftIO $ walletExists pool i
+              syncChk <- liftIO $ isSyncing pool
-              case w of
+              if syncChk
-                Just w' -> do
+                then return $
-                  aIdx <- liftIO $ getMaxAccount pool $ entityKey w'
+                     ErrorResponse
-                  nAcc <-
+                       (callId req)
-                    liftIO
+                       (-32012)
-                      (try $ createZcashAccount t (aIdx + 1) w' :: IO
+                       "The Zenith server is syncing, please try again later."
-                         (Either IOError ZcashAccount))
+                else do
-                  case nAcc of
+                  w <- liftIO $ walletExists pool i
-                    Left e ->
+                  case w of
+                    Just w' -> do
+                      aIdx <- liftIO $ getMaxAccount pool $ entityKey w'
+                      nAcc <-
+                        liftIO
+                          (try $ createZcashAccount t (aIdx + 1) w' :: IO
+                             (Either IOError ZcashAccount))
+                      case nAcc of
+                        Left e ->
+                          return $
+                          ErrorResponse (callId req) (-32010) $ T.pack $ show e
+                        Right nAcc' -> do
+                          r <- liftIO $ saveAccount pool nAcc'
+                          case r of
+                            Nothing ->
+                              return $
+                              ErrorResponse
+                                (callId req)
+                                (-32007)
+                                "Entity with that name already exists."
+                            Just x ->
+                              return $
+                              NewItemResponse (callId req) $
+                              fromSqlKey $ entityKey x
+                    Nothing ->
                       return $
-                      ErrorResponse (callId req) (-32010) $ T.pack $ show e
+                      ErrorResponse
-                    Right nAcc' -> do
+                        (callId req)
-                      r <- liftIO $ saveAccount pool nAcc'
+                        (-32008)
-                      case r of
+                        "Wallet does not exist."
-                        Nothing ->
-                          return $
-                          ErrorResponse
-                            (callId req)
-                            (-32007)
-                            "Entity with that name already exists."
-                        Just x ->
-                          return $
-                          NewItemResponse (callId req) $
-                          fromSqlKey $ entityKey x
-                Nothing ->
-                  return $
-                  ErrorResponse (callId req) (-32008) "Wallet does not exist."
             _anyOtherParams ->
               return $ ErrorResponse (callId req) (-32602) "Invalid params"
         GetNewAddress ->
@@ -637,35 +729,49 @@ zenithServer state = getinfo :<|> handleRPC
               let dbPath = w_dbPath state
               let net = w_network state
               pool <- liftIO $ runNoLoggingT $ initPool dbPath
-              acc <- liftIO $ getAccountById pool $ toSqlKey $ fromIntegral i
+              syncChk <- liftIO $ isSyncing pool
-              case acc of
+              if syncChk
-                Just acc' -> do
+                then return $
-                  maxAddr <-
+                     ErrorResponse
-                    liftIO $ getMaxAddress pool (entityKey acc') External
+                       (callId req)
-                  newAddr <-
+                       (-32012)
-                    liftIO $
+                       "The Zenith server is syncing, please try again later."
-                    createCustomWalletAddress
+                else do
-                      n
+                  acc <-
-                      (maxAddr + 1)
+                    liftIO $ getAccountById pool $ toSqlKey $ fromIntegral i
-                      net
+                  case acc of
-                      External
+                    Just acc' -> do
-                      acc'
+                      maxAddr <-
-                      s
+                        liftIO $ getMaxAddress pool (entityKey acc') External
-                      t
+                      newAddr <-
-                  dbAddr <- liftIO $ saveAddress pool newAddr
+                        liftIO $
-                  case dbAddr of
+                        createCustomWalletAddress
-                    Just nAddr -> do
+                          n
-                      return $
+                          (maxAddr + 1)
-                        NewAddrResponse (callId req) (toZcashAddressAPI nAddr)
+                          net
+                          External
+                          acc'
+                          s
+                          t
+                      dbAddr <- liftIO $ saveAddress pool newAddr
+                      case dbAddr of
+                        Just nAddr -> do
+                          return $
+                            NewAddrResponse
+                              (callId req)
+                              (toZcashAddressAPI nAddr)
+                        Nothing ->
+                          return $
+                          ErrorResponse
+                            (callId req)
+                            (-32007)
+                            "Entity with that name already exists."
                     Nothing ->
                       return $
                       ErrorResponse
                         (callId req)
-                        (-32007)
+                        (-32006)
-                        "Entity with that name already exists."
+                        "Account does not exist."
-                Nothing ->
-                  return $
-                  ErrorResponse (callId req) (-32006) "Account does not exist."
             _anyOtherParams ->
               return $ ErrorResponse (callId req) (-32602) "Invalid params"
         GetOperationStatus ->
@@ -682,6 +788,89 @@ zenithServer state = getinfo :<|> handleRPC
                   ErrorResponse (callId req) (-32009) "Operation ID not found"
             _anyOtherParams ->
               return $ ErrorResponse (callId req) (-32602) "Invalid params"
+        SendMany ->
+          case parameters req of
+            SendParams a ns p -> do
+              let dbPath = w_dbPath state
+              let zHost = w_host state
+              let zPort = w_port state
+              let znet = w_network state
+              pool <- liftIO $ runNoLoggingT $ initPool dbPath
+              syncChk <- liftIO $ isSyncing pool
+              if syncChk
+                then return $
+                     ErrorResponse
+                       (callId req)
+                       (-32012)
+                       "The Zenith server is syncing, please try again later."
+                else do
+                  opid <- liftIO nextRandom
+                  startTime <- liftIO getCurrentTime
+                  opkey <-
+                    liftIO $
+                    saveOperation pool $
+                    Operation
+                      (ZenithUuid opid)
+                      startTime
+                      Nothing
+                      Processing
+                      Nothing
+                  case opkey of
+                    Nothing ->
+                      return $
+                      ErrorResponse (callId req) (-32010) "Internal Error"
+                    Just opkey' -> do
+                      acc <-
+                        liftIO $ getAccountById pool $ toSqlKey $ fromIntegral a
+                      case acc of
+                        Just acc' -> do
+                          bl <-
+                            liftIO $
+                            getLastSyncBlock
+                              pool
+                              (zcashAccountWalletId $ entityVal acc')
+                          _ <-
+                            liftIO $
+                            forkIO $ do
+                              res <-
+                                liftIO $
+                                runNoLoggingT $
+                                prepareTxV2
+                                  pool
+                                  zHost
+                                  zPort
+                                  znet
+                                  (entityKey acc')
+                                  bl
+                                  ns
+                                  p
+                              case res of
+                                Left e ->
+                                  finalizeOperation pool opkey' Failed $
+                                  T.pack $ show e
+                                Right rawTx -> do
+                                  zebraRes <-
+                                    makeZebraCall
+                                      zHost
+                                      zPort
+                                      "sendrawtransaction"
+                                      [Data.Aeson.String $ H.toText rawTx]
+                                  case zebraRes of
+                                    Left e1 ->
+                                      finalizeOperation pool opkey' Failed $
+                                      T.pack $ show e1
+                                    Right txId ->
+                                      finalizeOperation pool opkey' Successful $
+                                      "Tx ID: " <> H.toText txId
+                          return $ SendResponse (callId req) opid
+                        Nothing ->
+                          return $
+                          ErrorResponse
+                            (callId req)
+                            (-32006)
+                            "Account does not exist."
+            _anyOtherParams ->
+              return $ ErrorResponse (callId req) (-32602) "Invalid params"
 
 authenticate :: Config -> BasicAuthCheck Bool
 authenticate config = BasicAuthCheck check
@@ -694,3 +883,71 @@ authenticate config = BasicAuthCheck check
 packRpcResponse :: ToJSON a => T.Text -> a -> Value
 packRpcResponse i x =
   object ["jsonrpc" .= ("2.0" :: String), "id" .= i, "result" .= x]
+
+scanZebra :: T.Text -> T.Text -> Int -> ZcashNet -> IO ()
+scanZebra dbPath zHost zPort net = do
+  bStatus <- checkBlockChain zHost zPort
+  pool <- runNoLoggingT $ initPool dbPath
+  b <- getMinBirthdayHeight pool $ ZcashNetDB net
+  dbBlock <- getMaxBlock pool $ ZcashNetDB net
+  chkBlock <- checkIntegrity dbPath zHost zPort net dbBlock 1
+  syncChk <- isSyncing pool
+  unless syncChk $ do
+    let sb =
+          if chkBlock == dbBlock
+            then max dbBlock b
+            else max chkBlock b
+    unless (chkBlock == dbBlock || chkBlock == 1) $
+      runNoLoggingT $ rewindWalletData pool sb $ ZcashNetDB net
+    unless (sb > zgb_blocks bStatus || sb < 1) $ do
+      let bList = [(sb + 1) .. (zgb_blocks bStatus)]
+      unless (null bList) $ do
+        _ <- startSync pool
+        mapM_ (processBlock pool) bList
+        confUp <- try $ updateConfs zHost zPort pool :: IO (Either IOError ())
+        case confUp of
+          Left _e0 -> do
+            _ <- completeSync pool Failed
+            return ()
+          Right _ -> do
+            wals <- getWallets pool net
+            _ <-
+              runNoLoggingT $
+              updateCommitmentTrees pool zHost zPort $ ZcashNetDB net
+            runNoLoggingT $
+              mapM_
+                (syncWallet (Config dbPath zHost zPort "user" "pwd" 8080 "usd"))
+                wals
+            _ <- completeSync pool Successful
+            return ()
+  where
+    processBlock :: ConnectionPool -> Int -> IO ()
+    processBlock pool bl = do
+      r <-
+        makeZebraCall
+          zHost
+          zPort
+          "getblock"
+          [Data.Aeson.String $ T.pack (show bl), jsonNumber 1]
+      case r of
+        Left _ -> completeSync pool Failed
+        Right blk -> do
+          r2 <-
+            makeZebraCall
+              zHost
+              zPort
+              "getblock"
+              [Data.Aeson.String $ T.pack (show bl), jsonNumber 0]
+          case r2 of
+            Left _ -> completeSync pool Failed
+            Right hb -> do
+              let blockTime = getBlockTime hb
+              bi <-
+                saveBlock pool $
+                ZcashBlock
+                  (fromIntegral $ bl_height blk)
+                  (HexStringDB $ bl_hash blk)
+                  (fromIntegral $ bl_confirmations blk)
+                  blockTime
+                  (ZcashNetDB net)
+              mapM_ (processTx zHost zPort bi pool) $ bl_txs blk

src/Zenith/Scanner.hs

@@ -12,6 +12,7 @@ import Control.Monad.Logger
   , logInfoN
   , runFileLoggingT
   , runNoLoggingT
+  , runStderrLoggingT
   )
 import Data.Aeson
 import Data.HexString
@@ -31,12 +32,13 @@ import ZcashHaskell.Types
   , fromRawTBundle
   )
 import ZcashHaskell.Utils (getBlockTime, makeZebraCall, readZebraTransaction)
-import Zenith.Core (checkBlockChain, syncWallet)
+import Zenith.Core (checkBlockChain, syncWallet, updateCommitmentTrees)
 import Zenith.DB
   ( ZcashBlock(..)
   , ZcashBlockId
   , clearWalletData
   , clearWalletTransactions
+  , completeSync
   , getBlock
   , getMaxBlock
   , getMinBirthdayHeight
@@ -47,9 +49,16 @@ import Zenith.DB
   , saveBlock
   , saveConfs
   , saveTransaction
+  , startSync
   , updateWalletSync
   , upgradeQrTable
   )
+import Zenith.Types
+  ( Config(..)
+  , HexStringDB(..)
+  , ZcashNetDB(..)
+  , ZenithStatus(..)
+  )
 import Zenith.Types (Config(..), HexStringDB(..), ZcashNetDB(..))
 import Zenith.Utils (jsonNumber)
 
@@ -74,8 +83,9 @@ rescanZebra host port dbFilePath = do
       upgradeQrTable pool1
       clearWalletTransactions pool1
       clearWalletData pool1
+      _ <- startSync pool1
       dbBlock <- getMaxBlock pool1 znet
-      b <- liftIO $ getMinBirthdayHeight pool1
+      b <- liftIO $ getMinBirthdayHeight pool1 znet
       let sb = max dbBlock b
       if sb > zgb_blocks bStatus || sb < 1
         then liftIO $ throwIO $ userError "Invalid starting block for scan"
@@ -99,6 +109,8 @@ rescanZebra host port dbFilePath = do
                 {-mapM_ (processBlock host port pool2 pg2 znet) bl2 `concurrently_`-}
                 {-mapM_ (processBlock host port pool3 pg3 znet) bl3-}
               print "Please wait..."
+          _ <- completeSync pool1 Successful
+          _ <- runNoLoggingT $ updateCommitmentTrees pool1 host port znet
           print "Rescan complete"
 
 -- | Function to process a raw block and extract the transaction information
@@ -119,7 +131,9 @@ processBlock host port pool pg net b = do
       "getblock"
       [Data.Aeson.String $ T.pack $ show b, jsonNumber 1]
   case r of
-    Left e -> liftIO $ throwIO $ userError e
+    Left e -> do
+      _ <- completeSync pool Failed
+      liftIO $ throwIO $ userError e
     Right blk -> do
       r2 <-
         liftIO $
@@ -129,7 +143,9 @@ processBlock host port pool pg net b = do
           "getblock"
           [Data.Aeson.String $ T.pack $ show b, jsonNumber 0]
       case r2 of
-        Left e2 -> liftIO $ throwIO $ userError e2
+        Left e2 -> do
+          _ <- completeSync pool Failed
+          liftIO $ throwIO $ userError e2
         Right hb -> do
           let blockTime = getBlockTime hb
           bi <-
@@ -160,7 +176,9 @@ processTx host port bt pool t = do
       "getrawtransaction"
       [Data.Aeson.String $ toText t, jsonNumber 1]
   case r of
-    Left e -> liftIO $ throwIO $ userError e
+    Left e -> do
+      _ <- completeSync pool Failed
+      liftIO $ throwIO $ userError e
     Right rawTx -> do
       case readZebraTransaction (ztr_hex rawTx) of
         Nothing -> return ()
@@ -223,7 +241,7 @@ clearSync config = do
           w <- getWallets pool $ zgb_net chainInfo
           liftIO $ mapM_ (updateWalletSync pool 0 . entityKey) w
           w' <- liftIO $ getWallets pool $ zgb_net chainInfo
-          r <- runFileLoggingT "zenith.log" $ mapM (syncWallet config) w'
+          r <- runNoLoggingT $ mapM (syncWallet config) w'
           liftIO $ print r
 
 -- | Detect chain re-orgs
@@ -231,10 +249,11 @@ checkIntegrity ::
      T.Text -- ^ Database path
   -> T.Text -- ^ Zebra host
   -> Int -- ^ Zebra port
+  -> ZcashNet -- ^ the network to scan
   -> Int -- ^ The block to start the check
   -> Int -- ^ depth
   -> IO Int
-checkIntegrity dbP zHost zPort b d =
+checkIntegrity dbP zHost zPort znet b d =
   if b < 1
     then return 1
     else do
@@ -248,10 +267,10 @@ checkIntegrity dbP zHost zPort b d =
         Left e -> throwIO $ userError e
         Right blk -> do
           pool <- runNoLoggingT $ initPool dbP
-          dbBlk <- getBlock pool b
+          dbBlk <- getBlock pool b $ ZcashNetDB znet
           case dbBlk of
-            Nothing -> throwIO $ userError "Block mismatch, rescan needed"
+            Nothing -> return 1
             Just dbBlk' ->
               if bl_hash blk == getHex (zcashBlockHash $ entityVal dbBlk')
                 then return b
-                else checkIntegrity dbP zHost zPort (b - 5 * d) (d + 1)
+                else checkIntegrity dbP zHost zPort znet (b - 5 * d) (d + 1)

src/Zenith/Tree.hs

@@ -0,0 +1,400 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveAnyClass #-}
+{-# LANGUAGE DerivingVia #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Zenith.Tree where
+
+import Codec.Borsh
+import Control.Monad.Logger (NoLoggingT, logDebugN)
+import Data.HexString
+import Data.Int (Int32, Int64, Int8)
+import Data.Maybe (fromJust, isNothing)
+import qualified Data.Text as T
+import qualified GHC.Generics as GHC
+import qualified Generics.SOP as SOP
+import ZcashHaskell.Orchard (combineOrchardNodes, getOrchardNodeValue)
+import ZcashHaskell.Sapling (combineSaplingNodes, getSaplingNodeValue)
+import ZcashHaskell.Types (MerklePath(..), OrchardTree(..), SaplingTree(..))
+
+type Level = Int8
+
+maxLevel :: Level
+maxLevel = 32
+
+type Position = Int32
+
+class Monoid v =>
+      Measured a v
+  where
+  measure :: a -> Position -> Int64 -> v
+
+class Node v where
+  getLevel :: v -> Level
+  getHash :: v -> HexString
+  getPosition :: v -> Position
+  getIndex :: v -> Int64
+  isFull :: v -> Bool
+  isMarked :: v -> Bool
+  mkNode :: Level -> Position -> HexString -> v
+
+type OrchardCommitment = HexString
+
+instance Measured OrchardCommitment OrchardNode where
+  measure oc p i =
+    case getOrchardNodeValue (hexBytes oc) of
+      Nothing -> OrchardNode 0 (hexString "00") 0 True 0 False
+      Just val -> OrchardNode p val 0 True i False
+
+type SaplingCommitment = HexString
+
+instance Measured SaplingCommitment SaplingNode where
+  measure sc p i =
+    case getSaplingNodeValue (hexBytes sc) of
+      Nothing -> SaplingNode 0 (hexString "00") 0 True 0 False
+      Just val -> SaplingNode p val 0 True i False
+
+data Tree v
+  = EmptyLeaf
+  | Leaf !v
+  | PrunedBranch !v
+  | Branch !v !(Tree v) !(Tree v)
+  | InvalidTree
+  deriving stock (Eq, GHC.Generic)
+  deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+  deriving (BorshSize, ToBorsh, FromBorsh) via AsEnum (Tree v)
+
+instance (Node v, Show v) => Show (Tree v) where
+  show EmptyLeaf = "()"
+  show (Leaf v) = "(" ++ show v ++ ")"
+  show (PrunedBranch v) = "{" ++ show v ++ "}"
+  show (Branch s x y) =
+    "<" ++ show (getHash s) ++ ">\n" ++ show x ++ "\n" ++ show y
+  show InvalidTree = "InvalidTree"
+
+instance (Monoid v, Node v) => Semigroup (Tree v) where
+  (<>) InvalidTree _ = InvalidTree
+  (<>) _ InvalidTree = InvalidTree
+  (<>) EmptyLeaf EmptyLeaf = PrunedBranch $ value $ branch EmptyLeaf EmptyLeaf
+  (<>) EmptyLeaf x = x
+  (<>) (Leaf x) EmptyLeaf = branch (Leaf x) EmptyLeaf
+  (<>) (Leaf x) (Leaf y) = branch (Leaf x) (Leaf y)
+  (<>) (Leaf _) Branch {} = InvalidTree
+  (<>) (Leaf _) (PrunedBranch _) = InvalidTree
+  (<>) (PrunedBranch x) EmptyLeaf = PrunedBranch $ x <> x
+  (<>) (PrunedBranch x) (Leaf y) =
+    if isFull x
+      then InvalidTree
+      else mkSubTree (getLevel x) (Leaf y)
+  (<>) (PrunedBranch x) (Branch s t u) =
+    if getLevel x == getLevel s
+      then branch (PrunedBranch x) (Branch s t u)
+      else InvalidTree
+  (<>) (PrunedBranch x) (PrunedBranch y) = PrunedBranch $ x <> y
+  (<>) (Branch s x y) EmptyLeaf =
+    branch (Branch s x y) $ getEmptyRoot (getLevel s)
+  (<>) (Branch s x y) (PrunedBranch w)
+    | getLevel s == getLevel w = branch (Branch s x y) (PrunedBranch w)
+    | otherwise = InvalidTree
+  (<>) (Branch s x y) (Leaf w)
+    | isFull s = InvalidTree
+    | isFull (value x) = branch x (y <> Leaf w)
+    | otherwise = branch (x <> Leaf w) y
+  (<>) (Branch s x y) (Branch s1 x1 y1)
+    | getLevel s == getLevel s1 = branch (Branch s x y) (Branch s1 x1 y1)
+    | otherwise = InvalidTree
+
+value :: Monoid v => Tree v -> v
+value EmptyLeaf = mempty
+value (Leaf v) = v
+value (PrunedBranch v) = v
+value (Branch v _ _) = v
+value InvalidTree = mempty
+
+branch :: Monoid v => Tree v -> Tree v -> Tree v
+branch x y = Branch (value x <> value y) x y
+
+leaf :: Measured a v => a -> Int32 -> Int64 -> Tree v
+leaf a p i = Leaf (measure a p i)
+
+prunedBranch :: Monoid v => Node v => Level -> Position -> HexString -> Tree v
+prunedBranch level pos val = PrunedBranch $ mkNode level pos val
+
+root :: Monoid v => Node v => Tree v -> Tree v
+root tree =
+  if getLevel (value tree) == maxLevel
+    then tree
+    else mkSubTree maxLevel tree
+
+getEmptyRoot :: Monoid v => Node v => Level -> Tree v
+getEmptyRoot level = iterate (\x -> x <> x) EmptyLeaf !! fromIntegral level
+
+append :: Monoid v => Measured a v => Node v => Tree v -> (a, Int64) -> Tree v
+append tree (n, i) = tree <> leaf n p i
+  where
+    p = 1 + getPosition (value tree)
+
+mkSubTree :: Node v => Monoid v => Level -> Tree v -> Tree v
+mkSubTree level t =
+  if getLevel (value subtree) == level
+    then subtree
+    else mkSubTree level subtree
+  where
+    subtree = t <> EmptyLeaf
+
+path :: Monoid v => Node v => Position -> Tree v -> Maybe MerklePath
+path pos (Branch s x y) =
+  if length (collectPath (Branch s x y)) /= 32
+    then Nothing
+    else Just $ MerklePath pos $ collectPath (Branch s x y)
+  where
+    collectPath :: Monoid v => Node v => Tree v -> [HexString]
+    collectPath EmptyLeaf = []
+    collectPath Leaf {} = []
+    collectPath PrunedBranch {} = []
+    collectPath InvalidTree = []
+    collectPath (Branch _ j k)
+      | getPosition (value k) /= 0 && getPosition (value k) < pos = []
+      | getPosition (value j) < pos = collectPath k <> [getHash (value j)]
+      | getPosition (value j) >= pos = collectPath j <> [getHash (value k)]
+      | otherwise = []
+path _ _ = Nothing
+
+nullPath :: MerklePath
+nullPath = MerklePath 0 []
+
+getNotePosition :: Monoid v => Node v => Tree v -> Int64 -> Maybe Position
+getNotePosition (Leaf x) i
+  | getIndex x == i = Just $ getPosition x
+  | otherwise = Nothing
+getNotePosition (Branch _ x y) i
+  | getIndex (value x) >= i = getNotePosition x i
+  | getIndex (value y) >= i = getNotePosition y i
+  | otherwise = Nothing
+getNotePosition _ _ = Nothing
+
+truncateTree :: Monoid v => Node v => Tree v -> Int64 -> NoLoggingT IO (Tree v)
+truncateTree (Branch s x y) i
+  | getLevel s == 1 && getIndex (value x) == i = do
+    logDebugN $ T.pack $ show (getLevel s) ++ " Trunc to left leaf"
+    return $ branch x EmptyLeaf
+  | getLevel s == 1 && getIndex (value y) == i = do
+    logDebugN $ T.pack $ show (getLevel s) ++ " Trunc to right leaf"
+    return $ branch x y
+  | getIndex (value x) >= i = do
+    logDebugN $
+      T.pack $
+      show (getLevel s) ++
+      ": " ++ show i ++ " left i: " ++ show (getIndex (value x))
+    l <- truncateTree x i
+    return $ branch (l) (getEmptyRoot (getLevel (value x)))
+  | getIndex (value y) /= 0 && getIndex (value y) >= i = do
+    logDebugN $
+      T.pack $
+      show (getLevel s) ++
+      ": " ++ show i ++ " right i: " ++ show (getIndex (value y))
+    r <- truncateTree y i
+    return $ branch x (r)
+  | otherwise = do
+    logDebugN $
+      T.pack $
+      show (getLevel s) ++
+      ": " ++
+      show (getIndex (value x)) ++ " catchall " ++ show (getIndex (value y))
+    return InvalidTree
+truncateTree x _ = return x
+
+countLeaves :: Node v => Tree v -> Int64
+countLeaves (Branch s x y) =
+  if isFull s
+    then 2 ^ getLevel s
+    else countLeaves x + countLeaves y
+countLeaves (PrunedBranch x) =
+  if isFull x
+    then 2 ^ getLevel x
+    else 0
+countLeaves (Leaf _) = 1
+countLeaves EmptyLeaf = 0
+countLeaves InvalidTree = 0
+
+batchAppend ::
+     Measured a v
+  => Node v => Monoid v => Tree v -> [(Int32, (a, Int64))] -> Tree v
+batchAppend x [] = x
+batchAppend (Branch s x y) notes
+  | isFull s = InvalidTree
+  | isFull (value x) = branch x (batchAppend y notes)
+  | otherwise =
+    branch
+      (batchAppend x (take leftSide notes))
+      (batchAppend y (drop leftSide notes))
+  where
+    leftSide = fromIntegral $ 2 ^ getLevel (value x) - countLeaves x
+batchAppend (PrunedBranch k) notes
+  | isFull k = InvalidTree
+  | otherwise =
+    branch
+      (batchAppend (getEmptyRoot (getLevel k - 1)) (take leftSide notes))
+      (batchAppend (getEmptyRoot (getLevel k - 1)) (drop leftSide notes))
+  where
+    leftSide = fromIntegral $ 2 ^ (getLevel k - 1)
+batchAppend EmptyLeaf notes
+  | length notes == 1 =
+    leaf (fst $ snd $ head notes) (fst $ head notes) (snd $ snd $ head notes)
+  | otherwise = InvalidTree
+batchAppend _ notes = InvalidTree
+
+data SaplingNode = SaplingNode
+  { sn_position :: !Position
+  , sn_value :: !HexString
+  , sn_level :: !Level
+  , sn_full :: !Bool
+  , sn_index :: !Int64
+  , sn_mark :: !Bool
+  } deriving stock (Eq, GHC.Generic)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct SaplingNode
+
+instance Semigroup SaplingNode where
+  (<>) x y =
+    case combineSaplingNodes (sn_level x) (sn_value x) (sn_value y) of
+      Nothing -> x
+      Just newHash ->
+        SaplingNode
+          (max (sn_position x) (sn_position y))
+          newHash
+          (1 + sn_level x)
+          (sn_full x && sn_full y)
+          (max (sn_index x) (sn_index y))
+          (sn_mark x || sn_mark y)
+
+instance Monoid SaplingNode where
+  mempty = SaplingNode 0 (hexString "00") 0 False 0 False
+  mappend = (<>)
+
+instance Node SaplingNode where
+  getLevel = sn_level
+  getHash = sn_value
+  getPosition = sn_position
+  getIndex = sn_index
+  isFull = sn_full
+  isMarked = sn_mark
+  mkNode l p v = SaplingNode p v l True 0 False
+
+instance Show SaplingNode where
+  show = show . sn_value
+
+saplingSize :: SaplingTree -> Int64
+saplingSize tree =
+  (if isNothing (st_left tree)
+     then 0
+     else 1) +
+  (if isNothing (st_right tree)
+     then 0
+     else 1) +
+  foldl
+    (\x (i, p) ->
+       case p of
+         Nothing -> x + 0
+         Just _ -> x + 2 ^ i)
+    0
+    (zip [1 ..] $ st_parents tree)
+
+mkSaplingTree :: SaplingTree -> Tree SaplingNode
+mkSaplingTree tree =
+  foldl
+    (\t (i, n) ->
+       case n of
+         Just n' -> prunedBranch i 0 n' <> t
+         Nothing -> t <> getEmptyRoot i)
+    leafRoot
+    (zip [1 ..] $ st_parents tree)
+  where
+    leafRoot =
+      case st_right tree of
+        Just r' -> leaf (fromJust $ st_left tree) (pos - 1) 0 <> leaf r' pos 0
+        Nothing -> leaf (fromJust $ st_left tree) pos 0 <> EmptyLeaf
+    pos = fromIntegral $ saplingSize tree - 1
+
+-- | Orchard 
+data OrchardNode = OrchardNode
+  { on_position :: !Position
+  , on_value :: !HexString
+  , on_level :: !Level
+  , on_full :: !Bool
+  , on_index :: !Int64
+  , on_mark :: !Bool
+  } deriving stock (Eq, GHC.Generic)
+    deriving anyclass (SOP.Generic, SOP.HasDatatypeInfo)
+    deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct OrchardNode
+
+instance Semigroup OrchardNode where
+  (<>) x y =
+    case combineOrchardNodes
+           (fromIntegral $ on_level x)
+           (on_value x)
+           (on_value y) of
+      Nothing -> x
+      Just newHash ->
+        OrchardNode
+          (max (on_position x) (on_position y))
+          newHash
+          (1 + on_level x)
+          (on_full x && on_full y)
+          (max (on_index x) (on_index y))
+          (on_mark x || on_mark y)
+
+instance Monoid OrchardNode where
+  mempty = OrchardNode 0 (hexString "00") 0 False 0 False
+  mappend = (<>)
+
+instance Node OrchardNode where
+  getLevel = on_level
+  getHash = on_value
+  getPosition = on_position
+  getIndex = on_index
+  isFull = on_full
+  isMarked = on_mark
+  mkNode l p v = OrchardNode p v l True 0 False
+
+instance Show OrchardNode where
+  show = show . on_value
+
+instance Measured OrchardNode OrchardNode where
+  measure o p i =
+    OrchardNode p (on_value o) (on_level o) (on_full o) i (on_mark o)
+
+orchardSize :: OrchardTree -> Int64
+orchardSize tree =
+  (if isNothing (ot_left tree)
+     then 0
+     else 1) +
+  (if isNothing (ot_right tree)
+     then 0
+     else 1) +
+  foldl
+    (\x (i, p) ->
+       case p of
+         Nothing -> x + 0
+         Just _ -> x + 2 ^ i)
+    0
+    (zip [1 ..] $ ot_parents tree)
+
+mkOrchardTree :: OrchardTree -> Tree OrchardNode
+mkOrchardTree tree =
+  foldl
+    (\t (i, n) ->
+       case n of
+         Just n' -> prunedBranch i 0 n' <> t
+         Nothing -> t <> getEmptyRoot i)
+    leafRoot
+    (zip [1 ..] $ ot_parents tree)
+  where
+    leafRoot =
+      case ot_right tree of
+        Just r' -> leaf (fromJust $ ot_left tree) (pos - 1) 0 <> leaf r' pos 0
+        Nothing -> leaf (fromJust $ ot_left tree) pos 0 <> EmptyLeaf
+    pos = fromIntegral $ orchardSize tree - 1

src/Zenith/Types.hs

@@ -17,19 +17,30 @@ import qualified Data.ByteString.Char8 as C
 import Data.HexString
 import Data.Int (Int64)
 import Data.Maybe (fromMaybe)
+import Data.Scientific (Scientific)
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as E
 import Data.Text.Encoding.Error (lenientDecode)
 import qualified Data.UUID as U
 import Database.Persist.TH
 import GHC.Generics
+import ZcashHaskell.Orchard (encodeUnifiedAddress, parseAddress)
+import ZcashHaskell.Sapling (encodeSaplingAddress)
+import ZcashHaskell.Transparent
+  ( encodeExchangeAddress
+  , encodeTransparentReceiver
+  )
 import ZcashHaskell.Types
-  ( OrchardSpendingKey(..)
+  ( ExchangeAddress(..)
+  , OrchardSpendingKey(..)
   , Phrase(..)
   , Rseed(..)
+  , SaplingAddress(..)
   , SaplingSpendingKey(..)
   , Scope(..)
+  , TransparentAddress(..)
   , TransparentSpendingKey
+  , ValidAddress(..)
   , ZcashNet(..)
   )
 
@@ -101,6 +112,7 @@ data Config = Config
   , c_zenithUser :: !BS.ByteString
   , c_zenithPwd :: !BS.ByteString
   , c_zenithPort :: !Int
+  , c_currencyCode :: !T.Text
   } deriving (Eq, Prelude.Show)
 
 data ZcashPool
@@ -207,9 +219,54 @@ data PrivacyPolicy
 
 $(deriveJSON defaultOptions ''PrivacyPolicy)
 
+newtype ValidAddressAPI = ValidAddressAPI
+  { getVA :: ValidAddress
+  } deriving newtype (Eq, Show)
+
+instance ToJSON ValidAddressAPI where
+  toJSON (ValidAddressAPI va) =
+    case va of
+      Unified ua -> Data.Aeson.String $ encodeUnifiedAddress ua
+      Sapling sa ->
+        maybe
+          Data.Aeson.Null
+          Data.Aeson.String
+          (encodeSaplingAddress (net_type sa) (sa_receiver sa))
+      Transparent ta ->
+        Data.Aeson.String $
+        encodeTransparentReceiver (ta_network ta) (ta_receiver ta)
+      Exchange ea ->
+        maybe
+          Data.Aeson.Null
+          Data.Aeson.String
+          (encodeExchangeAddress (ex_network ea) (ex_address ea))
+
+data ProposedNote = ProposedNote
+  { pn_addr :: !ValidAddressAPI
+  , pn_amt :: !Scientific
+  , pn_memo :: !(Maybe T.Text)
+  } deriving (Eq, Prelude.Show)
+
+instance FromJSON ProposedNote where
+  parseJSON =
+    withObject "ProposedNote" $ \obj -> do
+      a <- obj .: "address"
+      n <- obj .: "amount"
+      m <- obj .:? "memo"
+      case parseAddress (E.encodeUtf8 a) of
+        Nothing -> fail "Invalid address"
+        Just a' ->
+          if n > 0 && n < 21000000
+            then pure $ ProposedNote (ValidAddressAPI a') n m
+            else fail "Invalid amount"
+
+instance ToJSON ProposedNote where
+  toJSON (ProposedNote a n m) =
+    object ["address" .= a, "amount" .= n, "memo" .= m]
+
 data ShieldDeshieldOp
-  = Shield 
+  = Shield
-  | Deshield 
+  | Deshield
   deriving (Eq, Show, Read, Ord)
 
 -- ** `zebrad`
@@ -451,3 +508,12 @@ encodeHexText' t =
   if T.length t > 0
     then C.unpack . B64.encode $ E.encodeUtf8 t
     else C.unpack . B64.encode $ E.encodeUtf8 "Sent from Zenith"
+
+-- | Define a data structure for the parsed components
+data ZcashPaymentURI = ZcashPaymentURI
+  { uriAddress :: String
+  , uriAmount :: Maybe Double
+  , uriMemo :: T.Text
+  , uriLabel :: Maybe String
+  , uriMessage :: Maybe String
+  } deriving (Show, Eq)

src/Zenith/Utils.hs

@@ -2,37 +2,59 @@
 
 module Zenith.Utils where
 
+import Control.Exception (SomeException, try)
+import Control.Monad (when)
 import Data.Aeson
+import qualified Data.Aeson.Key as K
+import qualified Data.Aeson.KeyMap as KM
+import Data.Aeson.Types (parseMaybe)
+import qualified Data.ByteString.Base64 as B64
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.ByteString.Lazy as B
+import qualified Data.ByteString.Lazy.Char8 as BL
 import Data.Char (isAlphaNum, isSpace)
 import Data.Functor (void)
 import Data.Maybe
 import Data.Ord (clamp)
 import Data.Scientific (Scientific(..), scientific)
+import Data.Scientific (Scientific, toRealFloat)
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as E
+import qualified Data.Text.Encoding as TE
+import Network.HTTP.Simple
 import System.Directory
 import System.Process (createProcess_, shell)
+import Text.Printf (printf)
+import Text.Read (readMaybe)
 import Text.Regex.Posix
-import ZcashHaskell.Orchard (encodeUnifiedAddress, isValidUnifiedAddress, parseAddress)
+import ZcashHaskell.Orchard
+  ( encodeUnifiedAddress
+  , isValidUnifiedAddress
+  , parseAddress
+  )
 import ZcashHaskell.Sapling (decodeSaplingAddress, isValidShieldedAddress)
 import ZcashHaskell.Transparent
   ( decodeExchangeAddress
   , decodeTransparentAddress
   )
 import ZcashHaskell.Types
-  ( SaplingAddress(..)
+  ( ExchangeAddress(..)
+  , ExchangeAddress(..)
+  , SaplingAddress(..)
   , TransparentAddress(..)
   , UnifiedAddress(..)
-  , ZcashNet(..)
   , ValidAddress(..)
-  , ExchangeAddress(..)
+  , ValidAddress(..)
+  , ZcashNet(..)
   )
+import ZcashHaskell.Utils (makeZebraCall)
 import Zenith.Types
   ( AddressGroup(..)
+  , PrivacyPolicy(..)
   , UnifiedAddressDB(..)
   , ZcashAddress(..)
+  , ZcashPaymentURI(..)
   , ZcashPool(..)
-  , PrivacyPolicy(..)
   )
 
 -- | Helper function to convert numbers into JSON
@@ -47,7 +69,7 @@ displayZec s
   | abs s < 100000000 = show (fromIntegral s / 100000) ++ " mZEC"
   | otherwise = show (fromIntegral s / 100000000) ++ " ZEC "
 
--- | Helper function to display small amounts of ZEC
+-- | Helper function to display small amounts of TAZ
 displayTaz :: Integer -> String
 displayTaz s
   | abs s < 100 = show s ++ " tazs"
@@ -127,9 +149,9 @@ isRecipientValid a = do
 
 isUnifiedAddressValid :: T.Text -> Bool
 isUnifiedAddressValid ua =
-    case isValidUnifiedAddress (E.encodeUtf8 ua)  of
+  case isValidUnifiedAddress (E.encodeUtf8 ua) of
-            Just _a1 -> True
+    Just _a1 -> True
-            Nothing -> False
+    Nothing -> False
 
 isSaplingAddressValid :: T.Text -> Bool
 isSaplingAddressValid sa = isValidShieldedAddress (E.encodeUtf8 sa)
@@ -137,8 +159,8 @@ isSaplingAddressValid sa = isValidShieldedAddress (E.encodeUtf8 sa)
 isTransparentAddressValid :: T.Text -> Bool
 isTransparentAddressValid ta =
   case decodeTransparentAddress (E.encodeUtf8 ta) of
-         Just _a3 -> True
+    Just _a3 -> True
-         Nothing -> False
+    Nothing -> False
 
 isExchangeAddressValid :: T.Text -> Bool
 isExchangeAddressValid xa =
@@ -147,40 +169,44 @@ isExchangeAddressValid xa =
     Nothing -> False
 
 isRecipientValidGUI :: PrivacyPolicy -> T.Text -> Bool
-isRecipientValidGUI p a  = do
+isRecipientValidGUI p a = do
   let adr = parseAddress (E.encodeUtf8 a)
-  case p of 
+  case p of
-    Full -> case adr of  
+    Full ->
-              Just a -> 
+      case adr of
-                case a of  
+        Just a ->
-                    Unified ua -> True
+          case a of
-                    Sapling sa -> True
+            Unified ua -> True
-                    _ -> False
+            Sapling sa -> True
-              Nothing -> False
+            _ -> False
-    Medium -> case adr of 
+        Nothing -> False
-                Just a -> 
+    Medium ->
-                  case a of  
+      case adr of
-                      Unified ua -> True
+        Just a ->
-                      Sapling sa -> True
+          case a of
-                      _ -> False
+            Unified ua -> True
-                Nothing -> False
+            Sapling sa -> True
-    Low -> case adr of  
+            _ -> False
-              Just a -> 
+        Nothing -> False
-                case a of  
+    Low ->
-                    Unified ua -> True
+      case adr of
-                    Sapling sa -> True
+        Just a ->
-                    Transparent ta -> True
+          case a of
-                    _ -> False
+            Unified ua -> True
-              Nothing -> False
+            Sapling sa -> True
-    None -> case adr of  
+            Transparent ta -> True
-              Just a -> 
+            _ -> False
-                case a of  
+        Nothing -> False
-                    Transparent ta -> True
+    None ->
-                    Exchange ea -> True
+      case adr of
-                    _ -> False
+        Just a ->
-              Nothing -> False
+          case a of
+            Transparent ta -> True
+            Exchange ea -> True
+            _ -> False
+        Nothing -> False
 
-isZecAddressValid ::  T.Text -> Bool
+isZecAddressValid :: T.Text -> Bool
 isZecAddressValid a = do
   case isValidUnifiedAddress (E.encodeUtf8 a) of
     Just _a1 -> True
@@ -232,3 +258,73 @@ padWithZero n s
 isEmpty :: [a] -> Bool
 isEmpty [] = True
 isEmpty _ = False
+
+getChainTip :: T.Text -> Int -> IO Int
+getChainTip zHost zPort = do
+  r <- makeZebraCall zHost zPort "getblockcount" []
+  case r of
+    Left e1 -> pure 0
+    Right i -> pure i
+
+-- Function to fetch Zcash price from CoinGecko
+getZcashPrice :: T.Text -> IO (Maybe Double)
+getZcashPrice currency = do
+  let url =
+        "https://api.coingecko.com/api/v3/simple/price?ids=zcash&vs_currencies=" <>
+        T.unpack currency
+  response <- httpJSONEither (parseRequest_ url)
+  case getResponseBody response of
+    Right (Object obj)
+        -- Extract "zcash" object
+     -> do
+      case KM.lookup "zcash" obj of
+        Just (Object zcashObj)
+            -- Extract the currency price
+         ->
+          case KM.lookup (K.fromText (T.toLower currency)) zcashObj of
+            Just (Number price) -> return (Just (toRealFloat price))
+            _ -> return Nothing
+        _ -> return Nothing
+    _ -> return Nothing
+
+-- Parse memo result to convert it to a ByteString
+processEither :: Either String BC.ByteString -> BC.ByteString
+processEither (Right bs) = bs
+processEither (Left e) = BC.pack e -- Returns the error message
+
+-- Parse the query string into key-value pairs 
+parseQuery :: String -> [(String, String)]
+parseQuery query = map (breakOn '=') (splitOn '&' query)
+  where
+    splitOn :: Char -> String -> [String]
+    splitOn _ [] = [""]
+    splitOn delim (c:cs)
+      | c == delim = "" : rest
+      | otherwise = (c : head rest) : tail rest
+      where
+        rest = splitOn delim cs
+    breakOn :: Char -> String -> (String, String)
+    breakOn delim str = (key, drop 1 value)
+      where
+        (key, value) = span (/= delim) str
+
+-- Parse a ZIP-321 encoded string into a ZcashPayment structure
+parseZcashPayment :: String -> Either String ZcashPaymentURI
+parseZcashPayment input
+  | not (T.isPrefixOf "zcash:" (T.pack input)) =
+    Left "Invalid scheme: must start with 'zcash:'"
+  | otherwise =
+    let (addrPart, queryPart) = break (== '?') (drop 6 input)
+        queryParams = parseQuery (drop 1 queryPart)
+     in Right
+          ZcashPaymentURI
+            { uriAddress = addrPart
+            , uriAmount = lookup "amount" queryParams >>= readMaybe
+            , uriMemo =
+                case lookup "memo" queryParams of
+                  Just m ->
+                    T.pack (BC.unpack (processEither $ B64.decode $ BC.pack m))
+                  _ -> ""
+            , uriLabel = lookup "label" queryParams
+            , uriMessage = lookup "message" queryParams
+            }

test/ServerSpec.hs

@@ -7,7 +7,7 @@ import Control.Monad.Logger (runNoLoggingT)
 import Data.Aeson
 import qualified Data.ByteString as BS
 import Data.Configurator
-import Data.Maybe (fromMaybe)
+import Data.Maybe (fromJust, fromMaybe)
 import qualified Data.Text as T
 import qualified Data.Text.Encoding as E
 import Data.Time.Clock (getCurrentTime)
@@ -18,7 +18,7 @@ import Servant
 import System.Directory
 import Test.HUnit hiding (State)
 import Test.Hspec
-import ZcashHaskell.Orchard (isValidUnifiedAddress)
+import ZcashHaskell.Orchard (isValidUnifiedAddress, parseAddress)
 import ZcashHaskell.Types
   ( ZcashNet(..)
   , ZebraGetBlockChainInfo(..)
@@ -39,6 +39,9 @@ import Zenith.RPC
   )
 import Zenith.Types
   ( Config(..)
+  , PrivacyPolicy(..)
+  , ProposedNote(..)
+  , ValidAddressAPI(..)
   , ZcashAccountAPI(..)
   , ZcashAddressAPI(..)
   , ZcashWalletAPI(..)
@@ -55,7 +58,16 @@ main = do
   zebraPort <- require config "zebraPort"
   zebraHost <- require config "zebraHost"
   nodePort <- require config "nodePort"
-  let myConfig = Config dbFilePath zebraHost zebraPort nodeUser nodePwd nodePort
+  currencyCode <- require config "currencyCode"
+  let myConfig =
+        Config
+          dbFilePath
+          zebraHost
+          zebraPort
+          nodeUser
+          nodePwd
+          nodePort
+          currencyCode
   hspec $ do
     describe "RPC methods" $ do
       beforeAll_ (startAPI myConfig) $ do
@@ -572,6 +584,107 @@ main = do
                   Left e -> assertFailure e
                   Right (ErrorResponse i c m) -> c `shouldBe` (-32009)
                   Right _ -> assertFailure "unexpected response"
+        describe "Send tx" $ do
+          describe "sendmany" $ do
+            it "bad credentials" $ do
+              res <-
+                makeZenithCall
+                  "127.0.0.1"
+                  nodePort
+                  "baduser"
+                  "idontknow"
+                  SendMany
+                  BlankParams
+              res `shouldBe` Left "Invalid credentials"
+            describe "correct credentials" $ do
+              it "invalid account" $ do
+                let uaRead =
+                      parseAddress
+                        "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
+                res <-
+                  makeZenithCall
+                    "127.0.0.1"
+                    nodePort
+                    nodeUser
+                    nodePwd
+                    SendMany
+                    (SendParams
+                       17
+                       [ ProposedNote
+                           (ValidAddressAPI $ fromJust uaRead)
+                           0.005
+                           (Just "A cool memo")
+                       ]
+                       Full)
+                case res of
+                  Left e -> assertFailure e
+                  Right (ErrorResponse i c m) -> c `shouldBe` (-32006)
+              it "valid account, empty notes" $ do
+                let uaRead =
+                      parseAddress
+                        "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
+                res <-
+                  makeZenithCall
+                    "127.0.0.1"
+                    nodePort
+                    nodeUser
+                    nodePwd
+                    SendMany
+                    (SendParams 1 [] Full)
+                case res of
+                  Left e -> assertFailure e
+                  Right (ErrorResponse i c m) -> c `shouldBe` (-32602)
+              it "valid account, single output" $ do
+                let uaRead =
+                      parseAddress
+                        "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
+                res <-
+                  makeZenithCall
+                    "127.0.0.1"
+                    nodePort
+                    nodeUser
+                    nodePwd
+                    SendMany
+                    (SendParams
+                       1
+                       [ ProposedNote
+                           (ValidAddressAPI $ fromJust uaRead)
+                           5.0
+                           (Just "A cool memo")
+                       ]
+                       Full)
+                case res of
+                  Left e -> assertFailure e
+                  Right (SendResponse i o) -> o `shouldNotBe` U.nil
+              it "valid account, multiple outputs" $ do
+                let uaRead =
+                      parseAddress
+                        "utest1dl54utt6prjj5e0dnlknwumnxq9hycdjpkfr0sy6e6h522remqee8axe9zax0wsjrwpj76v555pdhvj9rnargpfyycs0vpkapq98xcdhem99gc4wchzn0ggepq3y6nz3a9sscwgqxgsh9vzhcad402y3x9szfregck5gslkya3c79d86xx0l33tpk8gnn7ew9vw37w43zh22u8dgdax"
+                let uaRead2 =
+                      parseAddress
+                        "ztestsapling136jp8z89v2jh6kqd5rs4dtvlxym90m43svzdwzxaplyvc5ttzppytpvx80ncllcsqzpmukxjl3y"
+                res <-
+                  makeZenithCall
+                    "127.0.0.1"
+                    nodePort
+                    nodeUser
+                    nodePwd
+                    SendMany
+                    (SendParams
+                       1
+                       [ ProposedNote
+                           (ValidAddressAPI $ fromJust uaRead)
+                           5.0
+                           (Just "A cool memo")
+                       , ProposedNote
+                           (ValidAddressAPI $ fromJust uaRead2)
+                           1.0
+                           (Just "Not so cool memo")
+                       ]
+                       Full)
+                case res of
+                  Left e -> assertFailure e
+                  Right (SendResponse i o) -> o `shouldNotBe` U.nil
 
 startAPI :: Config -> IO ()
 startAPI config = do

zcash-haskell

@@ -1 +1 @@
-Subproject commit 003293cc3f978c146824d0695c5c458cf2cc9bb5
+Subproject commit cfa862ec9495e810e7296fa6fe724b46dbe0ee52

zenith-openrpc.json

@@ -132,6 +132,7 @@
       ],
       "errors": [
         { "$ref": "#/components/errors/ZebraNotAvailable" },
+        { "$ref": "#/components/errors/ZenithBusy" },
         { "$ref": "#/components/errors/DuplicateName" }
       ]
     },
@@ -228,6 +229,7 @@
       "errors": [
         { "$ref": "#/components/errors/ZebraNotAvailable" },
         { "$ref": "#/components/errors/DuplicateName" },
+        { "$ref": "#/components/errors/ZenithBusy" },
         { "$ref": "#/components/errors/InvalidWallet" }
       ]
     },
@@ -444,6 +446,7 @@
       ],
       "errors": [
         { "$ref": "#/components/errors/InvalidAccount" },
+        { "$ref": "#/components/errors/ZenithBusy" },
         { "$ref": "#/components/errors/DuplicateName" }
       ]
     },
@@ -593,10 +596,11 @@
     {
       "name": "sendmany",
       "summary": "Send transaction(s)",
-      "description": "Send one or more transactions by specifying the source account, the recipient address, the amount, the shielded memo (optional) and the privacy policy (optional).",
+      "description": "Send one transaction by specifying the source account, the privacy policy (optional, default 'Full') and an array of proposed outputs. Each output needs a recipient address, an amount and an optional shielded memo.",
-      "tags": [{"$ref": "#/components/tags/draft"},{"$ref": "#/components/tags/wip"}],
+      "tags": [],
       "params": [
         { "$ref": "#/components/contentDescriptors/AccountId"},
+        { "$ref": "#/components/contentDescriptors/PrivacyPolicy"},
         { "$ref": "#/components/contentDescriptors/TxRequestArray"}
       ],
       "paramStructure": "by-position",
@@ -610,14 +614,19 @@
       "examples": [
         {
           "name": "Send a transaction",
-          "summary": "Send one transaction",
+          "summary": "Send a transaction",
-          "description": "Send a single transaction",
+          "description": "Send a transaction with one output",
           "params": [
             {
               "name": "Account index", 
               "summary": "The index for the account to use",
               "value": "1"
             },
+            {
+              "name": "Privacy Policy",
+              "summary": "The selected privacy policy",
+              "value": "Full"
+            },
             {
               "name": "Transaction request",
               "summary": "The transaction to attempt",
@@ -640,7 +649,7 @@
       ],
       "errors": [
         { "$ref": "#/components/errors/ZebraNotAvailable" },
-        { "$ref": "#/components/errors/InvalidRecipient" },
+        { "$ref": "#/components/errors/ZenithBusy" },
         { "$ref": "#/components/errors/InvalidAccount" }
       ]
     },
@@ -736,6 +745,16 @@
           "type": "array",
           "items": { "$ref": "#/components/schemas/TxRequest"}
         }
+      },
+      "PrivacyPolicy": { 
+        "name": "Privacy Policy",
+        "summary": "The chosen privacy policy to use for the transaction",
+        "description": "The privacy policy to use for the transaction. `Full` policy allows shielded funds to be transferred within their shielded pools. `Medium` policy allows shielded funds to cross shielded pools. `Low` allows deshielding transactions into transparent receivers but not to exchange addresses. `None` allows for transparent funds to be spent to transparent addresses and exchange addresses.",
+        "required": false,
+        "schema": {
+          "type": "string", 
+          "enum": ["None", "Low", "Medium", "Full"]
+        }
       }
     },
 	  "schemas": {
@@ -814,8 +833,7 @@
         "properties": {
           "address": { "type": "string", "description": "Recipient's address (unified, Sapling or transparent)" },
           "amount": { "type": "number", "description": "The amount to send in ZEC"},
-          "memo": { "type": "string", "description": "The shielded memo to include, if applicable"},
+          "memo": { "type": "string", "description": "The shielded memo to include, if applicable"}
-          "privacy": { "type": "string", "enum": ["None", "Low", "Medium", "Full"], "description": "The privacy policy to use for the transaction. `Full` policy allows shielded funds to be transferred within their shielded pools. `Medium` policy allows shielded funds to cross shielded pools and deshielding transactions. `Low` allows to spend transparent funds into shielded pools. `None` allows for transparent funds to be spent to transparent addresses."}
         }
       }
     },
@@ -872,6 +890,10 @@
       "InvalidRecipient": {
         "code": -32011,
         "message": "The provided recipient address is not valid."
+      },
+      "ZenithBusy": {
+        "code": -32012,
+        "message": "The Zenith server is syncing, please try again later."
       }
     }
   }

zenith.cabal

@@ -36,6 +36,7 @@ library
     Zenith.Zcashd
     Zenith.Scanner
     Zenith.RPC
+    Zenith.Tree
   hs-source-dirs:
     src
   build-depends:
@@ -49,6 +50,7 @@ library
     , base >=4.12 && <5
     , base64-bytestring
     , binary
+    , borsh
     , brick
     , bytestring
     , configurator
@@ -58,6 +60,7 @@ library
     , exceptions
     , filepath
     , ghc
+    , generics-sop
     , haskoin-core
     , hexstring
     , http-client
@@ -93,6 +96,7 @@ library
     , vty-crossplatform
     , word-wrap
     , zcash-haskell
+    , unordered-containers
   --pkgconfig-depends: rustzcash_wrapper
   default-language: Haskell2010
 
@@ -124,9 +128,12 @@ executable zenithserver
   build-depends:
       base >=4.12 && <5
     , configurator
+    , monad-logger
     , wai-extra
     , warp
     , servant-server
+    , text
+    , unix
     , zcash-haskell
     , zenith
   pkgconfig-depends: rustzcash_wrapper
@@ -141,8 +148,11 @@ test-suite zenith-tests
   build-depends:
       base >=4.12 && <5
     , bytestring
+    , aeson
     , configurator
     , monad-logger
+    , borsh
+    , aeson
     , data-default
     , sort
     , text

zenith.cfg

@@ -1,5 +1,38 @@
+# 
+# Zenith Configuration File
+# 
+# -------------------------------------------------------------
+# nodeUser - 
+# -------------------------------------------------------------
 nodeUser = "user"
+# -------------------------------------------------------------
+# nodePwd -
 nodePwd = "superSecret"
-dbFilePath = "zenith.db"
+# -------------------------------------------------------------
+# dbFileName  - contains the SQLite database name used for
+#			    keeping all Zenith's data
+#               default = zenith.db 
+#
+dbFileName = "zenith.db"
+# -------------------------------------------------------------
+# zebraHost   - Zebra IP 
+#				Default - "127.0.0.1" 
 zebraHost = "127.0.0.1"
+# -------------------------------------------------------------
+# zebraPort   - Port used for access Zebra API endpoints
+#			    must be the same port configured for your 
+#				Zebra node
 zebraPort = 18232
+# -------------------------------------------------------------
+# currencyCode  - ISO 4217 currency code 
+#
+#  Example of currency codes are:
+#
+#      United States -> currencyCode = "usd"	
+#      Canada        -> currencyCode = "cnd"	
+#      Australia     -> currencyCode = "aud"
+#      Euro Region   -> currencyCode = "eur"	
+#      Great Britain -> currencyCode = "gbp"	
+#      Japan         -> currencyCode = "jpy"		
+#                 
+currencyCode = "usd"