diff --git a/apps/simplex-store-service/src/StoreService/Web/Names.hs b/apps/simplex-store-service/src/StoreService/Web/Names.hs index 5898326214..684cf6dd07 100644 --- a/apps/simplex-store-service/src/StoreService/Web/Names.hs +++ b/apps/simplex-store-service/src/StoreService/Web/Names.hs @@ -7,11 +7,12 @@ module StoreService.Web.Names (Route (..), namesRoutes, namesApp) where import Data.Text (Text) import Network.HTTP.Types (Method) import Network.Wai (Request, ResponseReceived, pathInfo) +import StoreService.Config (ServiceConfig) import StoreService.Names.Env (NamesEnv (..)) import StoreService.Names.Orders (ordersEnv) import StoreService.Web.Http (HttpEnv, Limit, Respond, codeLimit, createLimit, holdMicros, limited, only, previewLimit, readLimit, searchLimit) import StoreService.Web.Names.Codes (codeCheckHandler) -import StoreService.Web.Names.Orders (codeOrderHandler) +import StoreService.Web.Names.Orders (codeOrderHandler, spendHandler) import StoreService.Web.Names.Registration (registrationHandler, retryHandler, revealHandler) import StoreService.Web.Names.Search (previewHandler, searchHandler) @@ -21,8 +22,8 @@ data Route = Route rHandler :: Request -> Respond -> IO ResponseReceived } -namesRoutes :: NamesEnv -> [Text] -> Maybe Route -namesRoutes env@NamesEnv {neConfig, neStore, neContracts, neProfiles, neWaiters, neProviders} = \case +namesRoutes :: ServiceConfig -> NamesEnv -> [Text] -> Maybe Route +namesRoutes cfg env@NamesEnv {neConfig, neStore, neContracts, neProfiles, neWaiters, neProviders} = \case ["api", "name", "register"] -> Just Route {rMethod = "POST", rLimit = codeLimit, rHandler = codeOrderHandler (ordersEnv env) neProviders neWaiters} ["api", "code", "check"] -> Just Route {rMethod = "POST", rLimit = codeLimit, rHandler = codeCheckHandler neStore} ["api", "link", "preview"] -> Just Route {rMethod = "POST", rLimit = previewLimit, rHandler = previewHandler neProfiles} @@ -31,6 +32,7 @@ namesRoutes env@NamesEnv {neConfig, neStore, neContracts, neProfiles, neWaiters, ["api", "registration", rid] -> Just Route {rMethod = "GET", rLimit = readLimit, rHandler = registrationHandler (ordersEnv env) holdMicros rid} ["api", "registration", rid, "reveal"] -> Just Route {rMethod = "POST", rLimit = readLimit, rHandler = revealHandler (ordersEnv env) rid} ["api", "registration", rid, "retry"] -> Just Route {rMethod = "POST", rLimit = createLimit, rHandler = retryHandler (ordersEnv env) rid} + ["api", "registration", rid, "spend"] -> Just Route {rMethod = "POST", rLimit = createLimit, rHandler = spendHandler (ordersEnv env) cfg neProviders neWaiters rid} _ -> Nothing -- | Nothing for a path no route knows. The limit is taken only once the route and the method match. diff --git a/apps/simplex-store-service/src/StoreService/Web/Names/Orders.hs b/apps/simplex-store-service/src/StoreService/Web/Names/Orders.hs index 92a5c19a98..9a38f9aced 100644 --- a/apps/simplex-store-service/src/StoreService/Web/Names/Orders.hs +++ b/apps/simplex-store-service/src/StoreService/Web/Names/Orders.hs @@ -9,6 +9,7 @@ module StoreService.Web.Names.Orders firstRefusal, nameInvoiceHandler, codeOrderHandler, + spendHandler, nameInvoiceView, orderRefusalResponse, ) @@ -17,36 +18,41 @@ where import Control.Concurrent.STM (atomically) import qualified Control.Exception as E import Control.Monad (forM_, unless) +import Control.Monad.Except (ExceptT (..), liftEither, runExceptT) import Data.Aeson ((.=)) import qualified Data.Aeson as J import qualified Data.Aeson.KeyMap as KM import Data.Bifunctor (first) -import Data.Maybe (isJust) +import Data.ByteString (ByteString) +import Data.Maybe (isJust, maybeToList) import Data.Text (Text) -import Data.Time.Clock (addUTCTime) -import Data.Word (Word32) +import Data.Time.Clock (UTCTime, addUTCTime) +import Data.Word (Word32, Word64) import Network.HTTP.Types (status200, status403, status409, status503) import Network.Wai (Request, Response, ResponseReceived) import Simplex.Chat.Badges.Code (NameCode (..), parseNameCode) -import Simplex.Chat.PaymentService.Types (CurrencyAmount (..), InvoiceId (..), InvoiceStatus (..), ServicePaymentMethod) +import Simplex.Chat.PaymentService.Types (CurrencyAmount (..), InvoiceId (..), InvoiceStatus (..), ServicePaymentMethod (..)) import Simplex.Messaging.Agent.Store.Common (withTransaction) +import qualified Simplex.Messaging.Agent.Store.DB as DB +import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature) import Simplex.Messaging.Util (tshow) import StoreService.Catalog (catalogCurrency) import StoreService.Config (NamesConfig (..), ServiceConfig) import StoreService.Log (logError, logInfo, logWarn) import StoreService.Names.Abi (hex) +import StoreService.Names.Balances (Spend (..), checkSpendBalance, coveredOrderInsert, differenceOrderInsert, spendTerms) import StoreService.Names.Codes (CodeRefusal (..), readPrepaidCode) import StoreService.Names.Orders import StoreService.Names.Phases (RegistrationId (..)) -import StoreService.Names.Signatures (OrderFields (..)) +import StoreService.Names.Signatures (OrderFields (..), spendMessage) import StoreService.Names.Store (NameRegistration (..), NewRegistration (..), OrderTerms (..), PaidOrder (..), PrepaidCode (..), RegistrationPayment (..), createPaidRegistration, getRegistration, newRegistrationId, orderHash, textMethod) -import StoreService.Names.Turns (withLabelTurn) -import StoreService.Names.View (registrationAt, registrationView) +import StoreService.Names.Turns (withBalanceTurn, withLabelTurn) +import StoreService.Names.View (balanceJSON, registrationAt, registrationView) import StoreService.Orders (publishRegistration) import StoreService.Providers (OrderDraft (..), Provider (..), ProviderError (..), ProviderInvoice (..), expiresItself) import StoreService.Store.Invoices (InvoiceRow (..), NewNameInvoice (..), getInvoice, insertNameInvoice, newInvoiceId, truncateToSecond) import StoreService.Waiters (Waiters, publish) -import StoreService.Web.Http (Respond, badRequest, confirmationsFor, internalError, invalidName, invoiceAt, invoicePairs, invoiceWindow, jsonError, jsonResponse, nameBodyBytes, providerFor, providerNamed, providerUnavailable, readBoundedBody) +import StoreService.Web.Http (Respond, badRequest, confirmationsFor, internalError, invalidName, invoiceAt, invoicePairs, invoiceWindow, jsonError, jsonResponse, nameBodyBytes, notFound, providerFor, providerNamed, providerUnavailable, readBoundedBody) import StoreService.Web.Names.Codes (codeRefusalResponse) data InvoiceOrder = InvoiceOrder @@ -88,68 +94,99 @@ nameInvoiceHandler env@OrdersEnv {oeStore, oeTurns, oeNow} cfg providers waiters now <- oeNow let hash = orderHash orOwner orFields (OTInvoice ioMethod $ fromIntegral ioPrice) withTransaction oeStore (\db -> existingOrder db req hash now) >>= \case - EOResent r -> answerResend now r + EOResent r -> resentOrder env cfg what now r EOMeets -> refuse OROrderExists EONew _ -> newOrder order where - refuse refusal = do - logInfo ("POST /api/invoice (name) refused: " <> tshow refusal) - pure $ answerNow $ orderRefusalResponse refusal - answerResend now r@NameRegistration {nrPayment} = case nrPayment of - RPInvoice _ invId -> getInvoice oeStore invId >>= maybe (refuse OROrderExists) (fmap answerNow . viewOf (registrationAt now r) . invoiceAt now) - RPCode _ -> refuse OROrderExists - viewOf r row = jsonResponse status200 <$> nameInvoiceView env (confirmationsFor cfg) row r - newOrder order@InvoiceOrder {ioRequest = OrderRequest {orFields = OrderFields {ofLabelHash, ofLength, ofDuration}, orTimestamp}, ioMethod, ioPrice} = do + what = "POST /api/invoice (name)" + refuse = refused what + newOrder InvoiceOrder {ioRequest = req@OrderRequest {orOwner, orFields = fields@OrderFields {ofLabelHash, ofLength, ofDuration}, orTimestamp}, ioMethod, ioPrice} = do now <- oeNow let years = nYears $ oeConfig env + price = fromIntegral ioPrice checks = [ pure $ checkTimestamp now orTimestamp, pure $ checkDuration (oeConfig env) now years ofDuration, checkNameFree (oeContracts env) oeStore ofLabelHash, - checkPrice (oeContracts env) ofLength years (fromIntegral ioPrice) + checkPrice (oeContracts env) ofLength years price ] + insert new paid db at = first (const OROrderExists) <$> createPaidRegistration db new (OTInvoice ioMethod price) paid at firstRefusal checks >>= \case Just refusal -> refuse refusal - Nothing -> case providerFor providers ioMethod of - Nothing -> do - logInfo ("POST /api/invoice (name) refused: no provider configured for " <> tshow ioMethod) - pure $ answerNow providerUnavailable - Just provider -> createAtProvider order provider - createAtProvider InvoiceOrder {ioRequest = req@OrderRequest {orOwner, orFields}, ioMethod, ioPrice} provider = do + Nothing -> createAtProvider env cfg providers waiters what InvoicedOrder {ivRequest = req, ivOrderHash = orderHash orOwner fields (OTInvoice ioMethod price), ivHolders = [], ivMethod = ioMethod, ivPrice = price, ivAmount = ioPrice, ivInsert = insert} + +-- | An order paid by invoice: its order hash, the holders its transaction closes, the order's price, what its invoice asks +-- (less than the price when a balance paid the rest), and its insert after the invoice row's. +data InvoicedOrder = InvoicedOrder + { ivRequest :: OrderRequest, + ivOrderHash :: ByteString, + ivHolders :: [NameRegistration], + ivMethod :: ServicePaymentMethod, + ivPrice :: Int, + ivAmount :: Word32, + ivInsert :: NewRegistration -> PaidOrder -> DB.Connection -> UTCTime -> IO (Either OrderRefusal ()) + } + +-- | The invoice is made at the provider first, then the order is written with its invoice row; an order not written has its invoice cancelled there. +createAtProvider :: OrdersEnv -> ServiceConfig -> [Provider] -> Waiters -> Text -> InvoicedOrder -> IO Answer +createAtProvider env@OrdersEnv {oeStore, oeConfig, oeNow} cfg providers waiters what InvoicedOrder {ivRequest = req@OrderRequest {orOwner, orFields}, ivOrderHash, ivHolders, ivMethod, ivPrice, ivAmount, ivInsert} = + case providerFor providers ivMethod of + Nothing -> do + logInfo (what <> " refused: no provider configured for " <> tshow ivMethod) + pure $ answerNow providerUnavailable + Just provider -> do invId <- newInvoiceId now <- truncateToSecond <$> oeNow - let amount = CurrencyAmount ioPrice - pCreateInvoice provider ioMethod OrderDraft {odAmount = amount, odCurrency = catalogCurrency, odReference = "name:" <> hex (orderHash orOwner orFields (OTInvoice ioMethod $ fromIntegral ioPrice))} >>= \case + let amount = CurrencyAmount ivAmount + pCreateInvoice provider ivMethod OrderDraft {odAmount = amount, odCurrency = catalogCurrency, odReference = "name:" <> hex ivOrderHash} >>= \case Left (ProviderError e) -> do - logError ("POST /api/invoice (name) failed: provider refused to create an invoice: " <> e) + logError (what <> " failed: provider refused to create an invoice: " <> e) pure $ answerNow providerUnavailable Right ProviderInvoice {piProviderRef, piDestination} -> do rid <- newRegistrationId - let invoice = NewNameInvoice {nniInvoiceId = invId, nniProvider = pProvider provider, nniAmount = amount, nniCurrency = catalogCurrency, nniDestination = piDestination, nniExpiresAt = addUTCTime (invoiceWindow cfg ioMethod) now, nniCreatedAt = now} - registration = NewRegistration {nrgId = rid, nrgOwner = orOwner, nrgOrder = orFields, nrgYears = nYears $ oeConfig env} - paid = PaidOrder {poMethod = ioMethod, poPrice = fromIntegral ioPrice, poInvoiceId = invId, poProviderRef = piProviderRef} - placeOrder env req (\db at -> insertNameInvoice db invoice >> first (const OROrderExists) <$> createPaidRegistration db registration paid at) + let invoice = NewNameInvoice {nniInvoiceId = invId, nniProvider = pProvider provider, nniAmount = amount, nniCurrency = catalogCurrency, nniDestination = piDestination, nniExpiresAt = addUTCTime (invoiceWindow cfg ivMethod) now, nniCreatedAt = now} + registration = NewRegistration {nrgId = rid, nrgOwner = orOwner, nrgOrder = orFields, nrgYears = nYears oeConfig} + paid = PaidOrder {poMethod = ivMethod, poPrice = ivPrice, poInvoiceId = invId, poProviderRef = piProviderRef} + placeOrder env req ivHolders (\db at -> insertNameInvoice db invoice >> ivInsert registration paid db at) `E.catch` strandedBy provider piProviderRef >>= \case Left refusal -> do - logWarn ("POST /api/invoice (name): the order lost to another, so invoice " <> piProviderRef <> " is cancelled at the provider") - (\a -> a {aAfter = cancelAtProvider provider piProviderRef}) <$> refuse refusal + logWarn (what <> ": the order was refused, so invoice " <> piProviderRef <> " is cancelled at the provider") + (\a -> a {aAfter = cancelAtProvider provider piProviderRef}) <$> refused what refusal Right closed -> do row_ <- getInvoice oeStore invId registration_ <- withTransaction oeStore (`getRegistration` rid) response <- case (row_, registration_) of - (Just row, Just r) -> viewOf r row - _ -> internalError <$ logError ("POST /api/invoice (name): order " <> invText invId <> " is not readable after its commit") + (Just row, Just r) -> invoiceViewResponse env cfg r row + _ -> internalError <$ logError (what <> ": order " <> invText invId <> " is not readable after its commit") pure Answer {aResponse = response, aAfter = announceClosed env providers waiters closed} + where -- An invoice created at the provider for an order that was not written would stay payable with nothing watching it. strandedBy :: Provider -> Text -> E.SomeException -> IO a strandedBy provider ref e = do unless (isAsync e) $ do - logError ("POST /api/invoice (name): the order was not written, so invoice " <> ref <> " is cancelled at the provider: " <> tshow e) + logError (what <> ": the order was not written, so invoice " <> ref <> " is cancelled at the provider: " <> tshow e) cancelAtProvider provider ref E.throwIO e isAsync e = isJust (E.fromException e :: Maybe E.SomeAsyncException) +-- | An exact resend, answered with its order as it reads now: the invoice view, or the id of an order without an invoice. +resentOrder :: OrdersEnv -> ServiceConfig -> Text -> UTCTime -> NameRegistration -> IO Answer +resentOrder env@OrdersEnv {oeStore} cfg what now r@NameRegistration {nrId, nrPayment} = case nrPayment of + RPInvoice _ invId -> getInvoice oeStore invId >>= maybe (refused what OROrderExists) (fmap answerNow . invoiceViewResponse env cfg (registrationAt now r) . invoiceAt now) + RPBalance -> pure $ answerNow $ registrationAnswer nrId + -- the hash of an invoice or spend order never matches a code order's + RPCode _ -> refused what OROrderExists + +invoiceViewResponse :: OrdersEnv -> ServiceConfig -> NameRegistration -> InvoiceRow -> IO Response +invoiceViewResponse env cfg r row = jsonResponse status200 <$> nameInvoiceView env (confirmationsFor cfg) row r + +registrationAnswer :: RegistrationId -> Response +registrationAnswer (RegistrationId rid) = jsonResponse status200 $ J.object ["registrationId" .= rid] + +refused :: Text -> OrderRefusal -> IO Answer +refused what refusal = answerNow (orderRefusalResponse refusal) <$ logInfo (what <> " refused: " <> tshow refusal) + -- | POST /api/name/register, an order paid with a prepaid code, in the contract's order of checks. codeOrderHandler :: OrdersEnv -> [Provider] -> Waiters -> Request -> Respond -> IO ResponseReceived codeOrderHandler env@OrdersEnv {oeStore, oeConfig, oeContracts, oeTurns, oeNow} providers waiters req respond = @@ -187,13 +224,83 @@ codeOrderHandler env@OrdersEnv {oeStore, oeConfig, oeContracts, oeTurns, oeNow} placeCodeOrder env order rid code >>= \case Left refusal -> refuse refusal Right closed -> pure Answer {aResponse = registrationAnswer rid, aAfter = announceClosed env providers waiters closed} - registrationAnswer (RegistrationId rid) = jsonResponse status200 $ J.object ["registrationId" .= rid] parseCodeOrder :: J.Object -> Either OrderRefusal (OrderRequest, Text) parseCodeOrder o = do order@(req, _) <- maybe (Left ORBadRequest) Right $ (,) <$> parseOrderRequest o <*> textField o "code" order <$ checkLength (orFields req) +-- | POST /api/registration/:id/spend, another name paid from this order's balance, in the contract's order of checks, +-- under the new name's turn and then the balance's. +spendHandler :: OrdersEnv -> ServiceConfig -> [Provider] -> Waiters -> Text -> Request -> Respond -> IO ResponseReceived +spendHandler env@OrdersEnv {oeStore, oeConfig, oeContracts, oeTurns, oeNow} cfg providers waiters ridText req respond + | nCodesOnly oeConfig = sendAnswer respond =<< refuse ORCodesOnly + | otherwise = readBoundedBody nameBodyBytes req >>= requested >>= sendAnswer respond + where + source = RegistrationId ridText + what = "POST /api/registration/:id/spend" + refuse = refused what + requested = \case + Just body | Just (J.Object o) <- J.decode body -> either refuse paying (parseSpend source o) + _ -> refuse ORBadRequest + paying ((fields, timestamp, signature), spend) = + withTransaction oeStore (`getRegistration` source) >>= \case + Nothing -> pure $ answerNow notFound + Just NameRegistration {nrOwner} -> + checkSigner nrOwner (spendMessage source fields timestamp) signature >>= \case + Left refusal -> refuse refusal + Right () -> do + let order = OrderRequest {orOwner = nrOwner, orFields = fields, orTimestamp = timestamp, orSignature = signature} + withLabelTurn oeTurns (ofLabelHash fields) $ withBalanceTurn oeTurns source $ inTurns order spend + inTurns order@OrderRequest {orOwner, orFields} spend = do + now <- oeNow + withTransaction oeStore (\db -> existingOrder db order (orderHash orOwner orFields $ spendTerms spend) now) >>= \case + EOResent r -> resentOrder env cfg what now r + EOMeets -> refuse OROrderExists + EONew _ -> runExceptT (checked now order spend) >>= either refuse (place order spend) + checked now OrderRequest {orFields = OrderFields {ofLabelHash, ofLength, ofDuration}, orTimestamp} spend@Spend {spPrice} = do + let years = nYears oeConfig + liftEither $ checkTimestamp now orTimestamp + liftEither $ checkDuration oeConfig now years ofDuration + holder <- ExceptT $ checkSpendBalance oeStore spend now + ExceptT $ checkNameFree oeContracts oeStore ofLabelHash + ExceptT $ checkPrice oeContracts ofLength years spPrice + pure holder + place order@OrderRequest {orOwner, orFields} spend@Spend {spPrice, spBalance, spMethod} holder = case spMethod of + Nothing -> do + rid <- newRegistrationId + let new = NewRegistration {nrgId = rid, nrgOwner = orOwner, nrgOrder = orFields, nrgYears = nYears oeConfig} + placeOrder env order (maybeToList holder) (coveredOrderInsert spend new) >>= \case + Left refusal -> refuse refusal + Right closed -> pure Answer {aResponse = registrationAnswer rid, aAfter = announceClosed env providers waiters closed} + Just (SPMCard _) + | spPrice - spBalance < minCardChargeCents -> refuse ORBadRequest + Just method -> + createAtProvider env cfg providers waiters what $ + InvoicedOrder {ivRequest = order, ivOrderHash = orderHash orOwner orFields (spendTerms spend), ivHolders = maybeToList holder, ivMethod = method, ivPrice = spPrice, ivAmount = fromIntegral (spPrice - spBalance), ivInsert = differenceOrderInsert spend} + +-- | Stripe refuses a USD charge under 50 cents, so the page offers only crypto for a smaller difference. +minCardChargeCents :: Int +minCardChargeCents = 50 + +-- | Every format check, the method present exactly for a difference, then the length's range. +parseSpend :: RegistrationId -> J.Object -> Either OrderRefusal ((OrderFields, Word64, RecoverableSignature), Spend) +parseSpend spSource o = do + parsed@((fields, _, _), _) <- maybe (Left ORBadRequest) Right $ do + signed <- parseOrderFields o + spPrice <- cents "price" + spBalance <- cents "balance" + spMethod <- case (KM.lookup "method" o, spPrice > spBalance) of + (Nothing, False) -> Just Nothing + (Just (J.String t), True) -> Just <$> textMethod t + _ -> Nothing + pure (signed, Spend {spSource, spPrice, spBalance, spMethod}) + parsed <$ checkLength fields + where + -- positive, and within an invoice amount's range + cents :: J.Key -> Maybe Int + cents k = KM.lookup k o >>= integerField >>= \n -> if n > (0 :: Word32) then Just (fromIntegral n) else Nothing + -- | After the commit, the closed orders' invoices and versions are published, and their invoices cancelled at the provider, -- best effort, as the poller's sweep would cancel them. announceClosed :: OrdersEnv -> [Provider] -> Waiters -> [ClosedOrder] -> IO () @@ -208,6 +315,7 @@ announceClosed OrdersEnv {oeStore, oePhases} providers waiters closed = do paidInvoice = \case RPInvoice _ invId -> Just invId RPCode _ -> Nothing + RPBalance -> Nothing cancelAtProvider :: Provider -> Text -> IO () cancelAtProvider Provider {pCancelInvoice} ref = @@ -224,8 +332,9 @@ firstRefusal = \case check : rest -> check >>= either (pure . Just) (const $ firstRefusal rest) nameInvoiceView :: OrdersEnv -> Maybe Int -> InvoiceRow -> NameRegistration -> IO J.Value -nameInvoiceView OrdersEnv {oeStore, oeConfig, oeContracts} confirmations row@InvoiceRow {irInvoiceId = InvoiceId invId} r = do - view <- registrationView oeStore oeConfig oeContracts r +nameInvoiceView OrdersEnv {oeStore, oeConfig, oeContracts, oeNow} confirmations row@InvoiceRow {irInvoiceId = InvoiceId invId} r = do + now <- oeNow + view <- registrationView oeStore oeConfig oeContracts now r pure $ J.object $ ["invoiceId" .= invId, "kind" .= ("name" :: Text), "registration" .= view] <> invoicePairs confirmations row orderRefusalResponse :: OrderRefusal -> Response @@ -237,4 +346,5 @@ orderRefusalResponse = \case ORNameCheckUnavailable -> jsonError status503 "name_check_unavailable" ORCatalogChanged price -> jsonResponse status409 $ J.object ["error" .= ("catalog_changed" :: Text), "price" .= price] ORCode refusal -> codeRefusalResponse refusal + ORBalanceChanged balance -> jsonResponse status409 $ J.object ["error" .= ("balance_changed" :: Text), "balance" .= (balanceJSON <$> balance)] ORCodesOnly -> jsonError status403 "codes_only" diff --git a/apps/simplex-store-service/src/StoreService/Web/Names/Registration.hs b/apps/simplex-store-service/src/StoreService/Web/Names/Registration.hs index 99b29b2d14..9cd6bb0170 100644 --- a/apps/simplex-store-service/src/StoreService/Web/Names/Registration.hs +++ b/apps/simplex-store-service/src/StoreService/Web/Names/Registration.hs @@ -54,7 +54,7 @@ registrationHandler OrdersEnv {oeStore, oeConfig, oeContracts, oePhases, oeNow} where rid = RegistrationId ridText readNow = oeNow >>= \now -> fmap (now,) <$> withTransaction oeStore (`getRegistration` rid) - answer (now, r) = respond . jsonResponse status200 =<< registrationView oeStore oeConfig oeContracts (registrationAt now r) + answer (now, r) = respond . jsonResponse status200 =<< registrationView oeStore oeConfig oeContracts now (registrationAt now r) -- | What a reveal decided in the name's turn, with the version it wrote; the publish and the answer come after the turn. data RevealDecision @@ -150,7 +150,7 @@ registrationRefusalResponse env tag rid = maybe notFound refusal <$> currentView -- | The registration's view as it reads now. currentView :: OrdersEnv -> RegistrationId -> IO (Maybe J.Value) currentView OrdersEnv {oeStore, oeConfig, oeContracts, oeNow} rid = - withTransaction oeStore (`getRegistration` rid) >>= traverse (\r -> oeNow >>= \now -> registrationView oeStore oeConfig oeContracts (registrationAt now r)) + withTransaction oeStore (`getRegistration` rid) >>= traverse (\r -> oeNow >>= \now -> registrationView oeStore oeConfig oeContracts now (registrationAt now r)) -- | The hold, cut to end just past the next moment at which the answer changes with time alone. heldFor :: Int -> UTCTime -> [UTCTime] -> Int diff --git a/apps/simplex-store-service/src/StoreService/Web/Server.hs b/apps/simplex-store-service/src/StoreService/Web/Server.hs index 4a2a59ca97..7c6a207626 100644 --- a/apps/simplex-store-service/src/StoreService/Web/Server.hs +++ b/apps/simplex-store-service/src/StoreService/Web/Server.hs @@ -132,7 +132,7 @@ siteApp env@WebEnv {weHttp} served req respond = case pathInfo req of ["webhooks", "stripe"] -> only "POST" req respond $ webhookHandler env PPStripe "POST /webhooks/stripe" req respond _ -> fromMaybe (respond notFound) names where - names = weNames env >>= \n -> namesApp weHttp (namesRoutes n) req respond + names = weNames env >>= \n -> namesApp weHttp (namesRoutes (weConfig env) n) req respond -- | The names build keeps files at its root, so every path outside the API and the webhooks is the site's. sitePath :: [Text] -> Bool diff --git a/tests/Bots/StoreService/NamesSpendTests.hs b/tests/Bots/StoreService/NamesSpendTests.hs new file mode 100644 index 0000000000..cd32a605b0 --- /dev/null +++ b/tests/Bots/StoreService/NamesSpendTests.hs @@ -0,0 +1,734 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TupleSections #-} + +module Bots.StoreService.NamesSpendTests (namesSpendChatTests, namesSpendTests) where + +import Bots.StoreService.BotTests (operatorCmd, withStoreService) +import Bots.StoreService.FakeBTCPay (FakeBTCPay (..), setInvoiceState, setRates, webhookEvent, webhookSigHeader, withFakeBTCPay) +import Bots.StoreService.FakeEthNode +import Bots.StoreService.NamesContractsTests (reservedNamesCall) +import Bots.StoreService.NamesOrdersTests (Ctx (..), Order (..), advance, aliceOrder, codesOnly, commitmentOf, configured, field, fieldsOf, invoiceRegistration, keyB, orderTime, placeOrder, placed, post, refusedWith, registrationById, registrationOf, registrationsOf, settleNow, withOrdersOn, yearsDuration) +import Bots.StoreService.NamesStoreTests (at, order, ownerA, placePaid, reg, t0, write) +import Bots.StoreService.WebTests (StubCall (..), capturingStderr, StubState (..), jsonObject, rcv, sampleProviderInvoice, statusOf, stubCalls, webGet, webRequestBody, withServiceStores) +import ChatTests.DBUtils (TestParams) +import Control.Concurrent.Async (Async, async, cancel, concurrently, wait) +import Control.Concurrent.MVar (newEmptyMVar, putMVar, takeMVar) +import Control.Concurrent.STM (atomically, check) +import Control.Monad (join, replicateM_, void) +import qualified Data.Aeson as J +import qualified Data.Aeson.KeyMap as KM +import qualified Data.Aeson.Types as JT +import qualified Data.ByteString.Lazy.Char8 as LB +import Data.Int (Int64) +import Data.IORef (IORef, modifyIORef', newIORef, readIORef, writeIORef) +import Data.List (sort) +import Data.Maybe (fromMaybe) +import Data.Text (Text) +import qualified Data.Text as T +import Data.Text.Encoding (encodeUtf8) +import Data.Time.Clock (UTCTime, addUTCTime, getCurrentTime) +import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds) +import Data.Word (Word64) +import Network.HTTP.Client (defaultManagerSettings, newManager) +import Network.HTTP.Types (hContentType) +import Network.Wai (Application) +import qualified Network.Wai.Handler.Warp as Warp +import Simplex.Chat.Controller (ChatController (..)) +import Simplex.Chat.PaymentService.Types (CryptoCurrency (..), CurrencyAmount (..), InvoiceId (..), InvoiceStatus (..), PaymentProvider (..), ServicePaymentMethod (..)) +import Simplex.Messaging.Agent.Store.Common (DBStore, withTransaction) +import qualified Simplex.Messaging.Crypto as C +import Simplex.Messaging.Crypto.Secp256k1 (signRecoverable) +import Simplex.Messaging.Eth.EIP712 (serializeSignature) +import Simplex.Messaging.SimplexName (LabelHash (..), labelHash) +import StoreService.Config (BTCPayConfig (..), ServiceConfig (..)) +import StoreService.Names.Abi (hex, uint256) +import StoreService.Names.Balances (RefundRefusal (..), recordRefund) +import StoreService.Names.Orders (OrdersEnv (..)) +import StoreService.Names.Phases (RegistrationId (..), phasesWaiting) +import StoreService.Names.Signatures (OrderFields (..), personalDigest, spendMessage) +import StoreService.Names.Store +import StoreService.Names.View (balanceJSON) +import StoreService.Orders (cancelOpenInvoice) +import StoreService.Poller (PollerEnv, creditPass, drainHints, forgetRates, newPollerEnv) +import StoreService.Providers (Funded (..), OrderDraft (..), PaymentSignal (..), Provider (..), ProviderError (..)) +import StoreService.Providers.BTCPay (btcpayProvider) +import StoreService.Names.Turns (balanceTurnCount, labelTurnCount, withBalanceTurn) +import StoreService.Store.Invoices (InvoiceRow (..), getInvoice) +import StoreService.Web.Http (createLimit, holdMicros, readLimit) +import StoreService.Web.Names (Route (..), namesApp) +import StoreService.Web.Names.Orders (spendHandler) +import StoreService.Web.Names.Registration (registrationHandler) +import StoreService.Web.Server (WebEnv (..), webApp) +import System.Timeout (timeout) +import Test.Hspec + +namesSpendTests :: Spec +namesSpendTests = describe "StoreService names: spend" $ do + describe "orders" $ do + it "queues an order whose price the balance covers, spending the price and keeping the rest, or all of it" testCoveredSpend + it "makes an invoice for the difference, the order holding all of the balance until the invoice's expiry" testDifferenceSpend + it "answers an exact resend with its order in any phase, by its own hash, with a new timestamp and after the balance changed" testSpendResend + it "keeps a spend and an /api/invoice order of the same fields apart, each meeting the other as order_exists" testInvoiceBodyApart + describe "refusals" $ do + it "answers balance_changed with the current balance for a stale amount, a held balance and an order with none" testBalanceChanged + it "refuses a method with a covered price, none with a difference, and prices and balances not positive" testMethodRule + it "refuses another signer and a stale timestamp, and answers an unknown order 404" testSignerAndId + it "answers name_taken, catalog_changed, name_check_unavailable, provider_unavailable and order_exists, spending nothing" testOrderChecks + it "runs its checks in the contract's order" testCheckOrder + it "refuses a card difference below the card minimum after the price check, accepting it by crypto and at the minimum" testCardMinimum + it "refuses sealed missing or over 11095 characters and a body over 16384 bytes, accepting the longest" testSpendSizes + it "counts spends against the create limit" testSpendLimit + it "answers 403 codes_only to a covered spend, a difference, a malformed body and an unknown order, spending nothing and reaching no provider" testSpendCodesOnly + describe "holders" $ do + it "closes the balance's overdue unfunded holder in the spend's transaction, publishing it and cancelling its invoice" testOverdueHolderSpent + it "closes an overdue unfunded holder of another name for a difference spend, the new invoice holding the balance" testDifferenceClosesHolder + it "makes a new invoice of the same name over its overdue difference order, closing and cancelling that order once" testSpendAgain + it "goes through when the overdue holder was cancelled meanwhile" testHolderCancelledMeanwhile + it "answers balance_changed when the overdue holder was funded meanwhile, cancelling the new invoice" testHolderFundedMeanwhile + describe "races" $ do + it "lets one of two concurrent spends of one balance win, the other answered balance_changed" testConcurrentSpends + it "answers balance_changed and cancels the provider invoice when another store changed the balance after the check" testWriteRefusedAtBalance + it "lets one of a spend and a refund of the balance win" testSpendRacesRefund + it "takes the new name's turn and then the balance's" testSpendTurns + +namesSpendChatTests :: SpecWith TestParams +namesSpendChatTests = + describe "StoreService names: spend end to end" $ + it "spends a taken order's balance on a dearer name through BTCPay and the poller, credits a late payment, and refunds the rest" testSpendEndToEnd + +testSpendCodesOnly :: IO () +testSpendCodesOnly = withSpend $ \open -> do + source <- sourceOf open "s" 10000 + serveSpend (configured codesOnly open) $ \ctx -> do + spend ctx source (covered 10000) `shouldReturn` refusedWith 403 "codes_only" + spend ctx source (dynamis 10000 $ Just "btc") `shouldReturn` refusedWith 403 "codes_only" + postSpend ctx source KM.empty `shouldReturn` refusedWith 403 "codes_only" + postSpend ctx (RegistrationId "unknown") KM.empty `shouldReturn` refusedWith 403 "codes_only" + amountOf ctx source `shouldReturn` Just 10000 + paidFrom ctx source `shouldReturn` [] + stubCalls (cStub ctx) `shouldReturn` [] + -- nothing the refusals left meets the same spend with codes_only off + fst <$> spend open source (covered 10000) `shouldReturn` 200 + +-- fixtures + +-- | Over a new database; the hook runs as each provider invoice is created. +withSpendHook :: (IORef (IO ()) -> Ctx -> IO a) -> IO a +withSpendHook action = do + hook <- newIORef (pure ()) + withServiceStores $ \open -> withSpendOn open (\p -> p {pCreateInvoice = \m d -> join (readIORef hook) >> pCreateInvoice p m d}) (action hook) + +withSpendOn :: IO DBStore -> (Provider -> Provider) -> (Ctx -> IO a) -> IO a +withSpendOn open via action = withOrdersOn open via (`serveSpend` action) + +-- | The spend route beside the registration poll and the service's routes, over the context's settings. +serveSpend :: Ctx -> (Ctx -> IO a) -> IO a +serveSpend ctx@Ctx {cOrders, cWeb} action = do + let routes :: [Text] -> Maybe Route + routes = \case + ["api", "registration", rid, "spend"] -> Just Route {rMethod = "POST", rLimit = createLimit, rHandler = spendHandler cOrders (weConfig cWeb) (weProviders cWeb) (weWaiters cWeb) rid} + ["api", "registration", rid] -> Just Route {rMethod = "GET", rLimit = readLimit, rHandler = registrationHandler cOrders holdMicros rid} + _ -> Nothing + app :: Application + app req respond = fromMaybe (webApp cWeb req respond) (namesApp (weHttp cWeb) routes req respond) + mgr <- newManager defaultManagerSettings + Warp.testWithApplication (pure app) $ \port -> action ctx {cClient = (mgr, "http://127.0.0.1:" <> show port)} + +withSpend :: (Ctx -> IO a) -> IO a +withSpend action = withSpendHook (const action) + +-- | Run by the next provider invoice made, once. +onCreate :: IORef (IO ()) -> IO () -> IO () +onCreate hook act = writeIORef hook (writeIORef hook (pure ()) >> act) + +-- | A taken paid order of owner A with a balance of the cents. +sourceOf :: Ctx -> Text -> Int -> IO RegistrationId +sourceOf Ctx {cStore} rid cents = do + placePaid cStore rid ownerA (order ("source-" <> rid) 1) {ofCommitment = C.sha256Hash $ encodeUtf8 rid} (at 60) `shouldReturn` Right () + taken <- reg cStore rid + write cStore taken {nrPhase = PTaken} `shouldReturn` Written 2 + credit cStore rid cents + pure $ RegistrationId rid + +credit :: DBStore -> Text -> Int -> IO () +credit st rid cents = withTransaction st $ \db -> creditBalance db (RegistrationId rid) cents t0 + +-- | What the page sends: the new order's fields and price, the balance it read, and a method only for a difference. +data SpendBody = SpendBody + { sbOrder :: Order, + sbBalance :: Int, + sbMethod :: Maybe Text + } + +-- | alicebakery, at 10000. +covered :: Int -> SpendBody +covered balance = SpendBody {sbOrder = aliceOrder, sbBalance = balance, sbMethod = Nothing} + +difference :: Int -> SpendBody +difference balance = (covered balance) {sbMethod = Just "btc"} + +-- | 7 letters, at the launch price of 20000 for 2 years. +dynamisOrder :: Order +dynamisOrder = aliceOrder {oLabel = "dynamis", oPrice = 20000, oCommitment = commitmentOf 2} + +dynamis :: Int -> Maybe Text -> SpendBody +dynamis = SpendBody dynamisOrder + +-- | Signed and timed at the clock's time, as a page acting later sends it. +timedAt :: UTCTime -> SpendBody -> SpendBody +timedAt now b@SpendBody {sbOrder} = b {sbOrder = orderAt now sbOrder} + +orderAt :: UTCTime -> Order -> Order +orderAt now o = o {oTimestamp = seconds now, oDuration = yearsDuration 2 now} + +spendBody :: Ctx -> RegistrationId -> SpendBody -> IO J.Object +spendBody Ctx {cRandom} source SpendBody {sbOrder = o@Order {oKey, oPrice, oTimestamp}, sbBalance, sbMethod} = do + sig <- either (error . show) id <$> signRecoverable cRandom oKey (personalDigest $ spendMessage source fields oTimestamp) + pure $ + KM.fromList $ + [ ("labelHash", J.String $ hex lh), + ("length", J.toJSON ofLength), + ("duration", J.toJSON ofDuration), + ("commitment", J.String $ hex ofCommitment), + ("sealed", J.String ofSealed), + ("price", J.toJSON oPrice), + ("balance", J.toJSON sbBalance), + ("timestamp", J.toJSON oTimestamp), + ("signature", J.String $ hex $ serializeSignature sig) + ] + <> maybe [] (\m -> [("method", J.String m)]) sbMethod + where + fields@OrderFields {ofLabelHash = LabelHash lh, ofLength, ofDuration, ofCommitment, ofSealed} = fieldsOf o + +postSpend :: Ctx -> RegistrationId -> J.Object -> IO (Int, Maybe J.Object) +postSpend ctx (RegistrationId rid) = post ctx ("/api/registration/" <> T.unpack rid <> "/spend") . J.encode + +spend :: Ctx -> RegistrationId -> SpendBody -> IO (Int, Maybe J.Object) +spend ctx source b = spendBody ctx source b >>= postSpend ctx source + +registrationAnswer :: Maybe J.Object -> RegistrationId +registrationAnswer = \case + Just v | KM.keys v == ["registrationId"], Just (J.String rid) <- field "registrationId" v -> RegistrationId rid + other -> error $ "not a registration id: " <> show other + +invoiceIdOf :: Maybe J.Object -> InvoiceId +invoiceIdOf v = case field "invoiceId" =<< v of + Just (J.String t) -> InvoiceId t + other -> error $ "not an invoice view: " <> show other + +registrationPath :: RegistrationId -> String +registrationPath (RegistrationId rid) = "/api/registration/" <> T.unpack rid + +viewOf :: Ctx -> RegistrationId -> IO J.Object +viewOf Ctx {cClient} rid = webGet cClient (registrationPath rid) >>= jsonObject + +-- | A registration poll at the order's version, once the server holds it. +heldPoll :: Ctx -> NameRegistration -> IO (Async (Int, J.Object)) +heldPoll Ctx {cOrders, cClient} NameRegistration {nrId, nrVersion} = do + waiting <- atomically $ phasesWaiting (oePhases cOrders) + poll <- async $ webGet cClient (registrationPath nrId <> "?seenVersion=" <> show nrVersion) >>= \resp -> (statusOf resp,) <$> jsonObject resp + timeout pollSeconds (atomically $ phasesWaiting (oePhases cOrders) >>= check . (> waiting)) >>= maybe (error "the poll was not held") pure + pure poll + +woken :: Async (Int, J.Object) -> IO (Int, J.Object) +woken poll = timeout pollSeconds (wait poll) >>= maybe (cancel poll >> error "the poll was not woken") pure + +pollSeconds :: Int +pollSeconds = 5000000 + +balanceOf :: Ctx -> RegistrationId -> IO (Maybe Balance) +balanceOf Ctx {cStore, cClock} rid = readIORef cClock >>= \now -> withTransaction cStore $ \db -> getBalance db rid now + +amountOf :: Ctx -> RegistrationId -> IO (Maybe Int) +amountOf ctx rid = fmap blAmount <$> balanceOf ctx rid + +balanceChanged :: Maybe Balance -> (Int, Maybe J.Object) +balanceChanged b = (409, Just $ KM.fromList [("error", "balance_changed"), ("balance", maybe J.Null balanceJSON b)]) + +-- | The orders a balance paid. +paidFrom :: Ctx -> RegistrationId -> IO [NameRegistration] +paidFrom ctx source = filter ((== Just source) . nrBalanceSource) <$> registrationsOf ctx ownerA + +cancels :: Ctx -> IO [Text] +cancels Ctx {cStub} = (\calls -> [r | StubCancel r <- calls]) <$> stubCalls cStub + +providerRef :: Ctx -> InvoiceId -> IO Text +providerRef Ctx {cStore} invId = maybe (error "no invoice row") irProviderRef <$> getInvoice cStore invId + +seconds :: UTCTime -> Word64 +seconds = floor . utcTimeToPOSIXSeconds + +btc :: ServicePaymentMethod +btc = SPMCrypto CCBtc + +-- tests + +testCoveredSpend :: IO () +testCoveredSpend = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 15000 + rid <- registrationAnswer . snd <$> spend ctx src (covered 15000) + r <- registrationById ctx rid + (nrPhase r, nrLive r, nrPrice r, nrPayment r, nrBalanceSource r, nrBalanceUsed r) `shouldBe` (PQueued, True, 10000, RPBalance, Just src, 10000) + nrOrderHash r `shouldBe` orderHash ownerA (fieldsOf aliceOrder) (OTBalance src 10000 15000 Nothing) + view <- viewOf ctx rid + (field "phase" view, field "price" view, field "fromBalance" view, field "balance" view) `shouldBe` (Just "queued", Just (J.Number 10000), Just (J.Number 10000), Just J.Null) + amountOf ctx src `shouldReturn` Just 5000 + exact <- sourceOf ctx "exact" 20000 + rid' <- registrationAnswer . snd <$> spend ctx exact (dynamis 20000 Nothing) + nrBalanceUsed <$> registrationById ctx rid' `shouldReturn` 20000 + fmap (\b -> (blAmount b, blHold b)) <$> balanceOf ctx exact `shouldReturn` Just (0, Nothing) + stubCalls (cStub ctx) `shouldReturn` [] + +testDifferenceSpend :: IO () +testDifferenceSpend = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 6000 + (status, v) <- spend ctx src (difference 6000) + status `shouldBe` 200 + let expiry = addUTCTime (45 * 60) orderTime + r = registrationOf <$> v + (field "status" =<< v, field "amount" =<< v, field "expiresAt" =<< v) `shouldBe` (Just "open", Just (J.Number 4000), Just (J.toJSON expiry)) + (field "phase" =<< r, field "price" =<< r, field "fromBalance" =<< r) `shouldBe` (Just "unpaid", Just (J.Number 10000), Just (J.Number 6000)) + let invId = invoiceIdOf v + holder <- invoiceRegistration ctx invId + stubCalls (cStub ctx) `shouldReturn` [StubCreate btc OrderDraft {odAmount = CurrencyAmount 4000, odCurrency = "usd", odReference = "name:" <> hex (nrOrderHash holder)}] + (nrPhase holder, nrLive holder, nrPrice holder, nrPayment holder, nrBalanceSource holder, nrBalanceUsed holder) `shouldBe` (PUnpaid, True, 10000, RPInvoice btc invId, Just src, 6000) + nrOrderHash holder `shouldBe` orderHash ownerA (fieldsOf aliceOrder) (OTBalance src 10000 6000 (Just btc)) + fmap irAmount <$> getInvoice (cStore ctx) invId `shouldReturn` Just (CurrencyAmount 4000) + field "balance" <$> viewOf ctx src `shouldReturn` Just (J.object ["amount" J..= (6000 :: Int), "held" J..= True, "heldUntil" J..= expiry, "refunded" J..= (0 :: Int)]) + +testSpendResend :: IO () +testSpendResend = withSpend $ \ctx@Ctx {cStore, cClock} -> do + src <- sourceOf ctx "src" 6000 + body <- spendBody ctx src (difference 6000) + (200, first') <- postSpend ctx src body + let invId = invoiceIdOf first' + credit cStore "src" 1000 + advance ctx 60 + spend ctx src (difference 6000) {sbOrder = aliceOrder {oTimestamp = seconds orderTime + 60}} `shouldReturn` (200, first') + advance ctx 700 + postSpend ctx src body `shouldReturn` (200, first') + holder <- invoiceRegistration ctx invId + now <- readIORef cClock + Written _ <- withTransaction cStore $ \db -> updateRegistration db holder {nrPhase = PQueued} now + (\(status, v) -> (status, invoiceIdOf v, field "phase" . registrationOf =<< v)) <$> postSpend ctx src body `shouldReturn` (200, invId, Just "queued") + other <- sourceOf ctx "other" 25000 + let paid = timedAt now $ dynamis 25000 Nothing + coveredBody <- spendBody ctx other paid + (200, answer) <- postSpend ctx other coveredBody + r <- registrationById ctx $ registrationAnswer answer + spend ctx other paid {sbOrder = (sbOrder paid) {oTimestamp = seconds now + 1}} `shouldReturn` (200, answer) + Written _ <- withTransaction cStore $ \db -> updateRegistration db r {nrPhase = PCommitted, nrRevealAfter = Just (seconds now), nrRevealBefore = Just (seconds now + 86400)} now + advance ctx 3600 + postSpend ctx other coveredBody `shouldReturn` (200, answer) + length <$> stubCalls (cStub ctx) `shouldReturn` 1 + amountOf ctx other `shouldReturn` Just 5000 + +testInvoiceBodyApart :: IO () +testInvoiceBodyApart = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 6000 + fst <$> spend ctx src (difference 6000) `shouldReturn` 200 + placeOrder ctx aliceOrder `shouldReturn` refusedWith 409 "order_exists" + fst <$> placeOrder ctx dynamisOrder `shouldReturn` 200 + other <- sourceOf ctx "other" 30000 + spend ctx other (dynamis 30000 Nothing) `shouldReturn` refusedWith 409 "order_exists" + amountOf ctx other `shouldReturn` Just 30000 + +testBalanceChanged :: IO () +testBalanceChanged = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 10000 + stale <- balanceOf ctx src + spend ctx src (covered 12000) `shouldReturn` balanceChanged stale + spend ctx src (difference 9000) `shouldReturn` balanceChanged stale + held <- sourceOf ctx "held" 6000 + fst <$> spend ctx held (dynamis 6000 (Just "btc")) `shouldReturn` 200 + holding <- balanceOf ctx held + (fmap bhUntil . blHold =<< holding, fmap bhOverdue . blHold =<< holding) `shouldBe` (Just (addUTCTime (45 * 60) orderTime), Just False) + spend ctx held (difference 6000) `shouldReturn` balanceChanged holding + placePaid (cStore ctx) "none" ownerA (order "source-none" 3) (at 60) `shouldReturn` Right () + spend ctx (RegistrationId "none") (covered 10000) `shouldReturn` balanceChanged Nothing + length <$> stubCalls (cStub ctx) `shouldReturn` 1 + paidFrom ctx src `shouldReturn` [] + +testMethodRule :: IO () +testMethodRule = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 6000 + good <- spendBody ctx src (difference 6000) + let with :: J.Key -> J.Value -> J.Object + with k v = KM.insert k v good + mapM_ + (\body -> postSpend ctx src body `shouldReturn` refusedWith 400 "bad_request") + [ KM.delete "method" good, + with "method" "eth", + with "method" J.Null, + with "price" (J.Number 0), + with "price" (J.Number 100.5), + with "balance" (J.Number 0), + with "balance" (J.Number (-1)), + KM.delete "balance" good + ] + spend ctx src (covered 6000) {sbOrder = aliceOrder {oPrice = 6000}, sbMethod = Just "btc"} `shouldReturn` refusedWith 400 "bad_request" + spend ctx src (difference 6000) {sbMethod = Nothing} `shouldReturn` refusedWith 400 "bad_request" + mapM_ (\len -> postSpend ctx src (with "length" (J.Number len)) `shouldReturn` refusedWith 400 "invalid_name") [5, 64] + stubCalls (cStub ctx) `shouldReturn` [] + amountOf ctx src `shouldReturn` Just 6000 + +testSignerAndId :: IO () +testSignerAndId = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 15000 + spend ctx src (covered 15000) {sbOrder = aliceOrder {oKey = keyB}} `shouldReturn` refusedWith 400 "bad_request" + mapM_ + (\offset -> spend ctx src (covered 15000) {sbOrder = aliceOrder {oTimestamp = fromInteger (toInteger (seconds orderTime) + offset)}} `shouldReturn` refusedWith 400 "bad_request") + [-601, 601] + spend ctx (RegistrationId "unknown") (covered 15000) `shouldReturn` refusedWith 404 "not_found" + amountOf ctx src `shouldReturn` Just 15000 + paidFrom ctx src `shouldReturn` [] + +testOrderChecks :: IO () +testOrderChecks = withSpend $ \ctx@Ctx {cNode = node, cStub} -> do + src <- sourceOf ctx "src" 30000 + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (1 :: Int) + spend ctx src (covered 30000) `shouldReturn` refusedWith 409 "name_taken" + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + spend ctx src (covered 30000) {sbOrder = aliceOrder {oPrice = 9000}} `shouldReturn` (409, Just $ KM.fromList [("error", "catalog_changed"), ("price", J.Number 10000)]) + setFault node "eth_getBlockByNumber" HttpFailure + spend ctx src (covered 30000) `shouldReturn` refusedWith 503 "name_check_unavailable" + clearFault node "eth_getBlockByNumber" + low <- sourceOf ctx "low" 6000 + modifyIORef' cStub $ \s -> s {ssCreateResult = Left (ProviderError "down")} + spend ctx low (difference 6000) `shouldReturn` refusedWith 503 "provider_unavailable" + modifyIORef' cStub $ \s -> s {ssCreateResult = Right sampleProviderInvoice} + fst <$> placeOrder ctx aliceOrder `shouldReturn` 200 + spend ctx src (covered 30000) {sbOrder = aliceOrder {oCommitment = commitmentOf 3}} `shouldReturn` refusedWith 409 "order_exists" + mapM (amountOf ctx) [src, low] `shouldReturn` [Just 30000, Just 6000] + mapM (paidFrom ctx) [src, low] `shouldReturn` [[], []] + +-- | Each request fails two checks, and is answered by the earlier. +testCheckOrder :: IO () +testCheckOrder = withSpend $ \ctx@Ctx {cNode = node, cStub} -> do + src <- sourceOf ctx "src" 30000 + low <- sourceOf ctx "low" 6000 + let unknown = RegistrationId "unknown" + unsealed <- KM.delete "sealed" <$> spendBody ctx unknown (covered 30000) + postSpend ctx unknown unsealed `shouldReturn` refusedWith 400 "bad_request" + spend ctx unknown (covered 30000) {sbOrder = aliceOrder {oKey = keyB}} `shouldReturn` refusedWith 404 "not_found" + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (1 :: Int) + spend ctx src (covered 31000) {sbOrder = aliceOrder {oTimestamp = seconds orderTime + 601}} `shouldReturn` refusedWith 400 "bad_request" + stale <- balanceOf ctx src + spend ctx src (covered 31000) `shouldReturn` balanceChanged stale + spend ctx src (covered 30000) {sbOrder = aliceOrder {oPrice = 9000}} `shouldReturn` refusedWith 409 "name_taken" + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + modifyIORef' cStub $ \s -> s {ssCreateResult = Left (ProviderError "down")} + spend ctx low (difference 6000) {sbOrder = aliceOrder {oPrice = 9000}} `shouldReturn` (409, Just $ KM.fromList [("error", "catalog_changed"), ("price", J.Number 10000)]) + modifyIORef' cStub $ \s -> s {ssCreateResult = Right sampleProviderInvoice} + fst <$> spend ctx src (covered 30000) `shouldReturn` 200 + spend ctx src (covered 30000) {sbOrder = aliceOrder {oKey = keyB}} `shouldReturn` refusedWith 400 "bad_request" + spend ctx src (covered 31000) {sbOrder = aliceOrder {oCommitment = commitmentOf 3}} `shouldReturn` refusedWith 409 "order_exists" + amountOf ctx src `shouldReturn` Just 20000 + +testCardMinimum :: IO () +testCardMinimum = withSpend $ \ctx -> do + small <- sourceOf ctx "small" 9951 + spend ctx small (difference 9951) {sbOrder = aliceOrder {oPrice = 9990}, sbMethod = Just "card"} `shouldReturn` (409, Just $ KM.fromList [("error", "catalog_changed"), ("price", J.Number 10000)]) + spend ctx small (difference 9951) {sbMethod = Just "card"} `shouldReturn` refusedWith 400 "bad_request" + stubCalls (cStub ctx) `shouldReturn` [] + amountOf ctx small `shouldReturn` Just 9951 + fst <$> spend ctx small (difference 9951) `shouldReturn` 200 + least <- sourceOf ctx "least" 19950 + fst <$> spend ctx least (dynamis 19950 (Just "card")) `shouldReturn` 200 + calls <- stubCalls (cStub ctx) + [odAmount d | StubCreate _ d <- calls] `shouldBe` [CurrencyAmount 49, CurrencyAmount 50] + +testSpendSizes :: IO () +testSpendSizes = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 15000 + missing <- KM.delete "sealed" <$> spendBody ctx src (covered 15000) + postSpend ctx src missing `shouldReturn` refusedWith 400 "bad_request" + spend ctx src (covered 15000) {sbOrder = aliceOrder {oSealed = T.replicate 11096 "a"}} `shouldReturn` refusedWith 400 "bad_request" + padded <- KM.insert "padding" (J.String $ T.replicate 16384 "a") <$> spendBody ctx src (covered 15000) + postSpend ctx src padded `shouldReturn` refusedWith 400 "bad_request" + longest <- spendBody ctx src (covered 15000) {sbOrder = aliceOrder {oSealed = T.replicate 11095 "a"}} + LB.length (J.encode longest) `shouldSatisfy` (< 16384) + fst <$> postSpend ctx src longest `shouldReturn` 200 + +testSpendLimit :: IO () +testSpendLimit = withSpend $ \Ctx {cClient} -> do + let attempt = statusOf <$> webRequestBody cClient "POST" "/api/registration/src/spend" [(hContentType, "application/json"), ("X-Forwarded-For", "203.0.113.9")] "{}" + replicateM_ 5 $ attempt `shouldReturn` 400 + attempt `shouldReturn` 429 + +testOverdueHolderSpent :: IO () +testOverdueHolderSpent = withSpend $ \ctx@Ctx {cStore, cClock} -> do + src <- sourceOf ctx "src" 10000 + -- by card, whose invoice does not expire by itself at the provider, past its 60 minutes + (200, held) <- spend ctx src (dynamis 10000 (Just "card")) + let holderInv = invoiceIdOf held + holder <- invoiceRegistration ctx holderInv + holderRef <- providerRef ctx holderInv + advance ctx (61 * 60) + now <- readIORef cClock + poll <- heldPoll ctx holder + rid <- registrationAnswer . snd <$> spend ctx src (timedAt now $ covered 10000) + (\(status, v) -> (status, field "version" v)) <$> woken poll `shouldReturn` (200, Just (J.toJSON $ nrVersion holder + 1)) + fmap irStatus <$> getInvoice cStore holderInv `shouldReturn` Just ISExpired + (\r -> (nrLive r, nrVersion r)) <$> invoiceRegistration ctx holderInv `shouldReturn` (False, nrVersion holder + 1) + cancels ctx `shouldReturn` [holderRef] + (\r -> (nrPhase r, nrBalanceUsed r)) <$> registrationById ctx rid `shouldReturn` (PQueued, 10000) + fmap (\b -> (blAmount b, blHold b)) <$> balanceOf ctx src `shouldReturn` Just (0, Nothing) + +-- | By card, whose invoice does not expire by itself at the provider, past its 60 minutes. +overdueCardHolder :: Ctx -> RegistrationId -> IO (NameRegistration, Text) +overdueCardHolder ctx src = do + (200, held) <- spend ctx src (difference 6000) {sbMethod = Just "card"} + let holderInv = invoiceIdOf held + holder <- invoiceRegistration ctx holderInv + holderRef <- providerRef ctx holderInv + advance ctx (61 * 60) + pure (holder, holderRef) + +-- | Whether the holder is live, its version, and its invoice's status. +holderAfter :: Ctx -> NameRegistration -> IO (Bool, Int64, Maybe InvoiceStatus) +holderAfter ctx@Ctx {cStore} NameRegistration {nrPayment} = case nrPayment of + RPInvoice _ invId -> do + r <- invoiceRegistration ctx invId + status <- fmap irStatus <$> getInvoice cStore invId + pure (nrLive r, nrVersion r, status) + other -> error $ "not a paid order: " <> show other + +testDifferenceClosesHolder :: IO () +testDifferenceClosesHolder = withSpend $ \ctx@Ctx {cClock} -> do + src <- sourceOf ctx "src" 6000 + (holder, holderRef) <- overdueCardHolder ctx src + now <- readIORef cClock + (status, v) <- spend ctx src (timedAt now $ dynamis 6000 (Just "btc")) + status `shouldBe` 200 + next <- invoiceRegistration ctx (invoiceIdOf v) + holderAfter ctx holder `shouldReturn` (False, nrVersion holder + 1, Just ISExpired) + cancels ctx `shouldReturn` [holderRef] + fmap (fmap bhHolder . blHold) <$> balanceOf ctx src `shouldReturn` Just (Just $ nrId next) + +-- | The page's "Get a new invoice": the same name with a new commitment, its earlier difference order overdue. +testSpendAgain :: IO () +testSpendAgain = withSpend $ \ctx@Ctx {cClock} -> do + src <- sourceOf ctx "src" 6000 + (holder, holderRef) <- overdueCardHolder ctx src + now <- readIORef cClock + (status, v) <- spend ctx src $ timedAt now SpendBody {sbOrder = aliceOrder {oCommitment = commitmentOf 5}, sbBalance = 6000, sbMethod = Just "card"} + status `shouldBe` 200 + next <- invoiceRegistration ctx (invoiceIdOf v) + (nrLive next, nrLabelHash next) `shouldBe` (True, nrLabelHash holder) + holderAfter ctx holder `shouldReturn` (False, nrVersion holder + 1, Just ISExpired) + cancels ctx `shouldReturn` [holderRef] + fmap (fmap bhHolder . blHold) <$> balanceOf ctx src `shouldReturn` Just (Just $ nrId next) + +testHolderCancelledMeanwhile :: IO () +testHolderCancelledMeanwhile = withSpendHook $ \hook ctx@Ctx {cStore, cWeb, cClock} -> do + src <- sourceOf ctx "src" 6000 + (200, held) <- spend ctx src (difference 6000) + let holderInv = invoiceIdOf held + advance ctx (46 * 60) + now <- readIORef cClock + onCreate hook $ cancelOpenInvoice cStore (weWaiters cWeb) Nothing holderInv now `shouldReturn` True + (status, v) <- spend ctx src (timedAt now $ dynamis 6000 (Just "btc")) + status `shouldBe` 200 + next <- invoiceRegistration ctx (invoiceIdOf v) + fmap irStatus <$> getInvoice cStore holderInv `shouldReturn` Just ISExpired + fmap (fmap bhHolder . blHold) <$> balanceOf ctx src `shouldReturn` Just (Just $ nrId next) + cancels ctx `shouldReturn` [] + +testHolderFundedMeanwhile :: IO () +testHolderFundedMeanwhile = withSpendHook $ \hook ctx@Ctx {cStore, cClock} -> do + src <- sourceOf ctx "src" 6000 + (200, held) <- spend ctx src (difference 6000) + let holderInv = invoiceIdOf held + holder <- invoiceRegistration ctx holderInv + holderRef <- providerRef ctx holderInv + advance ctx (46 * 60) + now <- readIORef cClock + onCreate hook $ settleNow ctx holderInv (SigFunded (rcv 4000 (Just "0.0006")) PaidInFull) `shouldReturn` Right ISOpen + answer <- spend ctx src (timedAt now $ dynamis 6000 (Just "btc")) + current <- balanceOf ctx src + answer `shouldBe` balanceChanged current + (fmap blAmount current, fmap bhHolder . blHold =<< current) `shouldBe` (Just 6000, Just $ nrId holder) + calls <- stubCalls (cStub ctx) + length [() | StubCreate {} <- calls] `shouldBe` 2 + refs <- cancels ctx + length refs `shouldBe` 1 + refs `shouldNotBe` [holderRef] + (fmap irStatus <$> getInvoice cStore holderInv) `shouldReturn` Just ISOpen + nrLive <$> invoiceRegistration ctx holderInv `shouldReturn` True + length <$> paidFrom ctx src `shouldReturn` 1 + +testConcurrentSpends :: IO () +testConcurrentSpends = withSpend $ \ctx -> do + src <- sourceOf ctx "src" 30000 + (a, b) <- concurrently (spend ctx src (covered 30000)) (spend ctx src (dynamis 30000 Nothing)) + sort [fst a, fst b] `shouldBe` [200, 409] + [won] <- paidFrom ctx src + current <- balanceOf ctx src + fmap blAmount current `shouldBe` Just (30000 - nrPrice won) + filter ((== 409) . fst) [a, b] `shouldBe` [balanceChanged current] + +testWriteRefusedAtBalance :: IO () +testWriteRefusedAtBalance = withSpendHook $ \hook ctx@Ctx {cOpenStore} -> do + src <- sourceOf ctx "src" 6000 + other <- cOpenStore + onCreate hook $ credit other "src" 500 + answered <- newIORef Nothing + logs <- capturingStderr $ spend ctx src (difference 6000) >>= writeIORef answered . Just + logs `shouldSatisfy` T.isInfixOf "the order was refused, so invoice pref-1 is cancelled at the provider" + Just answer <- readIORef answered + current <- balanceOf ctx src + (fmap blAmount current, blHold =<< current) `shouldBe` (Just 6500, Nothing) + answer `shouldBe` balanceChanged current + calls <- stubCalls (cStub ctx) + [() | StubCreate {} <- calls] `shouldBe` [()] + length <$> cancels ctx `shouldReturn` 1 + paidFrom ctx src `shouldReturn` [] + +testSpendRacesRefund :: IO () +testSpendRacesRefund = withSpend $ \ctx@Ctx {cStore, cOrders, cClock} -> do + src <- sourceOf ctx "src" 10000 + now <- readIORef cClock + (spent, refunded) <- concurrently (spend ctx src (covered 10000)) (recordRefund (oeTurns cOrders) cStore "src" 10000 now) + current <- balanceOf ctx src + fmap blAmount current `shouldBe` Just 0 + case refunded of + Right _ -> do + spent `shouldBe` balanceChanged current + paidFrom ctx src `shouldReturn` [] + fmap blRefunded current `shouldBe` Just 10000 + Left refusal -> do + (fst spent, refusal) `shouldBe` (200, RefundAmount 0) + length <$> paidFrom ctx src `shouldReturn` 1 + fmap blRefunded current `shouldBe` Just 0 + +testSpendTurns :: IO () +testSpendTurns = withSpend $ \ctx@Ctx {cOrders} -> do + src <- sourceOf ctx "src" 15000 + let turns = oeTurns cOrders + inside <- newEmptyMVar + proceed <- newEmptyMVar + holding <- async $ withBalanceTurn turns src $ putMVar inside () >> takeMVar proceed + takeMVar inside + spent <- async $ spend ctx src (covered 15000) + -- the spend waits for the balance's turn while it holds the name's + waiting <- timeout pollSeconds $ atomically $ do + balanceTurn <- balanceTurnCount turns src + nameTurn <- labelTurnCount turns (labelHash "alicebakery") + check (balanceTurn == 2 && nameTurn == 1) + waiting `shouldBe` Just () + putMVar proceed () + wait holding + fst <$> wait spent `shouldReturn` 200 + +-- end to end + +-- | The real BTCPay adapter against the fake, read by the poller when BTCPay's webhook asks, over the running service's store, so +-- //refund reads what the routes wrote; the clock is the wall clock, which the poller and //refund read. +withBTCPaySpend :: TestParams -> (ChatController -> FakeBTCPay -> PollerEnv -> Ctx -> IO ()) -> IO () +withBTCPaySpend ps action = withStoreService ps $ \_ _ cc -> withFakeBTCPay $ \fake -> do + btcpay <- btcpayProvider (fbConfig fake) + let viaFake :: Provider -> Provider + viaFake p = case pProvider p of + PPCrypto -> btcpay + _ -> p + withSpendOn (pure $ chatStore cc) viaFake $ \ctx@Ctx {cStore, cOrders, cWeb, cClock} -> do + getCurrentTime >>= writeIORef cClock + poller <- newPollerEnv cStore (weWaiters cWeb) (Just $ oePhases cOrders) (weHints cWeb) (weProviders cWeb) (poll $ weConfig cWeb) + action cc fake poller ctx + +-- | BTCPay shows the invoice in the state and sends the event, and the poller reads the invoice the event names. +reported :: FakeBTCPay -> PollerEnv -> Ctx -> Text -> Text -> [JT.Pair] -> IO () +reported fake poller Ctx {cClient} event ref state = do + setInvoiceState fake ref state + let body = webhookEvent event ref + statusOf <$> webRequestBody cClient "POST" "/webhooks/btcpay" (webhookSigHeader (bWebhookSecret $ fbConfig fake) body) body `shouldReturn` 200 + drainHints poller + +-- | Paid in full and settled: $100.00 at the fixtures' rate of 108000.12 dollars a bitcoin. +settledState :: [JT.Pair] +settledState = ["status" J..= ("Settled" :: Text), "paymentMethodPaid" J..= ("0.00092593" :: Text)] + +-- | $54.00 confirmed after the invoice expired, credited as 5400 cents at that rate. +latePaid :: [JT.Pair] +latePaid = + [ "additionalStatus" J..= ("PaidLate" :: Text), + "paymentMethodPaid" J..= lateBtc, + "payments" J..= [J.object ["id" J..= ("late-tx" :: Text), "receivedDate" J..= (1700003600 :: Int), "value" J..= lateBtc, "fee" J..= ("0.00000000" :: Text), "status" J..= ("Settled" :: Text)]] + ] + where + lateBtc = "0.00050000" :: Text + +ratesDown, ratesUp :: J.Value +ratesDown = J.toJSON [J.object ["currencyPair" J..= ("BTC_USD" :: Text), "errors" J..= ["no rate source answered" :: Text], "rate" J..= J.Null]] +ratesUp = J.toJSON [J.object ["currencyPair" J..= ("BTC_USD" :: Text), "errors" J..= ([] :: [Text]), "rate" J..= ("108000.12" :: Text)]] + +-- | The worker's write when another wallet holds the name: taken, with the order's whole price credited in the same transaction. +takenNow :: Ctx -> RegistrationId -> IO () +takenNow ctx@Ctx {cStore, cClock} rid = do + r <- registrationById ctx rid + now <- readIORef cClock + withTransaction cStore (\db -> updateRegistration db r {nrPhase = PTaken} now >>= \w -> w <$ creditBalance db rid (nrPrice r) now) + `shouldReturn` Written (nrVersion r + 1) + +balanceView :: Ctx -> RegistrationId -> IO (Maybe J.Value) +balanceView ctx rid = field "balance" <$> viewOf ctx rid + +-- | A balance nothing holds. +balanceObject :: Int -> Int -> Maybe J.Value +balanceObject amount refunded = Just $ J.object ["amount" J..= amount, "held" J..= False, "heldUntil" J..= J.Null, "refunded" J..= refunded] + +ridText :: RegistrationId -> Text +ridText (RegistrationId t) = t + +testSpendEndToEnd :: TestParams -> IO () +testSpendEndToEnd ps = withBTCPaySpend ps $ \cc fake poller ctx@Ctx {cClock} -> do + now <- readIORef cClock + let report :: Text -> InvoiceId -> [JT.Pair] -> IO () + report event inv state = providerRef ctx inv >>= \ref -> reported fake poller ctx event ref state + orderOf :: InvoiceId -> IO RegistrationId + orderOf inv = nrId <$> invoiceRegistration ctx inv + dynamisAgain :: Int -> SpendBody + dynamisAgain n = timedAt now $ (dynamis 10000 (Just "btc")) {sbOrder = dynamisOrder {oCommitment = commitmentOf n}} + -- alicebakery paid at BTCPay and queued by the poller, then taken by another wallet, its price kept as its balance + (srcInv@(InvoiceId srcInvText), _) <- placed ctx (orderAt now aliceOrder) + report "InvoiceSettled" srcInv settledState + src <- orderOf srcInv + nrPhase <$> registrationById ctx src `shouldReturn` PQueued + takenNow ctx src + balanceView ctx src `shouldReturn` balanceObject 10000 0 + let s = ridText src + -- the balance on dynamis, with an invoice for the difference that holds all of it until BTCPay expires it + (200, held) <- spend ctx src (dynamisAgain 2) + let firstInv = invoiceIdOf held + first <- orderOf firstInv + report "InvoiceExpired" firstInv ["status" J..= ("Expired" :: Text)] + (\r -> (nrPhase r, nrLive r)) <$> registrationById ctx first `shouldReturn` (PUnpaid, False) + balanceView ctx src `shouldReturn` balanceObject 10000 0 + -- money paid into the expired invoice: the poller's read cannot credit it while the rate read fails, and its next credit pass does + setRates fake ratesDown + report "InvoicePaymentSettled" firstInv latePaid + (\v -> (field "latePayment" v, field "balance" v)) <$> viewOf ctx first `shouldReturn` (Just $ J.object ["waiting" J..= ("crediting" :: Text)], Just J.Null) + setRates fake ratesUp + void $ capturingStderr $ forgetRates poller >> getCurrentTime >>= creditPass poller + (\v -> (field "latePayment" v, field "balance" v)) <$> viewOf ctx first `shouldReturn` (Just J.Null, balanceObject 5400 0) + balanceView ctx src `shouldReturn` balanceObject 10000 0 + -- dynamis again with a new commitment: BTCPay settles the difference, and the poller queues the order and spends the hold + (200, again) <- spend ctx src (dynamisAgain 3) + let dearerInv@(InvoiceId dearerInvText) = invoiceIdOf again + dearer <- orderOf dearerInv + let d = ridText dearer + report "InvoiceSettled" dearerInv settledState + (\r -> (nrPhase r, nrPrice r, nrBalanceSource r, nrBalanceUsed r)) <$> registrationById ctx dearer `shouldReturn` (PQueued, 20000, Just src, 10000) + balanceView ctx src `shouldReturn` balanceObject 0 0 + -- that order taken in turn keeps its whole price; a covered spend of alicebakery takes half, and support refunds the rest + takenNow ctx dearer + covering <- registrationAnswer . snd <$> spend ctx dearer (timedAt now $ (covered 20000) {sbOrder = aliceOrder {oCommitment = commitmentOf 4}}) + (\r -> (nrPhase r, nrBalanceSource r, nrBalanceUsed r)) <$> registrationById ctx covering `shouldReturn` (PQueued, Just dearer, 10000) + let paidBy = "order " <> d <> ": $100.00 by btc on invoice " <> dearerInvText <> ", $100.00 from the balance of order " <> s <> "; order " <> s <> ": $100.00 by btc on invoice " <> srcInvText + operatorCmd cc ("//refund " <> d) + `shouldReturn` Right ("Order " <> d <> ": balance $100.00 (credited $200.00, refunded $0.00). Paid by: " <> paidBy <> ". To record its refund: //refund " <> d <> " 10000") + operatorCmd cc ("//refund " <> dearerInvText <> " 10000") `shouldReturn` Right ("Recorded a refund of $100.00 for order " <> d <> ". Refund it now, by: " <> paidBy <> ".") + balanceView ctx dearer `shouldReturn` balanceObject 0 10000