store: add the names store and order signatures

This commit is contained in:
sh-agents committed 2026-11-01 15:27:04 +00:00
1 parent 3597155531
commit c7d415f706
10 files changed
+2529 -24

No files matched your search

@@ -17,6 +17,8 @@ module StoreService.Names.Abi
decodeWord64,
decodeAddress,
decodeBool,
decodeBytes32,
decodeBytes,
decodeString,
)
where
@@ -113,6 +115,9 @@ decodeBool ret =
1 -> Right True
_ -> Left AENotBool
decodeBytes32 :: ByteString -> Either AbiError ByteString
decodeBytes32 = wordAt 0
decodeBytes :: ByteString -> Either AbiError ByteString
decodeBytes ret = offsetAt 0 ret >>= bytesAt ret
@@ -1,26 +1,148 @@
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}
module StoreService.Names.Codes
( issueNameCode,
( CodeState (..),
codeState,
codeStateText,
CodeRefusal (..),
codeRefusal,
codeRefusalTag,
reserveRefusal,
readPrepaidCode,
reserveCode,
releaseCode,
spendCode,
issueNameCode,
revokeNameCode,
)
where
import Control.Applicative ((<|>))
import qualified Control.Exception as E
import Data.ByteString (ByteString)
import Data.Functor ((<&>))
import Data.Int (Int64)
import Data.Maybe (fromMaybe, isJust)
import Data.Text (Text)
import Data.Time.Clock (getCurrentTime)
import Data.Time.Clock (UTCTime, getCurrentTime)
import Simplex.Chat.Badges.Code (NamePrepaidCode, maxNameLength, minNameLength, namePrepaidCodeHash, randomNamePrepaidCode)
import Simplex.Chat.Badges.Types (BadgeCodePaymentStatus (..))
import Simplex.Chat.Bot.Store (withDB')
import Simplex.Chat.Controller (ChatController (..))
import Simplex.Messaging.Agent.Store.Common (DBStore, withTransaction)
import qualified Simplex.Messaging.Agent.Store.DB as DB
import StoreService.Config (minNameYears)
import StoreService.Group.Command (maxNameYears)
import StoreService.Names.Store (CodeHashTaken (..), NewPrepaidCode (..), insertPrepaidCode, revokePrepaidCode)
import StoreService.Names.Phases (RegistrationId)
import StoreService.Names.Store (CodeHashTaken (..), NewPrepaidCode (..), PrepaidCode (..), getPrepaidCode, getPrepaidCodeById, insertPrepaidCode, releasePrepaidCode, reservePrepaidCode, revokePrepaidCode, spendPrepaidCode)
import StoreService.Names.Turns (Turns, withCodeTurn)
import StoreService.Store (RevokeResult (..))
data CodeState = CSUnused | CSReserved | CSUsed | CSRevoked | CSExpired | CSUnpaid
deriving (Eq, Show, Enum, Bounded)
-- | A code revoked while its order held it can still be spent by that order, so a spent code reads as used.
codeState :: UTCTime -> PrepaidCode -> CodeState
codeState now PrepaidCode {pcReservedBy, pcSpentAt, pcRevokedAt, pcPaymentStatus, pcExpiresAt}
| isJust pcSpentAt = CSUsed
| isJust pcRevokedAt = CSRevoked
| isJust pcReservedBy = CSReserved
| CPSUnpaid <- pcPaymentStatus = CSUnpaid
| maybe False (<= now) pcExpiresAt = CSExpired
| otherwise = CSUnused
codeStateText :: CodeState -> Text
codeStateText = \case
CSUnused -> "unused"
CSReserved -> "reserved"
CSUsed -> "used"
CSRevoked -> "revoked"
CSExpired -> "expired"
CSUnpaid -> "unpaid"
data CodeRefusal = CRInvalid | CRUsed | CRReserved | CRExpired | CRPaymentPending | CRNotCovering
deriving (Eq, Show)
codeRefusalTag :: CodeRefusal -> Text
codeRefusalTag = \case
CRInvalid -> "code_invalid"
CRUsed -> "code_used"
CRReserved -> "code_reserved"
CRExpired -> "code_expired"
CRPaymentPending -> "payment_pending"
CRNotCovering -> "code_not_covering"
-- | Why the code cannot pay for the registration's name of this length. A code the registration
-- already holds stays good for it until spent, even if revoked or expired since.
codeRefusal :: UTCTime -> RegistrationId -> Int -> PrepaidCode -> Maybe CodeRefusal
codeRefusal now rid len code@PrepaidCode {pcReservedBy, pcSpentAt, pcMinLength}
| isJust pcSpentAt = Just CRUsed
| pcReservedBy == Just rid = covering
| otherwise = stateRefusal (codeState now code) <|> covering
where
covering
| len < pcMinLength = Just CRNotCovering
| otherwise = Nothing
stateRefusal :: CodeState -> Maybe CodeRefusal
stateRefusal = \case
CSUnused -> Nothing
CSReserved -> Just CRReserved
CSUsed -> Just CRUsed
CSRevoked -> Just CRInvalid
CSExpired -> Just CRExpired
CSUnpaid -> Just CRPaymentPending
-- | Why a conditional reservation of the code refused it, as the code reads now.
reserveRefusal :: DB.Connection -> UTCTime -> ByteString -> RegistrationId -> Int -> IO CodeRefusal
reserveRefusal db now codeHash rid len = maybe CRInvalid (fromMaybe CRReserved . codeRefusal now rid len) <$> getPrepaidCode db codeHash
readPrepaidCode :: DBStore -> NamePrepaidCode -> IO (Maybe PrepaidCode)
readPrepaidCode st code = withTransaction st (`getPrepaidCode` namePrepaidCodeHash code)
newtype ReservationRefused = ReservationRefused CodeRefusal
deriving (Show)
instance E.Exception ReservationRefused
-- | In the code's turn and one transaction, the code is checked, the write runs, then the code is reserved for the
-- registration, so the registration's row is locked before the code's. A refused reservation rolls the write back.
reserveCode :: Turns -> DBStore -> UTCTime -> ByteString -> RegistrationId -> Int -> (DB.Connection -> IO (Either e a)) -> IO (Either CodeRefusal (Either e a))
reserveCode turns st now codeHash rid len write =
withCodeTurn turns codeHash $ either (\(ReservationRefused refusal) -> Left refusal) id <$> E.try (withTransaction st reserve)
where
reserve db =
getPrepaidCode db codeHash >>= \case
Nothing -> pure $ Left CRInvalid
Just code@PrepaidCode {pcId, pcReservedBy}
| Just refusal <- codeRefusal now rid len code -> pure $ Left refusal
| otherwise ->
write db >>= \case
written@(Right _)
| pcReservedBy /= Just rid ->
reservePrepaidCode db pcId rid now >>= \case
True -> pure $ Right written
-- Only a writer outside this process, which takes no turn here, can refuse it.
False -> E.throwIO . ReservationRefused =<< reserveRefusal db now codeHash rid len
written -> pure $ Right written
-- | The write runs first, and the code is released only if it succeeds. False when the registration did not hold the code.
releaseCode :: Turns -> DBStore -> Int64 -> RegistrationId -> (DB.Connection -> IO (Either e a)) -> IO (Either e (a, Bool))
releaseCode turns st codeId rid = afterWrite turns st codeId (\db -> releasePrepaidCode db codeId rid)
-- | The write runs first, and the code is spent only if it succeeds. False when the registration did not hold the code.
spendCode :: Turns -> DBStore -> UTCTime -> Int64 -> RegistrationId -> (DB.Connection -> IO (Either e a)) -> IO (Either e (a, Bool))
spendCode turns st now codeId rid = afterWrite turns st codeId (\db -> spendPrepaidCode db codeId rid now)
afterWrite :: Turns -> DBStore -> Int64 -> (DB.Connection -> IO Bool) -> (DB.Connection -> IO (Either e a)) -> IO (Either e (a, Bool))
afterWrite turns st codeId change write = do
codeHash_ <- withTransaction st $ \db -> fmap pcCodeHash <$> getPrepaidCodeById db codeId
let run = withTransaction st $ \db -> write db >>= traverse (\a -> (a,) <$> change db)
maybe run (\codeHash -> withCodeTurn turns codeHash run) codeHash_
-- | The code table keeps only the hash, so the caller must deliver the code.
issueNameCode :: ChatController -> Int -> Int -> BadgeCodePaymentStatus -> IO (Either String NamePrepaidCode)
issueNameCode cc len years paymentStatus
@@ -39,11 +161,12 @@ issueNameCode cc len years paymentStatus
revokeNameCode :: Turns -> ChatController -> NamePrepaidCode -> IO (Either Text Text)
revokeNameCode turns cc code = withCodeTurn turns codeHash $ do
now <- getCurrentTime
withDB' "revokeNameCode" cc (\db -> revokePrepaidCode db codeHash now) <&> \case
Right (Revoked _) -> Right "Revoked."
Right (AlreadyRevoked _) -> Right "Already revoked."
Right AlreadyRedeemed -> Left "Already used. It cannot be revoked."
Right NoSuchCode -> Left "No such code."
withDB' "revokeNameCode" cc (\db -> (,) <$> revokePrepaidCode db codeHash now <*> getPrepaidCode db codeHash) <&> \case
Right (Revoked _, Just PrepaidCode {pcReservedBy = Just _}) -> Right "Revoked. The order holding it keeps it."
Right (Revoked _, _) -> Right "Revoked."
Right (AlreadyRevoked _, _) -> Right "Already revoked."
Right (AlreadyRedeemed, _) -> Left "Already used. It cannot be revoked."
Right (NoSuchCode, _) -> Left "No such code."
Left _ -> Left "The code could not be revoked."
where
codeHash = namePrepaidCodeHash code
@@ -0,0 +1,65 @@
{-# LANGUAGE NamedFieldPuns #-}
module StoreService.Names.Phases (Phases, RegistrationId (..), newPhases, publish, awaitChange, phasesCount, phasesWaiting) where
import Control.Concurrent.STM
import Control.Exception (bracket)
import Data.Int (Int64)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Text (Text)
newtype RegistrationId = RegistrationId Text
deriving (Eq, Ord, Show)
-- | wVersion only grows, so a publish that arrives after a newer one cannot wake anyone.
data Watch = Watch {wVersion :: TVar Int64, wRefs :: TVar Int}
newtype Phases = Phases (TVar (Map RegistrationId Watch))
newPhases :: IO Phases
newPhases = Phases <$> newTVarIO Map.empty
-- | Call after the transaction that wrote this version commits.
publish :: Phases -> RegistrationId -> Int64 -> STM ()
publish (Phases watches) rid version =
readTVar watches >>= mapM_ (\Watch {wVersion} -> modifyTVar' wVersion (max version)) . Map.lookup rid
-- | The registrations with a waiter.
phasesCount :: Phases -> IO Int
phasesCount (Phases watches) = Map.size <$> readTVarIO watches
-- | The waiters across all registrations.
phasesWaiting :: Phases -> STM Int
phasesWaiting (Phases watches) = readTVar watches >>= fmap sum . mapM (\Watch {wRefs} -> readTVar wRefs) . Map.elems
subscribe :: Phases -> RegistrationId -> STM Watch
subscribe (Phases watches) rid =
readTVar watches >>= \ws -> case Map.lookup rid ws of
Just watch@Watch {wRefs} -> watch <$ modifyTVar' wRefs (+ 1)
Nothing -> do
watch <- Watch <$> newTVar minBound <*> newTVar 1
watch <$ writeTVar watches (Map.insert rid watch ws)
release :: Phases -> RegistrationId -> STM ()
release (Phases watches) rid =
readTVar watches >>= \ws -> mapM_ (drop' ws) (Map.lookup rid ws)
where
drop' ws Watch {wRefs} = do
n <- pred <$> readTVar wRefs
if n <= 0 then writeTVar watches (Map.delete rid ws) else writeTVar wRefs n
-- | True once the version differs from @seen@, False after @micros@ without a change.
-- Subscribes before reading the version, so a publish between the read and the wait is not missed.
awaitChange :: Phases -> RegistrationId -> IO Int64 -> Int64 -> Int -> IO Bool
awaitChange phases rid readVersion seen micros =
bracket (atomically $ subscribe phases rid) (const . atomically $ release phases rid) $ \Watch {wVersion} -> do
current <- readVersion
atomically $ modifyTVar' wVersion (max current)
if current /= seen
then pure True
else do
timer <- registerDelay micros
atomically $
(readTVar wVersion >>= \v -> if v > seen then pure True else retry)
`orElse` (False <$ (readTVar timer >>= check))
@@ -0,0 +1,110 @@
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
module StoreService.Names.Signatures
( SignatureError (..),
AddressError (..),
OrderFields (..),
parseSignature,
personalDigest,
orderMessage,
parseChecksumAddress,
parseAnyCaseAddress,
)
where
import Control.Monad (unless, when)
import Crypto.Number.Serialize (os2ip)
import qualified Crypto.PubKey.ECC.Types as ECC
import Data.Bifunctor (first)
import Data.ByteArray.Encoding (Base (Base16), convertFromBase)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as BC
import Data.Char (isAsciiLower, isDigit, isHexDigit)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Text.Encoding (encodeUtf8)
import Data.Word (Word64)
import Simplex.Messaging.Crypto (keccak256, sha256Hash)
import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature (..))
import Simplex.Messaging.Encoding.String (strDecode, strEncode)
import Simplex.Messaging.Eth.Address (Address)
import Simplex.Messaging.SimplexName (LabelHash (..))
import Simplex.Messaging.Util (tshow)
import StoreService.Names.Abi (hex)
data SignatureError
= SEFormat
| SERecoveryId
| SEHighS
deriving (Eq, Show)
data AddressError
= ADFormat
| ADChecksum
deriving (Eq, Show)
-- | The fields an owner signs in an order and in another name for it.
data OrderFields = OrderFields
{ ofLabelHash :: LabelHash,
ofLength :: Int,
ofDuration :: Word64,
ofCommitment :: ByteString,
ofSealed :: Text
}
deriving (Eq)
signatureHexLength :: Int
signatureHexLength = 130
scalarSize :: Int
scalarSize = 32
addressHexLength :: Int
addressHexLength = 40
-- the contracts' SignatureChecker refuses a higher s, though recovery accepts it
maxS :: Integer
maxS = ECC.ecc_n (ECC.common_curve $ ECC.getCurveByName ECC.SEC_p256k1) `div` 2
parseSignature :: Text -> Either SignatureError RecoverableSignature
parseSignature t = do
h <- maybe (Left SEFormat) Right $ T.stripPrefix "0x" t
unless (T.length h == signatureHexLength && T.all isLowerHex h) $ Left SEFormat
sig <- first (const SEFormat) $ convertFromBase Base16 (encodeUtf8 h)
let (rsR, (rsS, v)) = B.splitAt scalarSize <$> B.splitAt scalarSize sig
rsRecId <- case B.unpack v of
[27] -> Right 0
[28] -> Right 1
_ -> Left SERecoveryId
when (os2ip rsS > maxS) $ Left SEHighS
pure RecoverableSignature {rsR, rsS, rsRecId}
where
isLowerHex c = isDigit c || (isAsciiLower c && isHexDigit c)
-- | EIP-191 @personal_sign@ digest.
personalDigest :: ByteString -> ByteString
personalDigest msg = keccak256 $ "\x19\&Ethereum Signed Message:\n" <> BC.pack (show $ B.length msg) <> msg
orderMessage :: OrderFields -> Word64 -> ByteString
orderMessage order timestamp = message $ ["order"] <> orderWords order <> [tshow timestamp]
message :: [Text] -> ByteString
message = encodeUtf8 . T.unwords . ("simplex.domains" :)
orderWords :: OrderFields -> [Text]
orderWords OrderFields {ofLabelHash = LabelHash labelHash, ofLength, ofDuration, ofCommitment, ofSealed} =
[hex labelHash, tshow ofLength, tshow ofDuration, hex ofCommitment, hex $ sha256Hash $ encodeUtf8 ofSealed]
-- the address parser checks EIP-55 only on mixed-case hex, so one-case text is refused here by comparing the encoding
parseChecksumAddress :: Text -> Either AddressError Address
parseChecksumAddress t = do
a <- parseAnyCaseAddress t
unless (strEncode a == encodeUtf8 t) $ Left ADChecksum
pure a
parseAnyCaseAddress :: Text -> Either AddressError Address
parseAnyCaseAddress t = case T.stripPrefix "0x" t of
Just h | T.length h == addressHexLength && T.all isHexDigit h -> first (const ADFormat) $ strDecode $ encodeUtf8 $ T.toLower h
_ -> Left ADFormat
@@ -1,30 +1,92 @@
{-# LANGUAGE CPP #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TypeOperators #-}
module StoreService.Names.Store
( PrepaidCode (..),
( NamePhase (..),
RegistrationPayment (..),
NameReveal (..),
NameRegistration (..),
NewRegistration (..),
PaidOrder (..),
RegistrationRefused (..),
VersionWrite (..),
LiveOrder (..),
OrderTerms (..),
PrepaidCode (..),
NewPrepaidCode (..),
CodeHashTaken (..),
TxFor (..),
TxStatus (..),
NameTransaction (..),
NewTransaction (..),
findLimit,
orderHash,
orderLive,
newRegistrationId,
methodText,
textMethod,
createPaidRegistration,
createCodeRegistration,
getRegistration,
getRegistrationByOrderHash,
getLiveOrders,
closeOverdue,
updateRegistration,
findRegistrations,
isLabelRegistering,
activeRegistrations,
unpaidCleanupCandidates,
deleteUnpaidRegistration,
failedCodeOrdersBefore,
insertPrepaidCode,
getPrepaidCode,
getPrepaidCodeById,
reservePrepaidCode,
releasePrepaidCode,
spendPrepaidCode,
revokePrepaidCode,
insertTransaction,
recordTransactionOutcome,
pendingTransactions,
registrationTransactions,
)
where
import qualified Control.Exception as E
import Control.Monad (when)
import Crypto.Number.Serialize (i2ospOf_)
import Data.ByteArray.Encoding (Base (Base16), convertToBase)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import Data.Int (Int64)
import Data.Maybe (isJust)
import Data.Functor ((<&>))
import Data.Maybe (isJust, listToMaybe)
import Data.Text (Text)
import Data.Text.Encoding (encodeUtf8)
import Data.Time.Clock (UTCTime)
import Data.Word (Word64)
import Simplex.Chat.Badges.Types (BadgeCodePaymentStatus (..))
import Simplex.Chat.PaymentService.Types (CardProvider (..), CryptoCurrency (..), InvoiceId (..), InvoiceStatus (..), ServicePaymentMethod (..))
import Simplex.Chat.Store.Shared (insertedRowId)
import Simplex.Messaging.Agent.Store.DB (Binary (..))
import Simplex.Messaging.Agent.Store.DB (Binary (..), BoolInt (..), FromField (..), ToField (..), fromTextField_)
import qualified Simplex.Messaging.Agent.Store.DB as DB
import Simplex.Messaging.Util (maybeFirstRow)
import Simplex.Messaging.Crypto (sha256Hash)
import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature)
import Simplex.Messaging.Encoding.String (TextEncoding (..), strDecode)
import Simplex.Messaging.Eth.Address (Address, unAddress)
import Simplex.Messaging.Eth.EIP712 (serializeSignature)
import Simplex.Messaging.SimplexName (LabelHash (..))
import Simplex.Messaging.Util (maybeFirstRow, tshow)
import StoreService.Names.Abi (hex)
import StoreService.Names.Chain (TxHash (..))
import StoreService.Names.Phases (RegistrationId (..))
import StoreService.Names.Signatures (OrderFields (..), parseSignature)
import StoreService.Store (RevokeResult (..))
import StoreService.Store.Invoices (executeChanging, truncateToSecond)
import StoreService.Store.Invoices (StoreDecodeError (..), executeChanging, invoiceStatusText, lockInvoice, newInvoiceId, truncateToSecond, unfundedQuery)
#if defined(dbPostgres)
import Database.PostgreSQL.Simple (Only (..), Query, (:.) (..))
@@ -34,12 +96,123 @@ import Database.SQLite.Simple (Only (..), Query, (:.) (..))
import Database.SQLite.Simple.QQ (sql)
#endif
data NamePhase
= PUnpaid
| PQueued
| PCommitting
| PCommitted
| PRegistering
| PRegistered
| PTaken
| PFailed
deriving (Eq, Show, Enum, Bounded)
instance TextEncoding NamePhase where
textEncode = \case
PUnpaid -> "unpaid"
PQueued -> "queued"
PCommitting -> "committing"
PCommitted -> "committed"
PRegistering -> "registering"
PRegistered -> "registered"
PTaken -> "taken"
PFailed -> "failed"
textDecode t = lookup t [(textEncode p, p) | p <- [minBound .. maxBound]]
instance FromField NamePhase where fromField = fromTextField_ textDecode
instance ToField NamePhase where toField = toField . textEncode
data RegistrationPayment
= RPInvoice ServicePaymentMethod InvoiceId
| RPCode Int64
deriving (Eq, Show)
-- | The name, links and owner's intent, all set by an accepted reveal and cleared together.
data NameReveal = NameReveal
{ rvLabel :: Text,
rvSecret :: ByteString,
rvContactLink :: Maybe Text,
rvChannelLink :: Maybe Text,
rvNonce :: Word64,
rvDeadline :: Word64,
rvSignature :: RecoverableSignature
}
deriving (Eq, Show)
data NameRegistration = NameRegistration
{ nrId :: RegistrationId,
nrVersion :: Int64,
nrLabelHash :: LabelHash,
nrLength :: Int,
nrDuration :: Word64,
nrOwner :: Address,
nrCommitment :: ByteString,
nrSealed :: Text,
nrPhase :: NamePhase,
nrYears :: Int,
nrPrice :: Int,
nrPayment :: RegistrationPayment,
nrReveal :: Maybe NameReveal,
nrCommitTx :: Maybe TxHash,
nrCommitBlock :: Maybe Word64,
nrRegisterTx :: Maybe TxHash,
nrRegisterBlock :: Maybe Word64,
nrRevealAfter :: Maybe Word64,
nrRevealBefore :: Maybe Word64,
nrExpiresAt :: Maybe Word64,
nrRegisteredAt :: Maybe UTCTime,
nrFailedAt :: Maybe UTCTime,
nrError :: Maybe Text,
nrLive :: Bool,
nrOrderHash :: ByteString,
nrMoves :: Int,
nrLinksRefusedAt :: Maybe UTCTime,
nrCreatedAt :: UTCTime,
nrUpdatedAt :: UTCTime
}
deriving (Eq, Show)
data NewRegistration = NewRegistration
{ nrgId :: RegistrationId,
nrgOwner :: Address,
nrgOrder :: OrderFields,
nrgYears :: Int
}
-- | The invoice row is inserted by the caller, in the same transaction and before the registration.
data PaidOrder = PaidOrder
{ poMethod :: ServicePaymentMethod,
poPrice :: Int,
poInvoiceId :: InvoiceId,
poProviderRef :: Text
}
data RegistrationRefused = RRLiveOrder | RRCodeNotReservable
deriving (Eq, Show)
-- | NotLive: the write would make a closed order live. LiveOrderExists: another live order holds its commitment, or its owner and label hash.
data VersionWrite = Written Int64 | VersionChanged | NotLive | LiveOrderExists
deriving (Eq, Show)
-- | A live order an order request meets; overdue when its open invoice is past its expiry time.
data LiveOrder = LiveOrder
{ loRegistration :: NameRegistration,
loOverdue :: Bool
}
deriving (Eq, Show)
-- | What an order pays with, as its hash covers it.
data OrderTerms = OTInvoice ServicePaymentMethod Int | OTCode ByteString
data PrepaidCode = PrepaidCode
{ pcId :: Int64,
pcCodeHash :: ByteString,
pcMinLength :: Int,
pcYears :: Int,
pcPaymentStatus :: BadgeCodePaymentStatus,
pcReservedBy :: Maybe RegistrationId,
pcReservedAt :: Maybe UTCTime,
pcSpentAt :: Maybe UTCTime,
pcRevokedAt :: Maybe UTCTime,
pcExpiresAt :: Maybe UTCTime,
@@ -58,6 +231,383 @@ data NewPrepaidCode = NewPrepaidCode
data CodeHashTaken = CodeHashTaken
deriving (Eq, Show)
data TxFor = TxCommit RegistrationId | TxRegister RegistrationId
deriving (Eq, Show)
-- | A dropped transaction has no receipt and its registrar nonce is used.
data TxStatus = TSPending | TSMined | TSReverted | TSDropped
deriving (Eq, Show, Enum, Bounded)
instance TextEncoding TxStatus where
textEncode = \case
TSPending -> "pending"
TSMined -> "mined"
TSReverted -> "reverted"
TSDropped -> "dropped"
textDecode t = lookup t [(textEncode s, s) | s <- [minBound .. maxBound]]
instance FromField TxStatus where fromField = fromTextField_ textDecode
instance ToField TxStatus where toField = toField . textEncode
data NameTransaction = NameTransaction
{ ntId :: Int64,
ntFor :: TxFor,
ntRaw :: ByteString,
ntHash :: TxHash,
ntNonce :: Word64,
ntSentAt :: UTCTime,
ntMinedBlock :: Maybe Word64,
ntStatus :: TxStatus
}
deriving (Eq, Show)
data NewTransaction = NewTransaction
{ ntxRaw :: ByteString,
ntxHash :: TxHash,
ntxNonce :: Word64
}
findLimit :: Int
findLimit = 50
initialVersion :: Int64
initialVersion = 1
orderHashFieldBytes :: Int
orderHashFieldBytes = 4
-- | Each field is length-prefixed, so no two different orders encode the same.
orderHash :: Address -> OrderFields -> OrderTerms -> ByteString
orderHash owner OrderFields {ofLabelHash = LabelHash lh, ofLength, ofDuration, ofCommitment, ofSealed} terms =
sha256Hash . B.concat . map field $ [tag, lh, num ofLength, num ofDuration, unAddress owner, ofCommitment, encodeUtf8 ofSealed] <> payment
where
(tag, payment) = case terms of
OTInvoice method price -> ("name-invoice", [encodeUtf8 $ methodText method, num price])
OTCode codeHash -> ("name-code", [codeHash])
field bs = i2ospOf_ orderHashFieldBytes (toInteger $ B.length bs) <> bs
num :: Show a => a -> ByteString
num = encodeUtf8 . tshow
newRegistrationId :: IO RegistrationId
newRegistrationId = (\(InvoiceId t) -> RegistrationId t) <$> newInvoiceId
methodText :: ServicePaymentMethod -> Text
methodText = \case
SPMCard CPStripe -> "card"
SPMCrypto CCBtc -> "btc"
SPMCrypto CCXmr -> "xmr"
textMethod :: Text -> Maybe ServicePaymentMethod
textMethod t = lookup t [(methodText m, m) | m <- [SPMCard CPStripe, SPMCrypto CCBtc, SPMCrypto CCXmr]]
createPaidRegistration :: DB.Connection -> NewRegistration -> PaidOrder -> UTCTime -> IO (Either RegistrationRefused ())
createPaidRegistration db new@NewRegistration {nrgId = RegistrationId rid, nrgOwner, nrgOrder} PaidOrder {poMethod, poPrice, poInvoiceId = InvoiceId invId, poProviderRef} now' = do
let now = truncateToSecond now'
hash = orderHash nrgOwner nrgOrder (OTInvoice poMethod poPrice)
inserted <- insertRegistration db new PUnpaid poPrice (Just poMethod) Nothing hash now
when inserted $
DB.execute
db
"INSERT INTO sx_badge_service_name_invoices (invoice_id, registration_id, provider_ref, created_at) VALUES (?,?,?,?)"
(invId, rid, poProviderRef, now)
pure $ if inserted then Right () else Left RRLiveOrder
-- | Reserving the code is the conditional update of the transaction that creates the registration.
createCodeRegistration :: DB.Connection -> NewRegistration -> PrepaidCode -> UTCTime -> IO (Either RegistrationRefused ())
createCodeRegistration db new@NewRegistration {nrgId = regId@(RegistrationId rid), nrgOwner, nrgOrder} PrepaidCode {pcId, pcCodeHash} now' = do
let now = truncateToSecond now'
inserted <- insertRegistration db new PQueued 0 Nothing (Just pcId) (orderHash nrgOwner nrgOrder (OTCode pcCodeHash)) now
if not inserted
then pure $ Left RRLiveOrder
else
reservePrepaidCode db pcId regId now >>= \case
True -> pure $ Right ()
False -> do
DB.execute db "DELETE FROM sx_badge_service_name_registrations WHERE registration_id = ?" (Only rid)
pure $ Left RRCodeNotReservable
-- | False when the registration would be a second live one for its commitment, or for its owner and label hash.
insertRegistration :: DB.Connection -> NewRegistration -> NamePhase -> Int -> Maybe ServicePaymentMethod -> Maybe Int64 -> ByteString -> UTCTime -> IO Bool
insertRegistration db NewRegistration {nrgId = RegistrationId rid, nrgOwner, nrgOrder, nrgYears} phase price method codeId hash now =
(> 0)
<$> executeChanging
db
[sql|
INSERT INTO sx_badge_service_name_registrations
(registration_id, version, label_hash, length, duration, owner, commitment, sealed, phase, years,
price, method, name_prepaid_code_id, live, order_hash, moves, created_at, updated_at)
VALUES (?,?,?,?,?,?,?,?,?,?, ?,?,?,?,?,?,?,?)
ON CONFLICT DO NOTHING
|]
( (rid, initialVersion, Binary lh, ofLength, int64 ofDuration, Binary $ unAddress nrgOwner, Binary ofCommitment, ofSealed, phase, nrgYears)
:. (price, methodText <$> method, codeId, BI True, Binary hash, 0 :: Int, now, now)
)
where
OrderFields {ofLabelHash = LabelHash lh, ofLength, ofDuration, ofCommitment, ofSealed} = nrgOrder
registrationColumns :: Query
registrationColumns =
[sql|
SELECT r.registration_id, r.version, r.label_hash, r.length, r.duration, r.owner, r.commitment, r.sealed, r.phase, r.years,
r.price, r.method, ni.invoice_id, r.name_prepaid_code_id, r.label, r.secret, r.contact_link, r.channel_link, r.intent_nonce, r.intent_deadline,
r.intent_signature, r.commit_tx, r.commit_block, r.register_tx, r.register_block, r.reveal_after, r.reveal_before, r.expires_at, r.registered_at,
r.failed_at, r.error, r.live, r.order_hash, r.moves, r.links_refused_at, r.created_at, r.updated_at
|]
registrationFrom :: Query
registrationFrom =
" "
<> [sql|
FROM sx_badge_service_name_registrations r
LEFT JOIN sx_badge_service_name_invoices ni ON ni.registration_id = r.registration_id
|]
selectRegistrations :: Query
selectRegistrations = registrationColumns <> registrationFrom
type RegistrationRow =
(Text, Int64, Binary ByteString, Int, Int64, Binary ByteString, Binary ByteString, Text, NamePhase, Int)
:. (Int, Maybe Text, Maybe Text, Maybe Int64, Maybe Text, Maybe (Binary ByteString), Maybe Text, Maybe Text, Maybe Int64, Maybe Int64)
:. (Maybe (Binary ByteString), Maybe (Binary ByteString), Maybe Int64, Maybe (Binary ByteString), Maybe Int64, Maybe Int64, Maybe Int64, Maybe Int64, Maybe UTCTime)
:. (Maybe UTCTime, Maybe Text, BoolInt, Binary ByteString, Int, Maybe UTCTime, UTCTime, UTCTime)
toRegistration :: RegistrationRow -> Either Text NameRegistration
toRegistration
( (rid, nrVersion, Binary lh, nrLength, duration, Binary owner, Binary nrCommitment, nrSealed, nrPhase, nrYears)
:. (nrPrice, method_, invoiceId_, codeId_, label_, secret_, nrContactLink, nrChannelLink, nonce_, deadline_)
:. (signature_, commitTx, commitBlock, registerTx, registerBlock, revealAfter, revealBefore, expiresAt, nrRegisteredAt)
:. (nrFailedAt, nrError, BI nrLive, Binary nrOrderHash, nrMoves, nrLinksRefusedAt, nrCreatedAt, nrUpdatedAt)
) = do
nrOwner <- decodeAddress owner
nrPayment <- case (method_, invoiceId_, codeId_) of
(Just m, Just invId, Nothing) -> (`RPInvoice` InvoiceId invId) <$> note ("name_registrations.method: " <> m) (textMethod m)
(Nothing, Nothing, Just codeId) -> Right $ RPCode codeId
_ -> Left $ "name_registrations payment: " <> rid
nrReveal <- case (label_, secret_, nonce_, deadline_, signature_) of
(Nothing, Nothing, Nothing, Nothing, Nothing) -> Right Nothing
(Just rvLabel, Just (Binary rvSecret), Just nonce, Just deadline, Just (Binary sig)) -> do
rvSignature <- decodeSignature sig
Right $ Just NameReveal {rvLabel, rvSecret, rvContactLink = nrContactLink, rvChannelLink = nrChannelLink, rvNonce = word64 nonce, rvDeadline = word64 deadline, rvSignature}
_ -> Left $ "name_registrations reveal: " <> rid
pure
NameRegistration
{ nrId = RegistrationId rid,
nrVersion,
nrLabelHash = LabelHash lh,
nrLength,
nrDuration = word64 duration,
nrOwner,
nrCommitment,
nrSealed,
nrPhase,
nrYears,
nrPrice,
nrPayment,
nrReveal,
nrCommitTx = txHash <$> commitTx,
nrCommitBlock = word64 <$> commitBlock,
nrRegisterTx = txHash <$> registerTx,
nrRegisterBlock = word64 <$> registerBlock,
nrRevealAfter = word64 <$> revealAfter,
nrRevealBefore = word64 <$> revealBefore,
nrExpiresAt = word64 <$> expiresAt,
nrRegisteredAt,
nrFailedAt,
nrError,
nrLive,
nrOrderHash,
nrMoves,
nrLinksRefusedAt,
nrCreatedAt,
nrUpdatedAt
}
getRegistration :: DB.Connection -> RegistrationId -> IO (Maybe NameRegistration)
getRegistration db (RegistrationId rid) =
firstDecoded toRegistration $ DB.query db (selectRegistrations <> " WHERE r.registration_id = ?") (Only rid)
-- | The newest stored order, live or not, with exactly these fields.
getRegistrationByOrderHash :: DB.Connection -> ByteString -> IO (Maybe NameRegistration)
getRegistrationByOrderHash db hash =
firstDecoded toRegistration $
DB.query db (selectRegistrations <> " WHERE r.order_hash = ? ORDER BY r.created_at DESC, r.registration_id DESC LIMIT 1") (Only $ Binary hash)
-- | Overdue whatever status the poller has marked, as long as the invoice is not paid and holds no money, as the sweep decides.
getLiveOrders :: DB.Connection -> ByteString -> Address -> LabelHash -> UTCTime -> IO [LiveOrder]
getLiveOrders db commitment owner (LabelHash lh) now =
DB.query
db
( registrationColumns
<> ", CASE WHEN r.phase = ? AND i.status <> ? AND i.expires_at < ?"
<> unfunded
<> " THEN 1 ELSE 0 END"
<> registrationFrom
<> " LEFT JOIN sx_badge_service_invoices i ON i.invoice_id = ni.invoice_id"
<> " WHERE r.live = 1 AND (r.commitment = ? OR (r.owner = ? AND r.label_hash = ?))"
)
(PUnpaid, invoiceStatusText ISPaid, truncateToSecond now, Binary commitment, Binary $ unAddress owner, Binary lh)
>>= decodeAll toLiveOrder
where
toLiveOrder (row :. Only (BI loOverdue)) = (\loRegistration -> LiveOrder {loRegistration, loOverdue}) <$> toRegistration row
-- | The sweep's own check, on the invoice joined as i.
unfunded :: Query
unfunded = unfundedQuery "i.invoice_id"
-- | Run in the transaction that inserts the next order, so the unique constraints let it in; the registration's new version.
-- Nothing when the order changed since it was read, or its invoice is no longer open, not past its expiry, or holds money: the caller rolls back,
-- since the invoice is written before the registration, as settlement, cancel and the sweep write them.
closeOverdue :: DB.Connection -> NameRegistration -> UTCTime -> IO (Maybe Int64)
closeOverdue db r@NameRegistration {nrId = RegistrationId rid, nrVersion, nrPayment} now = do
-- locked first, so the funding check below, a later statement, sees a payment a concurrent settlement committed
mapM_ (\invId -> lockInvoice db invId now) $ case nrPayment of
RPInvoice _ invId -> Just invId
RPCode _ -> Nothing
expired <-
executeChanging
db
( [sql|
UPDATE sx_badge_service_invoices SET status = ?, updated_at = ?
WHERE status = ? AND invoice_id IN (
SELECT i.invoice_id FROM sx_badge_service_name_invoices ni
JOIN sx_badge_service_name_registrations r ON r.registration_id = ni.registration_id
JOIN sx_badge_service_invoices i ON i.invoice_id = ni.invoice_id
WHERE ni.registration_id = ? AND r.version = ? AND r.live = 1 AND i.expires_at < ?
|]
<> unfunded
<> " )"
)
(invoiceStatusText ISExpired, truncateToSecond now, invoiceStatusText ISOpen, rid, nrVersion, truncateToSecond now)
if expired > 0
then
updateRegistration db r {nrLive = False} now <&> \case
Written v -> Just v
_ -> Nothing
else pure Nothing
-- | Whether an order can still progress to a registration for its name. The unique live indexes allow one such order per commitment,
-- and one per owner and label hash, so a wallet can order a name again once its registration is done.
-- An unpaid order is live while its invoice is open, which nrLive carries; a taken order is final.
orderLive :: NameRegistration -> Bool
orderLive NameRegistration {nrPhase, nrLive} = case nrPhase of
PUnpaid -> nrLive
PQueued -> True
PCommitting -> True
PCommitted -> True
PRegistering -> True
PFailed -> True
PTaken -> False
PRegistered -> False
-- | Writes every changeable field of a registration read at its nrVersion, unless it changed since, with live as orderLive decides.
-- A closed order is never made live again, and a write that would make the order meet another live one changes nothing.
updateRegistration :: DB.Connection -> NameRegistration -> UTCTime -> IO VersionWrite
updateRegistration db r now = do
changed <-
executeChanging
db
[sql|
UPDATE sx_badge_service_name_registrations
SET version = version + 1, label_hash = ?, length = ?, duration = ?, commitment = ?, sealed = ?, phase = ?, price = ?,
label = ?, secret = ?, contact_link = ?, channel_link = ?, intent_nonce = ?, intent_deadline = ?, intent_signature = ?,
commit_tx = ?, commit_block = ?, register_tx = ?, register_block = ?, reveal_after = ?, reveal_before = ?, expires_at = ?,
registered_at = ?, failed_at = ?, error = ?, live = ?, moves = ?, links_refused_at = ?, updated_at = ?
WHERE registration_id = ? AND version = ?
AND (? = 0 OR (live = 1 AND NOT EXISTS (
SELECT 1 FROM sx_badge_service_name_registrations o
WHERE o.live = 1 AND o.registration_id <> ? AND (o.commitment = ? OR (o.owner = ? AND o.label_hash = ?))
)))
|]
( (Binary lh, nrLength, int64 nrDuration, Binary nrCommitment, nrSealed, nrPhase, nrPrice)
:. (rvLabel <$> nrReveal, Binary . rvSecret <$> nrReveal, rvContactLink =<< nrReveal, rvChannelLink =<< nrReveal, int64 . rvNonce <$> nrReveal, int64 . rvDeadline <$> nrReveal, Binary . serializeSignature . rvSignature <$> nrReveal)
:. (txHashField <$> nrCommitTx, int64 <$> nrCommitBlock, txHashField <$> nrRegisterTx, int64 <$> nrRegisterBlock, int64 <$> nrRevealAfter, int64 <$> nrRevealBefore, int64 <$> nrExpiresAt)
:. (truncateToSecond <$> nrRegisteredAt, truncateToSecond <$> nrFailedAt, nrError, BI live, nrMoves, truncateToSecond <$> nrLinksRefusedAt, truncateToSecond now)
:. (rid, nrVersion, BI live, rid, Binary nrCommitment, Binary $ unAddress nrOwner, Binary lh)
)
if changed > 0 then pure $ Written (nrVersion + 1) else refusal
where
NameRegistration {nrId = RegistrationId rid, nrVersion, nrLabelHash = LabelHash lh, nrLength, nrDuration, nrOwner, nrCommitment, nrSealed, nrPhase, nrPrice, nrReveal} = r
NameRegistration {nrCommitTx, nrCommitBlock, nrRegisterTx, nrRegisterBlock, nrRevealAfter, nrRevealBefore, nrExpiresAt} = r
NameRegistration {nrRegisteredAt, nrFailedAt, nrError, nrMoves, nrLinksRefusedAt} = r
live = orderLive r
refusal =
DB.query db "SELECT version, live FROM sx_badge_service_name_registrations WHERE registration_id = ?" (Only rid) >>= \case
[(version, BI storedLive)] | version == nrVersion -> pure $ if storedLive then LiveOrderExists else NotLive
_ -> pure VersionChanged
-- | Newest first, at most findLimit.
findRegistrations :: DB.Connection -> Address -> IO [NameRegistration]
findRegistrations db owner =
DB.query db (selectRegistrations <> " WHERE r.owner = ? ORDER BY r.created_at DESC, r.registration_id DESC LIMIT ?") (Binary $ unAddress owner, findLimit)
>>= decodeAll toRegistration
isLabelRegistering :: DB.Connection -> LabelHash -> IO Bool
isLabelRegistering db (LabelHash lh) =
not . null
<$> ( DB.query db "SELECT 1 FROM sx_badge_service_name_registrations WHERE label_hash = ? AND phase = ? LIMIT 1" (Binary lh, PRegistering) ::
IO [Only Int]
)
-- | The registrations a worker moves on, oldest first.
activeRegistrations :: DB.Connection -> IO [NameRegistration]
activeRegistrations db =
DB.query db (selectRegistrations <> " WHERE r.phase IN (?,?,?,?) ORDER BY r.created_at, r.registration_id") (PQueued, PCommitting, PCommitted, PRegistering)
>>= decodeAll toRegistration
-- | Unpaid orders whose invoice expired before the cutoff, without a recorded payment.
unpaidCleanupCandidates :: DB.Connection -> UTCTime -> IO [(RegistrationId, InvoiceId)]
unpaidCleanupCandidates db expiredBefore =
map (\(rid, invId) -> (RegistrationId rid, InvoiceId invId))
<$> DB.query
db
[sql|
SELECT r.registration_id, ni.invoice_id
FROM sx_badge_service_name_registrations r
JOIN sx_badge_service_name_invoices ni ON ni.registration_id = r.registration_id
JOIN sx_badge_service_invoices i ON i.invoice_id = ni.invoice_id
WHERE r.phase = ? AND i.expires_at < ?
AND NOT EXISTS (SELECT 1 FROM sx_badge_service_payments p WHERE p.invoice_id = ni.invoice_id)
ORDER BY i.expires_at, r.registration_id
|]
(PUnpaid, truncateToSecond expiredBefore)
-- | Deletes an unpaid registration and its invoice, unless a payment was recorded for it.
deleteUnpaidRegistration :: DB.Connection -> RegistrationId -> IO Bool
deleteUnpaidRegistration db (RegistrationId rid) = do
invoiceIds <- DB.query db "SELECT invoice_id FROM sx_badge_service_name_invoices WHERE registration_id = ?" (Only rid)
deleted <-
executeChanging
db
[sql|
DELETE FROM sx_badge_service_name_registrations
WHERE registration_id = ? AND phase = ?
AND NOT EXISTS (
SELECT 1 FROM sx_badge_service_name_invoices ni
JOIN sx_badge_service_payments p ON p.invoice_id = ni.invoice_id
WHERE ni.registration_id = ?
)
|]
(rid, PUnpaid, rid)
when (deleted > 0) $
mapM_ (DB.execute db "DELETE FROM sx_badge_service_invoices WHERE invoice_id = ?" . Only . fromOnly) (invoiceIds :: [Only Text])
pure $ deleted > 0
-- | Code orders failed before the cutoff that still hold their unspent code.
failedCodeOrdersBefore :: DB.Connection -> UTCTime -> IO [(RegistrationId, Int64)]
failedCodeOrdersBefore db cutoff =
map (\(rid, codeId) -> (RegistrationId rid, codeId))
<$> DB.query
db
[sql|
SELECT r.registration_id, c.name_prepaid_code_id
FROM sx_badge_service_name_registrations r
JOIN sx_badge_service_name_prepaid_codes c ON c.reserved_by = r.registration_id
WHERE r.phase = ? AND r.failed_at < ? AND c.spent_at IS NULL
ORDER BY r.failed_at, r.registration_id
|]
(PFailed, truncateToSecond cutoff)
insertPrepaidCode :: DB.Connection -> NewPrepaidCode -> UTCTime -> IO (Either CodeHashTaken Int64)
insertPrepaidCode db NewPrepaidCode {npcCodeHash, npcMinLength, npcYears, npcPaymentStatus, npcExpiresAt} now = do
inserted <-
@@ -74,21 +624,60 @@ insertPrepaidCode db NewPrepaidCode {npcCodeHash, npcMinLength, npcYears, npcPay
prepaidCodeColumns :: Query
prepaidCodeColumns =
[sql|
SELECT name_prepaid_code_id, code_hash, min_length, years, code_payment_status, spent_at, revoked_at, expires_at, created_at
SELECT name_prepaid_code_id, code_hash, min_length, years, code_payment_status, reserved_by, reserved_at, spent_at, revoked_at, expires_at, created_at
FROM sx_badge_service_name_prepaid_codes
|]
type PrepaidCodeRow = (Int64, Binary ByteString, Int, Int, BadgeCodePaymentStatus, Maybe UTCTime, Maybe UTCTime, Maybe UTCTime) :. Only UTCTime
type PrepaidCodeRow = (Int64, Binary ByteString, Int, Int, BadgeCodePaymentStatus, Maybe Text, Maybe UTCTime, Maybe UTCTime, Maybe UTCTime, Maybe UTCTime) :. Only UTCTime
toPrepaidCode :: PrepaidCodeRow -> PrepaidCode
toPrepaidCode ((pcId, Binary pcCodeHash, pcMinLength, pcYears, pcPaymentStatus, pcSpentAt, pcRevokedAt, pcExpiresAt) :. Only pcCreatedAt) =
PrepaidCode {pcId, pcCodeHash, pcMinLength, pcYears, pcPaymentStatus, pcSpentAt, pcRevokedAt, pcExpiresAt, pcCreatedAt}
toPrepaidCode ((pcId, Binary pcCodeHash, pcMinLength, pcYears, pcPaymentStatus, reservedBy, pcReservedAt, pcSpentAt, pcRevokedAt, pcExpiresAt) :. Only pcCreatedAt) =
PrepaidCode {pcId, pcCodeHash, pcMinLength, pcYears, pcPaymentStatus, pcReservedBy = RegistrationId <$> reservedBy, pcReservedAt, pcSpentAt, pcRevokedAt, pcExpiresAt, pcCreatedAt}
getPrepaidCode :: DB.Connection -> ByteString -> IO (Maybe PrepaidCode)
getPrepaidCode db codeHash =
maybeFirstRow toPrepaidCode $ DB.query db (prepaidCodeColumns <> " WHERE code_hash = ?") (Only $ Binary codeHash)
-- | A spent code cannot be revoked.
getPrepaidCodeById :: DB.Connection -> Int64 -> IO (Maybe PrepaidCode)
getPrepaidCodeById db codeId =
maybeFirstRow toPrepaidCode $ DB.query db (prepaidCodeColumns <> " WHERE name_prepaid_code_id = ?") (Only codeId)
-- | Only an unused code: not reserved, spent or revoked, paid or free, and not expired.
reservePrepaidCode :: DB.Connection -> Int64 -> RegistrationId -> UTCTime -> IO Bool
reservePrepaidCode db codeId (RegistrationId rid) now' =
(> 0)
<$> executeChanging
db
[sql|
UPDATE sx_badge_service_name_prepaid_codes SET reserved_by = ?, reserved_at = ?
WHERE name_prepaid_code_id = ? AND reserved_by IS NULL AND spent_at IS NULL AND revoked_at IS NULL
AND code_payment_status <> ? AND (expires_at IS NULL OR expires_at > ?)
|]
(rid, now, codeId, CPSUnpaid, now)
where
now = truncateToSecond now'
releasePrepaidCode :: DB.Connection -> Int64 -> RegistrationId -> IO Bool
releasePrepaidCode db codeId (RegistrationId rid) =
(> 0)
<$> executeChanging
db
[sql|
UPDATE sx_badge_service_name_prepaid_codes SET reserved_by = NULL, reserved_at = NULL
WHERE name_prepaid_code_id = ? AND reserved_by = ? AND spent_at IS NULL
|]
(codeId, rid)
-- | A spent code keeps reserved_by, naming the registration it paid for.
spendPrepaidCode :: DB.Connection -> Int64 -> RegistrationId -> UTCTime -> IO Bool
spendPrepaidCode db codeId (RegistrationId rid) now =
(> 0)
<$> executeChanging
db
"UPDATE sx_badge_service_name_prepaid_codes SET spent_at = ? WHERE name_prepaid_code_id = ? AND reserved_by = ? AND spent_at IS NULL"
(truncateToSecond now, codeId, rid)
-- | A reserved code can be revoked, and its order keeps it; a spent one cannot.
revokePrepaidCode :: DB.Connection -> ByteString -> UTCTime -> IO RevokeResult
revokePrepaidCode db codeHash now = do
revoked <-
@@ -102,3 +691,87 @@ revokePrepaidCode db codeHash now = do
| revoked > 0 = Revoked pcId
| isJust pcRevokedAt = AlreadyRevoked pcId
| otherwise = AlreadyRedeemed
txKind :: TxFor -> (Text, Text)
txKind = \case
TxCommit (RegistrationId rid) -> ("commit", rid)
TxRegister (RegistrationId rid) -> ("register", rid)
-- | Saved once signed and before it is sent, so a restart can rebroadcast it.
insertTransaction :: DB.Connection -> TxFor -> NewTransaction -> UTCTime -> IO Int64
insertTransaction db for NewTransaction {ntxRaw, ntxHash, ntxNonce} now = do
let (kind, rid) = txKind for
DB.execute
db
[sql|
INSERT INTO sx_badge_service_name_transactions
(registration_id, kind, raw, tx_hash, registrar_nonce, sent_at, status)
VALUES (?,?,?,?,?,?,?)
|]
(rid, kind, Binary ntxRaw, txHashField ntxHash, int64 ntxNonce, truncateToSecond now, TSPending)
insertedRowId db
-- | Moves a transaction on from the status the caller read, so an outcome is never overwritten unseen; False when it is not in that status.
recordTransactionOutcome :: DB.Connection -> TxHash -> TxStatus -> TxStatus -> Maybe Word64 -> IO Bool
recordTransactionOutcome db hash from status block =
(> 0)
<$> executeChanging
db
"UPDATE sx_badge_service_name_transactions SET status = ?, mined_block = ? WHERE tx_hash = ? AND status = ?"
(status, int64 <$> block, txHashField hash, from)
transactionColumns :: Query
transactionColumns =
[sql|
SELECT name_transaction_id, kind, registration_id, raw, tx_hash, registrar_nonce, sent_at, mined_block, status
FROM sx_badge_service_name_transactions
|]
type TransactionRow = (Int64, Text, Maybe Text, Binary ByteString, Binary ByteString, Int64, UTCTime, Maybe Int64, TxStatus)
toTransaction :: TransactionRow -> Either Text NameTransaction
toTransaction (ntId, kind, rid_, Binary ntRaw, hash, nonce, ntSentAt, block, ntStatus) = do
ntFor <- case (kind, rid_) of
("commit", Just rid) -> Right $ TxCommit $ RegistrationId rid
("register", Just rid) -> Right $ TxRegister $ RegistrationId rid
_ -> Left $ "name_transactions.kind: " <> kind
pure NameTransaction {ntId, ntFor, ntRaw, ntHash = txHash hash, ntNonce = word64 nonce, ntSentAt, ntMinedBlock = word64 <$> block, ntStatus}
-- | Those without a receipt, in nonce order, for the sender to resume.
pendingTransactions :: DB.Connection -> IO [NameTransaction]
pendingTransactions db =
DB.query db (transactionColumns <> " WHERE status = ? ORDER BY registrar_nonce, name_transaction_id") (Only TSPending)
>>= decodeAll toTransaction
registrationTransactions :: DB.Connection -> RegistrationId -> IO [NameTransaction]
registrationTransactions db (RegistrationId rid) =
DB.query db (transactionColumns <> " WHERE registration_id = ? ORDER BY name_transaction_id") (Only rid)
>>= decodeAll toTransaction
int64 :: Word64 -> Int64
int64 = fromIntegral
txHash :: Binary ByteString -> TxHash
txHash (Binary h) = TxHash h
txHashField :: TxHash -> Binary ByteString
txHashField (TxHash h) = Binary h
word64 :: Int64 -> Word64
word64 = fromIntegral
-- | Address has no exported constructor; its parser takes lowercase hex without the EIP-55 check.
decodeAddress :: ByteString -> Either Text Address
decodeAddress bs = either (const $ Left "address column") Right $ strDecode $ convertToBase Base16 bs
decodeSignature :: ByteString -> Either Text RecoverableSignature
decodeSignature bs = either (Left . ("signature column: " <>) . tshow) Right $ parseSignature $ hex bs
note :: Text -> Maybe a -> Either Text a
note err = maybe (Left err) Right
decodeAll :: (row -> Either Text a) -> [row] -> IO [a]
decodeAll decode = either (E.throwIO . StoreDecodeError) pure . traverse decode
firstDecoded :: (row -> Either Text a) -> IO [row] -> IO (Maybe a)
firstDecoded decode rows = rows >>= fmap listToMaybe . decodeAll decode . take 1
@@ -1,21 +1,29 @@
{-# LANGUAGE NamedFieldPuns #-}
-- | A thread that takes a turn it already holds waits forever.
module StoreService.Names.Turns (Turns, newTurns, withCodeTurn) where
-- | A thread that takes a turn it already holds waits forever. Label turns are taken before a code turn.
module StoreService.Names.Turns (Turns, newTurns, withLabelTurn, withCodeTurn, turnsCount) where
import Control.Concurrent.STM
import Control.Exception (bracket, bracket_)
import Data.ByteString (ByteString)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Simplex.Messaging.SimplexName (LabelHash (..))
-- | Each lock counts the requests holding or waiting for it, and its entry goes when none are left.
type TurnLocks = TVar (Map ByteString (TMVar (), Int))
data Turns = Turns {codeTurns :: TurnLocks}
data Turns = Turns {labelTurns :: TurnLocks, codeTurns :: TurnLocks}
newTurns :: IO Turns
newTurns = Turns <$> newTVarIO Map.empty
newTurns = Turns <$> newTVarIO Map.empty <*> newTVarIO Map.empty
withLabelTurn :: Turns -> LabelHash -> IO a -> IO a
withLabelTurn Turns {labelTurns} (LabelHash h) = withTurn labelTurns h
-- | The label and code hashes with a holder or a waiter.
turnsCount :: Turns -> IO Int
turnsCount Turns {labelTurns, codeTurns} = atomically $ (+) <$> (Map.size <$> readTVar labelTurns) <*> (Map.size <$> readTVar codeTurns)
-- | Keyed by the code's SHA-256 hash.
withCodeTurn :: Turns -> ByteString -> IO a -> IO a
+335 -2
View File
@@ -1,24 +1,357 @@
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}
module Bots.StoreService.NamesCodesTests (namesCodesTests) where
import Control.Monad (forM_)
import Simplex.Chat.Badges.Code (NameCode (..), NamePrepaidCode, formatNameCode, randomNamePrepaidCode)
import Bots.StoreService.NamesStoreTests (order, ownerA, ownerB, placeCode, placePaid, usable)
import Bots.StoreService.WebTests (withServiceStore)
import Control.Arrow ((&&&))
import Control.Concurrent (threadDelay)
import Control.Concurrent.Async (concurrently)
import Control.Monad (forM_, replicateM_)
import qualified Data.Aeson as J
import qualified Data.Aeson.KeyMap as KM
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lazy.Char8 as LB
import Data.IORef (newIORef, readIORef, writeIORef)
import Data.Maybe (fromJust, fromMaybe)
import Data.Text (Text)
import Data.Time.Calendar (fromGregorian)
import Data.Time.Clock (UTCTime (..), addUTCTime, getCurrentTime)
import Network.HTTP.Client (Manager, Response, RequestBody (..), defaultManagerSettings, httpLbs, method, newManager, parseRequest, requestBody, responseBody, responseHeaders, responseStatus)
import Network.HTTP.Types (hContentType)
import Network.HTTP.Types.Status (statusCode)
import qualified Network.Wai.Handler.Warp as Warp
import Simplex.Chat.Badges.Code (NameCode (..), NamePrepaidCode, formatNameCode, namePrepaidCodeHash, parseNameCode, randomNamePrepaidCode)
import Simplex.Chat.Badges.Types (BadgeCodePaymentStatus (..))
import Simplex.Chat.Types.Shared (GroupMemberRole (..))
import Simplex.Messaging.Agent.Store.Common (DBStore, withTransaction)
import qualified Simplex.Messaging.Agent.Store.DB as DB
import qualified Simplex.Messaging.Crypto as C
import StoreService.Config (ListenerConfig (..))
import StoreService.Group.Command (CmdAction (..), GroupCmd (..), groupCmdAction)
import StoreService.Names.Codes
import StoreService.Names.Phases (RegistrationId (..))
import StoreService.Names.Store (NewPrepaidCode (..), PrepaidCode (..), getPrepaidCode, insertPrepaidCode, reservePrepaidCode, revokePrepaidCode, spendPrepaidCode)
import StoreService.Names.Turns (Turns, newTurns)
import StoreService.Store (RevokeResult (..))
import StoreService.Web.Http (codeLimit, newHttpEnv, notFound)
import StoreService.Web.Names (Route (..), namesApp)
import StoreService.Web.Names.Codes (codeCheckHandler)
import Test.Hspec
namesCodesTests :: Spec
namesCodesTests = describe "StoreService names: prepaid codes" $ do
describe "state" $
it "reads each state from the code's row, a spent code as used even if revoked while held" testCodeStates
describe "check" $ do
it "answers each state with what the code covers, and changes no code" testCheckStates
it "folds a code typed in lower case with spaces to the issued one" testCheckFolded
it "answers code_invalid to an unknown, mistyped, zero-padded, owner or badge code" testCheckInvalid
it "answers bad_request to a body that is not an object with a code text, and 405 to GET" testCheckBadBody
it "takes a code token for every check, whatever its outcome" testCheckLimit
describe "reservations" $ do
it "reserves an unused code after the registration's write, in its transaction" testReserve
it "refuses each unusable code with its tag, before the write runs" testReserveRefusals
it "keeps a code its registration holds even if revoked or expired since, still checking the length" testReserveHeld
it "refuses a spent code to its own registration with code_used, before the write runs" testReserveSpent
it "reserves nothing when the write refuses" testReserveWriteRefused
it "rolls the write back when the code's reservation is refused after it" testReserveRollsBack
it "lets one of two concurrent reservations of a code win, the other answered code_reserved" testConcurrentReserve
it "releases and spends a code only after the write, and only for its holder" testReleaseSpend
describe "group commands" $ do
it "parses /issue name and /bulk name with the length, years and count" testGroupNameCommands
it "answers the usage to a bad length, years or count, or a badge option" testGroupNameCommandsRefused
it "parses /revoke of a prepaid code, telling a moderator it was not revoked" testGroupRevokeNameCommand
r1, r2 :: RegistrationId
r1 = RegistrationId "r1"
r2 = RegistrationId "r2"
tNow :: UTCTime
tNow = UTCTime (fromGregorian 2026 10 21) 3600
baseCode :: PrepaidCode
baseCode =
PrepaidCode
{ pcId = 1,
pcCodeHash = "",
pcMinLength = 8,
pcYears = 2,
pcPaymentStatus = CPSPaid,
pcReservedBy = Nothing,
pcReservedAt = Nothing,
pcSpentAt = Nothing,
pcRevokedAt = Nothing,
pcExpiresAt = Nothing,
pcCreatedAt = tNow
}
testCodeStates :: IO ()
testCodeStates = do
let stateOf = codeState tNow
held = baseCode {pcReservedBy = Just r1, pcReservedAt = Just tNow}
revoked = Just tNow
map codeStateText [minBound .. maxBound] `shouldBe` ["unused", "reserved", "used", "revoked", "expired", "unpaid"]
stateOf baseCode `shouldBe` CSUnused
stateOf baseCode {pcPaymentStatus = CPSFree, pcExpiresAt = Just (addUTCTime 1 tNow)} `shouldBe` CSUnused
stateOf held `shouldBe` CSReserved
stateOf held {pcSpentAt = Just tNow} `shouldBe` CSUsed
stateOf held {pcSpentAt = Just tNow, pcRevokedAt = revoked} `shouldBe` CSUsed
stateOf baseCode {pcRevokedAt = revoked} `shouldBe` CSRevoked
stateOf held {pcRevokedAt = revoked} `shouldBe` CSRevoked
stateOf baseCode {pcPaymentStatus = CPSUnpaid} `shouldBe` CSUnpaid
stateOf baseCode {pcPaymentStatus = CPSUnpaid, pcExpiresAt = Just tNow} `shouldBe` CSUnpaid
stateOf baseCode {pcExpiresAt = Just tNow} `shouldBe` CSExpired
stateOf held {pcExpiresAt = Just tNow} `shouldBe` CSReserved
-- The route as namesRoutes registers it, since a NamesEnv needs a running chat controller.
withCodeCheck :: (DBStore -> Client -> IO a) -> IO a
withCodeCheck action = withServiceStore $ \st -> do
http <- newHttpEnv ListenerConfig {lHost = "127.0.0.1", lBadgesPort = 0, lBadgesStaticDir = "", lServeWebapp = False, lBadgesExportDir = Nothing, lTrustForwardedFor = False, lNamesStaticDir = Nothing, lNamesExportDir = Nothing, lNamesPort = Nothing}
let routes = \case
["api", "code", "check"] -> Just Route {rMethod = "POST", rLimit = codeLimit, rHandler = codeCheckHandler st}
_ -> Nothing
app req respond = fromMaybe (respond notFound) (namesApp http routes req respond)
mgr <- newManager defaultManagerSettings
Warp.testWithApplication (pure app) $ \port -> action st (mgr, "http://127.0.0.1:" <> show port)
type Client = (Manager, String)
postCheck :: Client -> LB.ByteString -> IO (Response LB.ByteString)
postCheck (mgr, base) body = do
req <- parseRequest (base <> "/api/code/check")
httpLbs req {method = "POST", requestBody = RequestBodyLBS body} mgr
checkText :: Client -> Text -> IO (Response LB.ByteString)
checkText client code = postCheck client (J.encode (J.object ["code" J..= code]))
checkCode :: Client -> NamePrepaidCode -> IO (Response LB.ByteString)
checkCode client = checkText client . formatNameCode . NCPrepaid
answerOf :: Response LB.ByteString -> (Int, Maybe J.Object)
answerOf r = (statusCode (responseStatus r), J.decode (responseBody r))
coverage :: Int -> Int -> Text -> (Int, Maybe J.Object)
coverage minLength years state = (200, Just $ KM.fromList [("minLength", J.toJSON minLength), ("years", J.toJSON years), ("state", J.String state)])
refused :: Int -> Text -> (Int, Maybe J.Object)
refused status tag = (status, Just $ KM.fromList [("error", J.String tag)])
newCode :: Int -> IO NamePrepaidCode
newCode len = C.newRandom >>= (`randomNamePrepaidCode` len)
issueAs :: DBStore -> NamePrepaidCode -> NewPrepaidCode -> IO PrepaidCode
issueAs st code new = withTransaction st $ \db -> do
Right _ <- insertPrepaidCode db new {npcCodeHash = namePrepaidCodeHash code} tNow
fromJust <$> getPrepaidCode db (namePrepaidCodeHash code)
readCode :: DBStore -> PrepaidCode -> IO (Maybe PrepaidCode)
readCode st PrepaidCode {pcCodeHash} = withTransaction st (`getPrepaidCode` pcCodeHash)
testCheckStates :: IO ()
testCheckStates = withCodeCheck $ \st client -> do
now <- getCurrentTime
[unused, reserved, used, revoked, expired, unpaid] <- mapM newCode [8, 6, 7, 9, 12, 63]
unusedRow <- issueAs st unused usable {npcYears = 5, npcExpiresAt = Just (addUTCTime 3600 now)}
reservedRow <- issueAs st reserved usable {npcMinLength = 6}
usedRow <- issueAs st used usable {npcMinLength = 7}
revokedRow <- issueAs st revoked usable {npcMinLength = 9, npcPaymentStatus = CPSFree}
expiredRow <- issueAs st expired usable {npcMinLength = 12, npcExpiresAt = Just (addUTCTime (-60) now)}
unpaidRow <- issueAs st unpaid usable {npcMinLength = 63, npcYears = 10, npcPaymentStatus = CPSUnpaid}
placeCode st "r1" ownerA (order "alicebakery" 1) reservedRow `shouldReturn` Right ()
placeCode st "r2" ownerA (order "bobsbakery" 2) usedRow `shouldReturn` Right ()
withTransaction st (\db -> spendPrepaidCode db (pcId usedRow) r2 tNow) `shouldReturn` True
withTransaction st (\db -> revokePrepaidCode db (pcCodeHash revokedRow) tNow) `shouldReturn` Revoked (pcId revokedRow)
let rows = [unusedRow, reservedRow, usedRow, revokedRow, expiredRow, unpaidRow]
rowsBefore <- mapM (readCode st) rows
answerOf <$> checkCode client unused `shouldReturn` coverage 8 5 "unused"
answerOf <$> checkCode client reserved `shouldReturn` coverage 6 2 "reserved"
answerOf <$> checkCode client used `shouldReturn` coverage 7 2 "used"
answerOf <$> checkCode client revoked `shouldReturn` coverage 9 2 "revoked"
answerOf <$> checkCode client expired `shouldReturn` coverage 12 2 "expired"
answerOf <$> checkCode client unpaid `shouldReturn` coverage 63 10 "unpaid"
mapM (readCode st) rows `shouldReturn` rowsBefore
-- The webapp's and core's vector: these two spellings are one code.
testCheckFolded :: IO ()
testCheckFolded = withCodeCheck $ \st client -> do
Just (NCPrepaid code) <- pure $ parseNameCode "SN7-BJTBP-29596-R3HJ8-25YM7"
_ <- issueAs st code usable {npcMinLength = 7}
answerOf <$> checkText client "sn7 bjtbp 29596 r3hj8 25ym7" `shouldReturn` coverage 7 2 "unused"
testCheckInvalid :: IO ()
testCheckInvalid = withCodeCheck $ \st client -> do
Just (NCPrepaid issued) <- pure $ parseNameCode "SN7-BJTBP-29596-R3HJ8-25YM7"
_ <- issueAs st issued usable {npcMinLength = 7}
unknown <- newCode 8
let invalid = refused 400 "code_invalid"
answerOf <$> checkCode client unknown `shouldReturn` invalid
forM_
[ "SN7-BJTBP-29596-R3HJ8-25YM8",
"SN07-BJTBP-29596-R3HJ8-25YM7",
"SN-DWPHS-6JBFR-ZR1MA-T5HQ9-P17QM-F5GM5",
"SB-00000-00000-00000-00000",
"alicebakery",
""
]
$ \text -> (text,) . answerOf <$> checkText client text `shouldReturn` (text, invalid)
testCheckBadBody :: IO ()
testCheckBadBody = withCodeCheck $ \_ client@(mgr, base) -> do
let badRequest = refused 400 "bad_request"
forM_ ["", "not json", "[\"SN7-BJTBP-29596-R3HJ8-25YM7\"]", "{}", "{\"code\": 7}", "{\"code\": null}"] $ \body ->
(body,) . answerOf <$> postCheck client body `shouldReturn` (body, badRequest)
let overCap = "{\"code\": \"SN7-BJTBP-29596-R3HJ8-25YM7\", \"pad\": \"" <> LB.replicate 8192 'x' <> "\"}"
answerOf <$> postCheck client overCap `shouldReturn` badRequest
req <- parseRequest (base <> "/api/code/check")
r <- httpLbs req mgr
statusCode (responseStatus r) `shouldBe` 405
lookup "Allow" (responseHeaders r) `shouldBe` Just "POST"
lookup hContentType (responseHeaders r) `shouldBe` Just "application/json"
testCheckLimit :: IO ()
testCheckLimit = withCodeCheck $ \st client -> do
issued <- newCode 8
_ <- issueAs st issued usable
unknown <- newCode 8
replicateM_ 5 $ checkCode client issued >>= (`shouldBe` 200) . fst . answerOf
replicateM_ 4 $ checkCode client unknown >>= (`shouldBe` 400) . fst . answerOf
postCheck client "{}" >>= (`shouldBe` 400) . fst . answerOf
limited <- checkCode client issued
answerOf limited `shouldBe` refused 429 "rate_limited"
lookup "Retry-After" (responseHeaders limited) `shouldSatisfy` maybe False (BC.all (`elem` ['0' .. '9']))
-- | Two paid orders, so a code can be reserved for either.
withOrders :: (Turns -> DBStore -> IO a) -> IO a
withOrders action = withServiceStore $ \st -> do
placePaid st "r1" ownerA (order "alicebakery" 1) tNow `shouldReturn` Right ()
placePaid st "r2" ownerB (order "bobsbakery" 2) tNow `shouldReturn` Right ()
turns <- newTurns
action turns st
writeOk :: DB.Connection -> IO (Either Text ())
writeOk _ = pure $ Right ()
testReserve :: IO ()
testReserve = withOrders $ \turns st -> do
code <- newCode 8
PrepaidCode {pcCodeHash} <- issueAs st code usable
let holderInWrite db = Right . (pcReservedBy =<<) <$> getPrepaidCode db pcCodeHash :: IO (Either Text (Maybe RegistrationId))
reserveCode turns st tNow pcCodeHash r1 8 holderInWrite `shouldReturn` Right (Right Nothing)
(pcReservedBy =<<) <$> withTransaction st (`getPrepaidCode` pcCodeHash) `shouldReturn` Just r1
reserveCode turns st tNow pcCodeHash r1 11 holderInWrite `shouldReturn` Right (Right (Just r1))
testReserveRefusals :: IO ()
testReserveRefusals = withOrders $ \turns st -> do
[reserved, used, revoked, expired, unpaid, unknown, short] <- mapM newCode [8, 8, 8, 8, 8, 8, 8]
reservedRow <- issueAs st reserved usable
usedRow <- issueAs st used usable
revokedRow <- issueAs st revoked usable
expiredRow <- issueAs st expired usable {npcExpiresAt = Just tNow}
unpaidRow <- issueAs st unpaid usable {npcPaymentStatus = CPSUnpaid}
shortRow <- issueAs st short usable
placeCode st "r5" ownerA (order "erinsbakery" 5) reservedRow `shouldReturn` Right ()
placeCode st "r3" ownerB (order "carolsbakery" 4) usedRow `shouldReturn` Right ()
withTransaction st (\db -> spendPrepaidCode db (pcId usedRow) (RegistrationId "r3") tNow) `shouldReturn` True
withTransaction st (\db -> revokePrepaidCode db (pcCodeHash revokedRow) tNow) `shouldReturn` Revoked (pcId revokedRow)
wrote <- newIORef False
let reserve hash len = reserveCode turns st tNow hash r1 len (\_ -> Right () <$ writeIORef wrote True :: IO (Either Text ()))
rows = [reservedRow, usedRow, revokedRow, expiredRow, unpaidRow, shortRow]
rowsBefore <- mapM (readCode st) rows
reserve (pcCodeHash reservedRow) 8 `shouldReturn` Left CRReserved
reserve (pcCodeHash usedRow) 8 `shouldReturn` Left CRUsed
reserve (pcCodeHash revokedRow) 8 `shouldReturn` Left CRInvalid
reserve (pcCodeHash expiredRow) 8 `shouldReturn` Left CRExpired
reserve (pcCodeHash unpaidRow) 8 `shouldReturn` Left CRPaymentPending
reserve (namePrepaidCodeHash unknown) 8 `shouldReturn` Left CRInvalid
reserve (pcCodeHash shortRow) 7 `shouldReturn` Left CRNotCovering
reserve (pcCodeHash revokedRow) 7 `shouldReturn` Left CRInvalid
readIORef wrote `shouldReturn` False
mapM (readCode st) rows `shouldReturn` rowsBefore
map codeRefusalTag [CRInvalid, CRUsed, CRReserved, CRExpired, CRPaymentPending, CRNotCovering]
`shouldBe` ["code_invalid", "code_used", "code_reserved", "code_expired", "payment_pending", "code_not_covering"]
testReserveHeld :: IO ()
testReserveHeld = withOrders $ \turns st -> do
code <- newCode 8
row@PrepaidCode {pcCodeHash} <- issueAs st code usable
placeCode st "r3" ownerB (order "carolsbakery" 3) row `shouldReturn` Right ()
let r3 = RegistrationId "r3"
withTransaction st (\db -> revokePrepaidCode db pcCodeHash tNow) `shouldReturn` Revoked (pcId row)
withTransaction st $ \db -> DB.execute db "UPDATE sx_badge_service_name_prepaid_codes SET expires_at = ? WHERE code_hash = ?" (tNow, DB.Binary pcCodeHash)
held <- readCode st row
reserveCode turns st tNow pcCodeHash r3 9 writeOk `shouldReturn` Right (Right ())
reserveCode turns st tNow pcCodeHash r3 7 writeOk `shouldReturn` Left CRNotCovering
reserveCode turns st tNow pcCodeHash r1 9 writeOk `shouldReturn` Left CRInvalid
readCode st row `shouldReturn` held
testReserveSpent :: IO ()
testReserveSpent = withOrders $ \turns st -> do
code <- newCode 8
row@PrepaidCode {pcCodeHash} <- issueAs st code usable
placeCode st "r3" ownerB (order "carolsbakery" 3) row `shouldReturn` Right ()
let r3 = RegistrationId "r3"
withTransaction st (\db -> spendPrepaidCode db (pcId row) r3 tNow) `shouldReturn` True
spent <- readCode st row
wrote <- newIORef False
reserveCode turns st tNow pcCodeHash r3 8 (\_ -> Right () <$ writeIORef wrote True :: IO (Either Text ())) `shouldReturn` Left CRUsed
readIORef wrote `shouldReturn` False
readCode st row `shouldReturn` spent
testReserveWriteRefused :: IO ()
testReserveWriteRefused = withOrders $ \turns st -> do
code <- newCode 8
row@PrepaidCode {pcCodeHash} <- issueAs st code usable
reserveCode turns st tNow pcCodeHash r1 8 (\_ -> pure (Left "registration_changed" :: Either Text ())) `shouldReturn` Right (Left "registration_changed")
(pcReservedBy =<<) <$> readCode st row `shouldReturn` Nothing
reserveCode turns st tNow pcCodeHash r2 8 writeOk `shouldReturn` Right (Right ())
(pcReservedBy =<<) <$> readCode st row `shouldReturn` Just r2
-- | The write reserves the code for another registration, as a writer outside this process could between the check and the reservation.
testReserveRollsBack :: IO ()
testReserveRollsBack = withOrders $ \turns st -> do
code <- newCode 8
row@PrepaidCode {pcId, pcCodeHash} <- issueAs st code usable
let takenMeanwhile db = Right () <$ reservePrepaidCode db pcId r2 tNow :: IO (Either Text ())
reserveCode turns st tNow pcCodeHash r1 8 takenMeanwhile `shouldReturn` Left CRReserved
readCode st row `shouldReturn` Just row
testConcurrentReserve :: IO ()
testConcurrentReserve = withOrders $ \turns st -> do
code <- newCode 8
row@PrepaidCode {pcCodeHash} <- issueAs st code usable
let slowWrite _ = Right () <$ threadDelay 100000 :: IO (Either Text ())
reserveFor rid = reserveCode turns st tNow pcCodeHash rid 8 slowWrite
outcomes <- concurrently (reserveFor r1) (reserveFor r2)
outcomes `shouldSatisfy` (`elem` [(Right (Right ()), Left CRReserved), (Left CRReserved, Right (Right ()))])
holder <- (pcReservedBy =<<) <$> readCode st row
holder `shouldBe` Just (if fst outcomes == Right (Right ()) then r1 else r2)
testReleaseSpend :: IO ()
testReleaseSpend = withOrders $ \turns st -> do
[spent, released] <- mapM newCode [8, 8]
spentRow <- issueAs st spent usable
releasedRow <- issueAs st released usable
placeCode st "r3" ownerB (order "carolsbakery" 3) spentRow `shouldReturn` Right ()
placeCode st "r4" ownerB (order "davesbakery" 4) releasedRow `shouldReturn` Right ()
let r3 = RegistrationId "r3"
r4 = RegistrationId "r4"
holderInWrite row db = Right . (pcReservedBy =<<) <$> getPrepaidCode db (pcCodeHash row) :: IO (Either Text (Maybe RegistrationId))
changed _ = pure (Left "registration_changed") :: IO (Either Text ())
spendCode turns st tNow (pcId spentRow) r3 changed `shouldReturn` Left "registration_changed"
(pcSpentAt =<<) <$> readCode st spentRow `shouldReturn` Nothing
spendCode turns st tNow (pcId spentRow) r1 writeOk `shouldReturn` Right ((), False)
spendCode turns st tNow (pcId spentRow) r3 writeOk `shouldReturn` Right ((), True)
((pcReservedBy =<<) &&& (pcSpentAt =<<)) <$> readCode st spentRow `shouldReturn` (Just r3, Just tNow)
releaseCode turns st (pcId spentRow) r3 writeOk `shouldReturn` Right ((), False)
releaseCode turns st (pcId releasedRow) r4 changed `shouldReturn` Left "registration_changed"
releaseCode turns st (pcId releasedRow) r1 writeOk `shouldReturn` Right ((), False)
releaseCode turns st (pcId releasedRow) r4 (holderInWrite releasedRow) `shouldReturn` Right (Just r4, True)
(pcReservedBy =<<) <$> readCode st releasedRow `shouldReturn` Nothing
testGroupNameCommands :: IO ()
testGroupNameCommands = do
let p = groupCmdAction GRModerator
+321
View File
@@ -0,0 +1,321 @@
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}
module Bots.StoreService.NamesPhasesTests (namesPhasesTests, change, held, woken, prompt, registrationPath, seenVersion) where
import Bots.StoreService.NamesOrdersTests
import Bots.StoreService.NamesStoreTests (reveal)
import Bots.StoreService.WebTests (bounded, jsonObject, rcv, statusOf, webGet)
import Control.Concurrent (threadDelay)
import Control.Concurrent.Async (Async, async, cancel, wait, waitCatchSTM)
import qualified Control.Concurrent.Async as Async
import Control.Concurrent.STM (STM, atomically, check, orElse)
import Control.Monad (forM_)
import qualified Data.Aeson as J
import qualified Data.Aeson.Key as K
import qualified Data.Aeson.KeyMap as KM
import Data.IORef (readIORef, writeIORef)
import Data.Int (Int64)
import Data.Maybe (fromJust, fromMaybe, isNothing)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Time.Clock (NominalDiffTime, UTCTime, addUTCTime, diffUTCTime, getCurrentTime)
import Data.Time.Clock.POSIX (posixSecondsToUTCTime, utcTimeToPOSIXSeconds)
import Network.HTTP.Client (defaultManagerSettings, newManager)
import qualified Network.Wai.Handler.Warp as Warp
import Simplex.Chat.PaymentService.Types (InvoiceId (..), InvoiceStatus (..))
import Simplex.Messaging.Agent.Store.Common (withTransaction)
import StoreService.Names.Orders (OrdersEnv (..))
import StoreService.Names.Phases (RegistrationId (..), phasesWaiting, publish)
import StoreService.Names.Store (NamePhase (..), NameRegistration (..), VersionWrite (..), getRegistration, updateRegistration)
import StoreService.Providers (Funded (..), PaymentSignal (..))
import StoreService.Store.Invoices (InvoiceRow (..), getInvoice)
import StoreService.Waiters (publishPayment, waitingCountSTM)
import StoreService.Web.Http (holdMicros, readLimit)
import StoreService.Web.Names (Route (..), namesApp)
import StoreService.Web.Names.Registration (registrationHandler)
import StoreService.Web.Server (WebEnv (..), webApp)
import System.Timeout (timeout)
import Test.Hspec
namesPhasesTests :: Spec
namesPhasesTests = describe "StoreService names: phases" $ do
describe "changes" $ do
it "wakes a held invoice poll and a held registration poll on each change: phase, label set and cleared, reveal times, error" testEachChangeWakes
it "holds a paid name invoice on its registration's version alone, and answers at once without a valid version" testPaidHoldsOnVersion
it "answers at once an invoice paid after its order closed" testLatePaidAnswersAtOnce
it "wakes an open invoice poll by a version change, and holds it on its status without a valid version" testOpenWakesOnVersion
describe "time" $ do
it "wakes an unpaid invoice held on its status at its expiry, reading it expired" testExpiryWakes
it "reads a funded open invoice past its expiry as open, and holds it" testFundedStaysOpen
it "reads a committed registration with no reveal past revealBefore as failed, waking held registration and invoice polls" testLapseReadsFailed
describe "registration poll" $ do
it "answers at once without seenVersion, with another version, or with one that is not a number" testAnswersAtOnce
it "answers unchanged after the hold" testHoldTimesOut
it "answers an unknown registration 404" testUnknownRegistration
it "leaves waitingCount to polls waiting on a payment" testWaitingCount
data Polls = Polls
{ pCtx :: Ctx,
-- | Sets the service's clock, which then runs on in real time, so a hold can end at a moment.
pSetNow :: UTCTime -> IO ()
}
-- | The registration route as namesRoutes registers it, beside the invoice routes, since a NamesEnv needs a running chat controller.
withPolls :: Int -> (Polls -> IO a) -> IO a
withPolls hold action = withOrders $ \ctx@Ctx {cClock, cOrders, cWeb} -> do
started <- getCurrentTime
let elapsed = (`diffUTCTime` started) <$> getCurrentTime
running = addUTCTime <$> elapsed <*> readIORef cClock
orders = cOrders {oeNow = running}
web = cWeb {weOrders = Just orders}
routes = \case
["api", "registration", rid] -> Just Route {rMethod = "GET", rLimit = readLimit, rHandler = registrationHandler orders hold rid}
_ -> Nothing
app req respond = fromMaybe (webApp web req respond) (namesApp (weHttp web) routes req respond)
pSetNow t = elapsed >>= \e -> writeIORef cClock (addUTCTime (negate e) t)
mgr <- newManager defaultManagerSettings
Warp.testWithApplication (pure app) $ \port ->
action Polls {pCtx = ctx {cOrders = orders, cWeb = web, cClient = (mgr, "http://127.0.0.1:" <> show port)}, pSetNow}
-- | How long a held poll is watched for a wake that must not come.
parkDelay :: Int
parkDelay = 200000
-- | How long a poll may take to be held or to answer once woken; far below the hold.
prompt :: Int
prompt = 6000000
-- | How far ahead of a moment the clock is set, so a poll is held well before the moment wakes it.
shortOfMoment :: NominalDiffTime
shortOfMoment = 3
shortHold :: Int
shortHold = 500000
get :: Ctx -> String -> IO (Int, J.Object)
get Ctx {cClient} path = webGet cClient path >>= \r -> (statusOf r,) <$> jsonObject r
-- | The holds the server has taken: invoices held on a payment, and waiters on a registration's version.
subscriptions :: Ctx -> STM (Int, Int)
subscriptions Ctx {cWeb, cOrders} = (,) <$> waitingCountSTM (weWaiters cWeb) <*> phasesWaiting (oePhases cOrders)
-- | A poll once the server holds it, having taken these many more holds of each kind.
held :: Ctx -> (Int, Int) -> String -> IO (Async (Int, J.Object))
held ctx (payments, versions) path = do
(payments0, versions0) <- atomically $ subscriptions ctx
poll <- async $ get ctx path
let holding = subscriptions ctx >>= check . (== (payments0 + payments, versions0 + versions))
timeout prompt (atomically $ (Left <$> waitCatchSTM poll) `orElse` (Right <$> holding)) >>= \case
Just (Right ()) -> pure poll
Just (Left answered) -> fail $ path <> " was answered at once: " <> show answered
Nothing -> cancel poll >> fail (path <> " was not held with " <> show (payments, versions) <> " more holds")
woken :: String -> Async (Int, J.Object) -> IO (Int, J.Object)
woken what poll = timeout prompt (wait poll) >>= maybe (cancel poll >> fail (what <> " was not woken")) pure
answeredAtOnce :: Ctx -> String -> IO (Int, J.Object)
answeredAtOnce ctx path = timeout prompt (get ctx path) >>= maybe (fail (path <> " was held")) pure
invoicePath :: InvoiceId -> String
invoicePath (InvoiceId t) = "/api/invoice/" <> T.unpack t
registrationPath :: RegistrationId -> String
registrationPath (RegistrationId t) = "/api/registration/" <> T.unpack t
-- | The query the page sends to follow an invoice, as it last saw it.
following :: InvoiceStatus -> Int64 -> Text -> Bool -> String
following status version = followingAs status (Just $ show version)
-- | With seenVersion as given, a number or not, or left out.
followingAs :: InvoiceStatus -> Maybe String -> Text -> Bool -> String
followingAs status version paid full =
"?wait=" <> statusText <> maybe "" ("&seenVersion=" <>) version <> "&seenPaid=" <> T.unpack paid <> "&seenFull=" <> (if full then "1" else "0")
where
statusText = case status of
ISOpen -> "open"
ISPaid -> "paid"
ISExpired -> "expired"
seenVersion :: Int64 -> String
seenVersion v = "?seenVersion=" <> show v
-- | A write as the worker or a reveal makes it: a compare-and-set, then a publish after the commit.
change :: Ctx -> RegistrationId -> (NameRegistration -> NameRegistration) -> IO Int64
change Ctx {cStore, cOrders, cClock} rid f = do
now <- readIORef cClock
written <- withTransaction cStore $ \db -> getRegistration db rid >>= \r -> updateRegistration db (f $ fromJust r) now
case written of
Written v -> v <$ atomically (publish (oePhases cOrders) rid v)
other -> fail $ "registration not written: " <> show other
key :: Text -> J.Object -> Maybe J.Value
key k = KM.lookup (K.fromText k)
seconds :: UTCTime -> Integer
seconds = floor . utcTimeToPOSIXSeconds
-- | The settled payment's marks: its crypto amount and paid in full.
settledPaid :: Text
settledPaid = "0.00156"
-- tests
-- | Paid and queued at version 2; each change below is one the worker, a reveal or a re-commit makes.
testEachChangeWakes :: IO ()
testEachChangeWakes = bounded "each change wakes" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(inv, _) <- placed ctx aliceOrder
settleNow ctx inv settled `shouldReturn` Right ISPaid
NameRegistration {nrId} <- invoiceRegistration ctx inv
let day = seconds orderTime + 86400
changes :: [(String, NameRegistration -> NameRegistration, Text, J.Value)]
changes =
[ ("phase", \r -> r {nrPhase = PCommitting}, "phase", "committing"),
("committed", \r -> r {nrPhase = PCommitted, nrRevealAfter = Just (fromInteger day), nrRevealBefore = Just (fromInteger $ day + 86400)}, "revealBefore", J.toJSON (day + 86400)),
("label set", \r -> r {nrReveal = Just reveal}, "label", "alicebakery"),
("label cleared", \r -> r {nrReveal = Nothing}, "label", J.Null),
("reveal times after a re-commit", \r -> r {nrRevealAfter = Just (fromInteger $ day + 60), nrRevealBefore = Just (fromInteger $ day + 86460)}, "revealBefore", J.toJSON (day + 86460)),
("error", \r -> r {nrPhase = PFailed, nrError = Just "The commit transaction failed"}, "error", "The commit transaction failed")
]
forM_ changes $ \(what, f, k, expected) -> do
v <- nrVersion <$> invoiceRegistration ctx inv
invoicePoll <- held ctx (0, 1) $ invoicePath inv <> following ISPaid v settledPaid True
registrationPoll <- held ctx (0, 1) $ registrationPath nrId <> seenVersion v
v' <- change ctx nrId f
(status, o) <- woken (what <> ": invoice poll") invoicePoll
(status, key "status" o, key "version" (registrationOf o), key k (registrationOf o)) `shouldBe` (200, Just "paid", Just (J.toJSON v'), Just expected)
(status', r) <- woken (what <> ": registration poll") registrationPoll
(status', key "version" r, key k r) `shouldBe` (200, Just (J.toJSON v'), Just expected)
testPaidHoldsOnVersion :: IO ()
testPaidHoldsOnVersion = bounded "paid holds on version" $ withPolls holdMicros $ \Polls {pCtx = ctx@Ctx {cWeb}} -> do
(inv, _) <- placed ctx aliceOrder
settleNow ctx inv settled `shouldReturn` Right ISPaid
NameRegistration {nrId, nrVersion} <- invoiceRegistration ctx inv
-- without a version there is nothing a paid invoice could wait for
forM_ [Nothing, Just "two"] $ \version ->
(fst <$> answeredAtOnce ctx (invoicePath inv <> followingAs ISPaid version settledPaid True)) `shouldReturn` 200
poll <- held ctx (0, 1) $ invoicePath inv <> following ISPaid nrVersion settledPaid True
atomically $ publishPayment (weWaiters cWeb) inv
threadDelay parkDelay
Async.poll poll >>= (`shouldSatisfy` isNothing)
v' <- change ctx nrId $ \r -> r {nrPhase = PCommitting}
(_, o) <- woken "paid invoice poll" poll
(key "version" (registrationOf o), key "phase" (registrationOf o)) `shouldBe` (Just (J.toJSON v'), Just "committing")
-- marks other than the page saw answer at once
(fst <$> answeredAtOnce ctx (invoicePath inv <> following ISPaid v' "0.001" True)) `shouldReturn` 200
testLatePaidAnswersAtOnce :: IO ()
testLatePaidAnswersAtOnce = bounded "late paid" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(inv, _) <- placed ctx aliceOrder
fst <$> post ctx (invoicePath inv <> "/cancel") "" `shouldReturn` 200
settleNow ctx inv settled `shouldReturn` Right ISPaid
NameRegistration {nrVersion} <- invoiceRegistration ctx inv
(status, o) <- answeredAtOnce ctx $ invoicePath inv <> following ISPaid nrVersion settledPaid True
(status, key "status" o, key "phase" (registrationOf o)) `shouldBe` (200, Just "paid", Just "unpaid")
testOpenWakesOnVersion :: IO ()
testOpenWakesOnVersion = bounded "open wakes on version" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(inv, _) <- placed ctx aliceOrder
NameRegistration {nrId, nrVersion} <- invoiceRegistration ctx inv
-- a version the page has not seen answers at once
(fst <$> answeredAtOnce ctx (invoicePath inv <> following ISOpen (nrVersion - 1) "" False)) `shouldReturn` 200
poll <- held ctx (1, 1) $ invoicePath inv <> following ISOpen nrVersion "" False
v' <- change ctx nrId $ \r -> r {nrError = Just "Checking the payment"}
(_, o) <- woken "open invoice poll" poll
(key "status" o, key "version" (registrationOf o)) `shouldBe` (Just "open", Just (J.toJSON v'))
-- a seenVersion that is no version leaves the hold on the status and payment alone
byStatus <- held ctx (1, 0) $ invoicePath inv <> followingAs ISOpen (Just "two") "" False
settleNow ctx inv (SigFunded (rcv 5000 (Just "0.00078")) PaidInPart) `shouldReturn` Right ISOpen
(_, paidInPart) <- woken "open invoice poll without a version" byStatus
(key "status" paidInPart, key "cryptoAmountPaid" paidInPart) `shouldBe` (Just "open", Just "0.00078")
-- | The stub's crypto invoice expires 45 minutes after the order; the clock is set just short of it.
testExpiryWakes :: IO ()
testExpiryWakes = bounded "expiry wakes" $ withPolls holdMicros $ \Polls {pCtx = ctx, pSetNow} -> do
(inv, _) <- placed ctx aliceOrder
Just InvoiceRow {irExpiresAt} <- getInvoice (cStore ctx) inv
NameRegistration {nrVersion} <- invoiceRegistration ctx inv
pSetNow $ addUTCTime (negate shortOfMoment) irExpiresAt
poll <- held ctx (1, 0) $ invoicePath inv <> followingAs ISOpen Nothing "" False
(status, o) <- woken "unpaid invoice poll" poll
(status, key "status" o, key "version" (registrationOf o)) `shouldBe` (200, Just "expired", Just (J.toJSON nrVersion))
-- read so, not written: the sweep or the next order closes it
(irStatus <$>) <$> getInvoice (cStore ctx) inv `shouldReturn` Just ISOpen
(fst <$> answeredAtOnce ctx (invoicePath inv <> following ISOpen nrVersion "" False)) `shouldReturn` 200
testFundedStaysOpen :: IO ()
testFundedStaysOpen = bounded "funded stays open" $ withPolls holdMicros $ \Polls {pCtx = ctx, pSetNow} -> do
(inv, _) <- placed ctx aliceOrder
settleNow ctx inv (SigFunded (rcv 5000 (Just "0.00078")) PaidInPart) `shouldReturn` Right ISOpen
Just InvoiceRow {irExpiresAt} <- getInvoice (cStore ctx) inv
NameRegistration {nrVersion} <- invoiceRegistration ctx inv
pSetNow $ addUTCTime 60 irExpiresAt
(status, o) <- get ctx (invoicePath inv)
(status, key "status" o) `shouldBe` (200, Just "open")
poll <- held ctx (1, 1) $ invoicePath inv <> following ISOpen nrVersion "0.00078" False
cancel poll
testLapseReadsFailed :: IO ()
testLapseReadsFailed = bounded "lapse" $ withPolls holdMicros $ \Polls {pCtx = ctx@Ctx {cOrders}, pSetNow} -> do
(inv, _) <- placed ctx aliceOrder
settleNow ctx inv settled `shouldReturn` Right ISPaid
NameRegistration {nrId} <- invoiceRegistration ctx inv
now <- oeNow cOrders
let revealBefore = seconds now + 600
lapsedAt = posixSecondsToUTCTime (fromInteger revealBefore)
pSetNow $ addUTCTime (negate shortOfMoment) lapsedAt
v <- change ctx nrId $ \r -> r {nrPhase = PCommitted, nrRevealAfter = Just (fromInteger $ revealBefore - 3600), nrRevealBefore = Just (fromInteger revealBefore)}
(_, r) <- get ctx (registrationPath nrId)
key "phase" r `shouldBe` Just "committed"
invoicePoll <- held ctx (0, 1) $ invoicePath inv <> following ISPaid v settledPaid True
poll <- held ctx (0, 1) $ registrationPath nrId <> seenVersion v
(status, lapsed) <- woken "registration poll at the lapse" poll
(status, key "phase" lapsed, key "error" lapsed, key "version" lapsed) `shouldBe` (200, Just "failed", Just "The name was not signed in time", Just (J.toJSON v))
(_, o) <- woken "invoice poll at the lapse" invoicePoll
(key "status" o, key "phase" (registrationOf o), key "error" (registrationOf o)) `shouldBe` (Just "paid", Just "failed", Just "The name was not signed in time")
(nrPhase <$> invoiceRegistration ctx inv) `shouldReturn` PCommitted
-- one with a reveal set stays committed past revealBefore
revealed <- change ctx nrId $ \r' -> r' {nrReveal = Just reveal}
pSetNow $ addUTCTime 3600 lapsedAt
(_, r') <- get ctx (registrationPath nrId)
(key "phase" r', key "label" r', key "version" r') `shouldBe` (Just "committed", Just "alicebakery", Just (J.toJSON revealed))
testAnswersAtOnce :: IO ()
testAnswersAtOnce = bounded "at once" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(inv, _) <- placed ctx aliceOrder
NameRegistration {nrId = rid@(RegistrationId ridText), nrVersion} <- invoiceRegistration ctx inv
forM_ ["", seenVersion (nrVersion + 1), seenVersion (nrVersion - 1), "?seenVersion=one", "?seenVersion=-1", "?seenVersion=99999999999999999999"] $ \q -> do
(status, r) <- answeredAtOnce ctx (registrationPath rid <> q)
(q, status, key "id" r, key "version" r, key "phase" r) `shouldBe` (q, 200, Just (J.String ridText), Just (J.toJSON nrVersion), Just "unpaid")
testHoldTimesOut :: IO ()
testHoldTimesOut = bounded "hold times out" $ withPolls shortHold $ \Polls {pCtx = ctx} -> do
(inv, _) <- placed ctx aliceOrder
NameRegistration {nrId, nrVersion} <- invoiceRegistration ctx inv
started <- getCurrentTime
(status, r) <- get ctx $ registrationPath nrId <> seenVersion nrVersion
waited <- (`diffUTCTime` started) <$> getCurrentTime
(status, key "version" r) `shouldBe` (200, Just (J.toJSON nrVersion))
waited `shouldSatisfy` (>= (fromIntegral shortHold / 1000000 :: NominalDiffTime))
testUnknownRegistration :: IO ()
testUnknownRegistration = bounded "unknown" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(status, o) <- answeredAtOnce ctx (registrationPath (RegistrationId "t2Jk8RmQ4vXw9NcP3yLb6g") <> seenVersion 1)
(status, o) `shouldBe` (404, KM.fromList [("error", "not_found")])
-- | The poller reads providers sooner while a page waits on a payment; a hold on a version waits on none.
testWaitingCount :: IO ()
testWaitingCount = bounded "waiting count" $ withPolls holdMicros $ \Polls {pCtx = ctx} -> do
(paid, _) <- placed ctx aliceOrder
settleNow ctx paid settled `shouldReturn` Right ISPaid
NameRegistration {nrId, nrVersion} <- invoiceRegistration ctx paid
polls <- mapM (held ctx (0, 1)) [registrationPath nrId <> seenVersion nrVersion, invoicePath paid <> following ISPaid nrVersion settledPaid True]
atomically (subscriptions ctx) `shouldReturn` (0, 2)
(open, _) <- placed ctx aliceOrder {oLabel = "dynamis", oPrice = 20000, oCommitment = commitmentOf 2}
NameRegistration {nrVersion = openVersion} <- invoiceRegistration ctx open
openPoll <- held ctx (1, 1) $ invoicePath open <> following ISOpen openVersion "" False
atomically (subscriptions ctx) `shouldReturn` (1, 3)
mapM_ cancel (openPoll : polls)
@@ -0,0 +1,158 @@
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
module Bots.StoreService.NamesSignatureTests (namesSignatureTests) where
import Control.Monad (forM_)
import Data.ByteArray.Encoding (Base (Base16), convertFromBase)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import Data.Maybe (fromMaybe)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Text.Encoding (encodeUtf8)
import Data.Word (Word64)
import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature (..))
import Simplex.Messaging.Encoding.String (strDecode)
import Simplex.Messaging.Eth.Address (Address, recoverAddress)
import Simplex.Messaging.SimplexName (SimplexTLD (..), labelHash)
import StoreService.Names.Abi
import StoreService.Names.Registration
import StoreService.Names.Signatures
import Test.Hspec
namesSignatureTests :: Spec
namesSignatureTests = describe "StoreService names: signatures" $ do
-- expected values are viem 2.57.5's for the fixtures below, the webapp's wallet (BIP-39 entropy 6f2d1c9a4b7e3f80d15a2c6e9b04f7a3, account 0)
-- and the SimplexSponsor, SimplexController, SimplexResolver and SimplexPriceOracle ABIs of ens-contracts PR #36 at 23892cc
describe "EIP-712" $ do
it "commits to a registration with one contact link" $
makeCommitment dynamis `shouldBe` commitment
it "hashes RegisterName" $
registerIntentDigest (sponsorDomain chainId sponsor) dynamis 0 1800000000 `shouldBe` hx "0x4b0bcc282db581446f6c25e0e3fbe2839409acbc011bb3e082523dd9eab85a6a"
describe "EIP-191 messages" $ do
it "signs an order" $
testMessage
(orderMessage dynamisOrder timestamp)
"simplex.domains order 0x78b602f03f164366531da963764c1f2fdfd588d0487daf2aa261ca799e5ffe33 7 69259500 0x9cf04ddef2eedfb02e6e7ba58f879c0636c584b6acc67ffe9f97a06bfb016ac1 0xb1971beb567c8dc1b2f01f0d823754c6168d8d6830db2221702a7678e1804674 1792574100"
"0x5deee1b3589df9e53665e34aa65a491a4eabfd76a39207b0e9303457f7c44b7a"
"0x73e32be461e99e64b093a4ad09b04b4d810e5623a1b0e9c9fdb4701ec2a6a2a84df9ffdccc39c5cb827cde4d846c7662f591665f1b868ab1c15778646d3f414e1b"
describe "signature format" $ do
it "refuses a high s, though recovery accepts it" testHighS
it "refuses v other than 27 or 28" $
forM_ ["00", "01", "1d"] $ \v -> parseSignature (T.dropEnd 2 orderSignature <> v) `shouldBe` Left SERecoveryId
it "refuses uppercase hex, no 0x and a wrong length" $ do
parseSignature ("0x" <> T.toUpper (T.drop 2 orderSignature)) `shouldBe` Left SEFormat
parseSignature (T.drop 2 orderSignature) `shouldBe` Left SEFormat
parseSignature (T.dropEnd 2 orderSignature) `shouldBe` Left SEFormat
parseSignature (orderSignature <> "00") `shouldBe` Left SEFormat
describe "addresses" $ do
it "accepts the EIP-55 form in orders" $
parseChecksumAddress ownerText `shouldBe` Right owner
it "refuses a letter in the wrong case and one-case hex in orders" $ do
parseChecksumAddress "0x014F9c09CcEeDEF1B713110d04D3a07d5B5D9b73" `shouldBe` Left ADChecksum
parseChecksumAddress ownerLower `shouldBe` Left ADChecksum
parseChecksumAddress ownerUpper `shouldBe` Left ADChecksum
it "accepts any case in find" $
forM_ [ownerText, ownerLower, ownerUpper, "0x014F9c09CcEeDEF1B713110d04D3a07d5B5D9b73"] $ \a ->
parseAnyCaseAddress a `shouldBe` Right owner
it "refuses what is not an address" $
forM_ ["014f9c09cceedef1b713110d04d3a07d5b5d9b73", "0X014f9c09cceedef1b713110d04d3a07d5b5d9b73", T.dropEnd 1 ownerLower, ownerLower <> "0", "0x014f9c09cceedef1b713110d04d3a07d5b5d9b7g"] $ \a -> do
parseAnyCaseAddress a `shouldBe` Left ADFormat
parseChecksumAddress a `shouldBe` Left ADFormat
describe "ABI return data" $ do
it "decodes each type as viem encodes it" $ do
decodeUint256 (hx "00000000000000000000000000000000000000018ee90ff6c373e0ee4e3f0ad2") `shouldBe` Right 123456789012345678901234567890
decodeAddress (hx "000000000000000000000000014f9c09cceedef1b713110d04d3a07d5b5d9b73") `shouldBe` Right owner
decodeBool (hx "0000000000000000000000000000000000000000000000000000000000000001") `shouldBe` Right True
decodeBool (B.replicate 32 0) `shouldBe` Right False
decodeBytes32 (hx "833cc73a7eae1ddee67ec8845ec3d39799406c7bc87fab7c504a7e0ab5cb89bb") `shouldBe` Right node
decodeString retString `shouldBe` Right "https://smp8.simplex.im/a#contact"
decodeString (hx "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000") `shouldBe` Right ""
decodeBytes (hx "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000010410f13a8c833cc73a7eae1ddee67ec8845ec3d39799406c7bc87fab7c504a7e0ab5cb89bb000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000f73696d706c65782e636f6e746163740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002168747470733a2f2f736d70382e73696d706c65782e696d2f6123636f6e746163740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") `shouldBe` Right (hx "10f13a8c833cc73a7eae1ddee67ec8845ec3d39799406c7bc87fab7c504a7e0ab5cb89bb000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000f73696d706c65782e636f6e746163740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002168747470733a2f2f736d70382e73696d706c65782e696d2f6123636f6e7461637400000000000000000000000000000000000000000000000000000000000000")
it "refuses data that does not hold the type" $ do
decodeUint256 (B.replicate 31 0) `shouldBe` Left AEShort
decodeAddress (B.singleton 1 <> B.drop 1 (hx "000000000000000000000000014f9c09cceedef1b713110d04d3a07d5b5d9b73")) `shouldBe` Left AENotAddress
decodeBool (uint256 (2 :: Int)) `shouldBe` Left AENotBool
decodeString (uint256 (4096 :: Int) <> B.drop 32 retString) `shouldBe` Left AEOffset
decodeString (B.take 80 retString) `shouldBe` Left AEShort
decodeString (abiTuple [Dynamic $ abiBytes "\xff"]) `shouldBe` Left AENotUtf8
testMessage :: ByteString -> ByteString -> Text -> Text -> IO ()
testMessage msg expected digest signature = do
msg `shouldBe` expected
personalDigest msg `shouldBe` hx digest
sig <- either (fail . show) pure $ parseSignature signature
recoverAddress sig (personalDigest msg) `shouldReturn` Right owner
testHighS :: IO ()
testHighS = do
parseSignature highS `shouldBe` Left SEHighS
let (rsR, (rsS, v)) = B.splitAt 32 <$> B.splitAt 32 (hx highS)
recoverAddress RecoverableSignature {rsR, rsS, rsRecId = B.head v - 27} (personalDigest $ orderMessage dynamisOrder timestamp)
`shouldReturn` Right owner
where
highS = "0x73e32be461e99e64b093a4ad09b04b4d810e5623a1b0e9c9fdb4701ec2a6a2a8b206002333c63a347d8321b27b93899bc51d768793c21589fe7ae62862f6fff31c"
-- fixtures
dynamis :: Registration
dynamis =
Registration
{ rLabel = "dynamis",
rTLD = TLDSimplex,
rOwner = owner,
rDuration = duration,
rSecret = B.replicate 32 0x11,
rResolver = resolver,
rContactLink = Just "https://smp8.simplex.im/a#contact",
rChannelLink = Nothing
}
dynamisOrder :: OrderFields
dynamisOrder =
OrderFields
{ ofLabelHash = labelHash "dynamis",
ofLength = 7,
ofDuration = duration,
ofCommitment = commitment,
ofSealed = "q3Zk0Yx7c2VhbGVkLW9yZGVyLWZpeHR1cmU"
}
commitment :: ByteString
commitment = hx "0x9cf04ddef2eedfb02e6e7ba58f879c0636c584b6acc67ffe9f97a06bfb016ac1"
node :: ByteString
node = hx "0x833cc73a7eae1ddee67ec8845ec3d39799406c7bc87fab7c504a7e0ab5cb89bb"
-- 21 October 2026 09:15 UTC
timestamp :: Word64
timestamp = 1792574100
-- 2 years of 365 days and the free days until 1 January 2027
duration :: Word64
duration = 69259500
orderSignature :: Text
orderSignature = "0x73e32be461e99e64b093a4ad09b04b4d810e5623a1b0e9c9fdb4701ec2a6a2a84df9ffdccc39c5cb827cde4d846c7662f591665f1b868ab1c15778646d3f414e1b"
retString :: ByteString
retString = hx "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002168747470733a2f2f736d70382e73696d706c65782e696d2f6123636f6e7461637400000000000000000000000000000000000000000000000000000000000000"
owner :: Address
owner = either error id $ strDecode $ encodeUtf8 ownerText
ownerText, ownerLower, ownerUpper :: Text
ownerText = "0x014f9c09CcEeDEF1B713110d04D3a07d5B5D9b73"
ownerLower = T.toLower ownerText
ownerUpper = "0x" <> T.toUpper (T.drop 2 ownerText)
sponsor, resolver :: Address
sponsor = either error id $ strDecode "0x9a676e781a523b5d0c0e43731313a708cb607508"
resolver = either error id $ strDecode "0x2279b7a0a67db372996a5fab50d91eaa73d2ebe6"
chainId :: Word64
chainId = 31337
hx :: Text -> ByteString
hx t = either error id $ convertFromBase Base16 $ encodeUtf8 $ fromMaybe t $ T.stripPrefix "0x" t
+709
View File
@@ -0,0 +1,709 @@
{-# LANGUAGE CPP #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
module Bots.StoreService.NamesStoreTests (namesStoreTests, at, btc, insertInvoiceRow, invoiceStatus, issue, newReg, order, ownerA, ownerB, paidOrder, placeCode, placePaid, price, reg, reveal, signature, t0, usable, write) where
import Bots.StoreService.WebTests (columnsOf, digestFixture, runMigrations, withServiceStore)
import Control.Arrow ((&&&))
import Control.Monad (forM_, void)
import Data.List (sort)
import Data.Maybe (fromJust, mapMaybe)
import Data.Text (Text)
import qualified Data.Text as T
import Data.Time.Calendar (fromGregorian)
import Data.Time.Clock (UTCTime (..), addUTCTime)
import Data.Word (Word8)
import Simplex.Chat.Badges.Types (BadgeCodePaymentStatus (..))
import Simplex.Chat.PaymentService.Types (CardProvider (..), CryptoCurrency (..), InvoiceId (..), ServicePaymentMethod (..))
import Simplex.Messaging.Agent.Store.Common (DBStore, withTransaction)
import qualified Simplex.Messaging.Agent.Store.DB as DB
import Simplex.Messaging.Agent.Store.Shared (Migration (..), MigrationsToRun (..), toDownMigration)
import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature)
import Simplex.Messaging.Eth.Address (Address)
import Simplex.Messaging.SimplexName (labelHash)
import StoreService.Names.Chain (TxHash (..))
import StoreService.Names.Phases (RegistrationId (..))
import StoreService.Names.Signatures (OrderFields (..), parseAnyCaseAddress, parseSignature)
import StoreService.Names.Store
import StoreService.Store (RevokeResult (..))
import Test.Hspec
#if defined(dbPostgres)
import Database.PostgreSQL.Simple (Only (..), (:.) (..))
import Database.PostgreSQL.Simple.Errors (ConstraintViolation (..), constraintViolation)
import StoreService.Store.Postgres.Migrations (storeServiceSchemaMigrations)
#else
import Database.SQLite.Simple (Error (ErrorConstraint), Only (..), SQLError (..), (:.) (..))
import StoreService.Store.SQLite.Migrations (storeServiceSchemaMigrations)
#endif
namesStoreTests :: Spec
namesStoreTests = describe "StoreService names: store" $ do
describe "migration" $ do
it "creates the names tables with the planned columns" testNamesColumns
it "rolls back and re-applies only the names migrations, with rows in them, leaving the badge tables and paid invoices as they were" testNamesDownUp
it "turns a code_issued order taken at price 0 and not live at its next version, dropping issued_code_id with its index and foreign key, which the down migration restores" testDropTakenCodes
describe "order hash" $ do
it "is equal for the same order fields, and differs when any one field differs" testOrderHashFields
it "keeps field boundaries, so moving a byte between two fields changes it" testOrderHashBoundaries
describe "registrations" $ do
it "creates a paid order unpaid and live at version 1, linked to its invoice" testCreatePaid
it "creates a code order queued with its code reserved" testCreateCode
it "refuses a second live order for one owner and label hash, or for one commitment" testLiveUnique
it "leaves no registration when the code cannot be reserved" testCodeNotReservable
it "finds an exact resend by its order hash, live or not" testOrderHashLookup
it "tells an overdue live order apart, whatever the poller marked, unless paid" testLiveOrdersOverdue
it "closes an overdue order so a new one from the same wallet fits in the same transaction" testCloseOverdue
it "closes nothing from a stale version" testCloseOverdueStale
it "bumps the version on every write and changes nothing for a stale one" testVersionBumps
it "writes and reads back every changeable field, and clears the reveal" testRoundTrip
it "keeps live in step with the phase" testLiveFollowsPhase
it "is live while an order can still progress to a registration for its name" testOrderLive
it "lets a wallet order a name again once its registration is done" testReorderAfterRegistered
it "refuses to queue a closed order, also when a newer live order holds its name" testLatePayment
it "finds an owner's orders newest first, at most 50" testFind
it "orders registrations made in the same second by their id" testSameSecondOrder
it "tells a label being registered here" testLabelRegistering
it "lists the registrations a worker moves on" testActive
it "lists unpaid orders whose invoice expired before the cutoff without a payment, and deletes one with its invoice" testUnpaidCleanup
it "lists code orders failed before the cutoff that still hold their code" testFailedCodeOrders
describe "prepaid codes" $ do
it "issues one code per hash" testIssueCode
it "reserves only an unused code, releases and spends it only for its holder" testReserveReleaseSpend
it "refuses an unpaid, revoked or expired code" testReserveRefused
it "lets a registration hold one code" testOneCodePerRegistration
it "revokes an unspent code, reserved or not, never a spent one" testRevoke
describe "transactions" $ do
it "keeps a signed transaction pending until its outcome, and lists them by owner" testTransactions
it "moves a transaction only from the status its caller read" testTransactionFromStatus
t0 :: UTCTime
t0 = UTCTime (fromGregorian 2026 10 21) 0
at :: Int -> UTCTime
at minutes = addUTCTime (fromIntegral $ minutes * 60) t0
ownerA :: Address
ownerA = address "0x014f9c09CcEeDEF1B713110d04D3a07d5B5D9b73"
ownerB :: Address
ownerB = address "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318"
address :: Text -> Address
address = either (error . show) id . parseAnyCaseAddress
-- r all 0x11, s all 0x22 (a low s), v 27
signature :: RecoverableSignature
signature = either (error . show) id $ parseSignature $ "0x" <> T.replicate 32 "11" <> T.replicate 32 "22" <> "1b"
twoYears :: Int
twoYears = 2
order :: Text -> Word8 -> OrderFields
order label n =
OrderFields
{ ofLabelHash = labelHash label,
ofLength = T.length label,
ofDuration = 69292800,
ofCommitment = digestFixture n,
ofSealed = "sealed-" <> label <> "-" <> T.pack (show n)
}
newReg :: Text -> Address -> OrderFields -> NewRegistration
newReg rid nrgOwner nrgOrder = NewRegistration {nrgId = RegistrationId rid, nrgOwner, nrgOrder, nrgYears = twoYears}
btc :: ServicePaymentMethod
btc = SPMCrypto CCBtc
price :: Int
price = 20000
paidOrder :: Text -> PaidOrder
paidOrder invId = PaidOrder {poMethod = btc, poPrice = price, poInvoiceId = InvoiceId invId, poProviderRef = "ref-" <> invId}
insertInvoiceRow :: DB.Connection -> Text -> UTCTime -> Text -> IO ()
insertInvoiceRow db invId expiresAt status =
DB.execute
db
"INSERT INTO sx_badge_service_invoices (invoice_id, provider, price, amount, currency, payment_address, payment_crypto_currency, payment_crypto_amount, expires_at, status, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)"
((invId, "crypto" :: Text, price, price, "usd" :: Text, "bc1qexampleaddress" :: Text, "btc" :: Text, "0.00312" :: Text) :. (expiresAt, status, t0, t0))
-- | A paid order whose invoice, named after the registration, expires at the given time.
placePaid :: DBStore -> Text -> Address -> OrderFields -> UTCTime -> IO (Either RegistrationRefused ())
placePaid st rid owner o expiresAt = withTransaction st $ \db -> do
insertInvoiceRow db ("inv-" <> rid) expiresAt "open"
createPaidRegistration db (newReg rid owner o) (paidOrder $ "inv-" <> rid) t0
issue :: DBStore -> Word8 -> NewPrepaidCode -> IO PrepaidCode
issue st n c = withTransaction st $ \db -> do
Right codeId <- insertPrepaidCode db c {npcCodeHash = digestFixture n} t0
fromJust <$> getPrepaidCodeById db codeId
usable :: NewPrepaidCode
usable = NewPrepaidCode {npcCodeHash = "", npcMinLength = 8, npcYears = twoYears, npcPaymentStatus = CPSPaid, npcExpiresAt = Nothing}
placeCode :: DBStore -> Text -> Address -> OrderFields -> PrepaidCode -> IO (Either RegistrationRefused ())
placeCode st rid owner o code = withTransaction st $ \db -> createCodeRegistration db (newReg rid owner o) code t0
reg :: DBStore -> Text -> IO NameRegistration
reg st rid = withTransaction st $ \db -> fromJust <$> getRegistration db (RegistrationId rid)
write :: DBStore -> NameRegistration -> IO VersionWrite
write st r = withTransaction st $ \db -> updateRegistration db r (at 1)
namesTables :: [Text]
namesTables = map ("sx_badge_service_name_" <>) ["prepaid_codes", "registrations", "invoices", "record_edits", "transactions"]
badgeTables :: [Text]
badgeTables = map ("sx_badge_service_" <>) ["invoices", "payments", "badge_prices", "badge_offers", "badge_purchases", "badge_ledger", "badge_issuances", "badge_codes", "badge_code_invoices", "group"]
testNamesColumns :: IO ()
testNamesColumns = withServiceStore $ \st -> do
let has table cols = columnsOf st table >>= \cs -> filter (`notElem` cs) cols `shouldBe` []
has "sx_badge_service_name_prepaid_codes" ["name_prepaid_code_id", "code_hash", "min_length", "years", "code_payment_status", "reserved_by", "reserved_at", "spent_at", "revoked_at", "expires_at", "created_at"]
has
"sx_badge_service_name_registrations"
[ "registration_id", "label_hash", "length", "label", "secret", "contact_link", "channel_link", "intent_nonce", "intent_deadline", "intent_signature",
"sealed", "owner", "commitment", "phase", "commit_tx", "commit_block", "register_tx", "register_block", "reveal_after", "reveal_before",
"years", "duration", "expires_at", "price", "name_prepaid_code_id", "registered_at", "failed_at", "error", "created_at",
"updated_at", "version", "live", "order_hash", "method", "moves", "links_refused_at"
]
has "sx_badge_service_name_invoices" ["invoice_id", "registration_id", "provider_ref"]
has "sx_badge_service_name_record_edits" ["label_hash", "owner", "nonce", "body_hash", "state", "revert", "mined_tx", "created_at"]
has "sx_badge_service_name_transactions" ["registration_id", "name_record_edit_id", "kind", "raw", "tx_hash", "registrar_nonce", "sent_at", "mined_block", "status"]
testNamesDownUp :: IO ()
testNamesDownUp = withServiceStore $ \st -> do
let names = dropWhile ((/= "20261013_names") . name) storeServiceSchemaMigrations
badgeColumns = mapM (fmap sort . columnsOf st) badgeTables
map name names `shouldBe` ["20261013_names", "20261022_drop_taken_codes"]
badgeBefore <- badgeColumns
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
placePaid st "r2" ownerB (order "bobsbakery" 2) (at 60) `shouldReturn` Right ()
placePaid st "r3" ownerB (order "carolsbakery" 3) (at 60) `shouldReturn` Right ()
withTransaction st $ \db -> insertPayment db "inv-r3"
runMigrations st $ MTRDown (mapMaybe toDownMigration names)
mapM (columnsOf st) namesTables `shouldReturn` map (const []) namesTables
mapM (invoiceCount st) ["inv-r2", "inv-r3"] `shouldReturn` [0, 1]
badgeColumns `shouldReturn` badgeBefore
runMigrations st $ MTRUp names
mapM (fmap null . columnsOf st) namesTables `shouldReturn` map (const False) namesTables
badgeColumns `shouldReturn` badgeBefore
testDropTakenCodes :: IO ()
testDropTakenCodes = withServiceStore $ \st -> do
let dropCodes = [m | m@Migration {name = "20261022_drop_taken_codes"} <- storeServiceSchemaMigrations]
issuedCode = (,) <$> (elem "issued_code_id" <$> columnsOf st "sx_badge_service_name_registrations") <*> indexExists st "sx_badge_service_idx_name_registrations_issued_code"
worth r = (nrPhase r, nrPrice r, nrLive r, nrVersion r)
length dropCodes `shouldBe` 1
runMigrations st $ MTRDown (mapMaybe toDownMigration dropCodes)
issuedCode `shouldReturn` (True, True)
code <- issue st 1 usable
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
placePaid st "r2" ownerB (order "bobsbakery" 2) (at 60) `shouldReturn` Right ()
withTransaction st $ \db -> DB.execute db "UPDATE sx_badge_service_name_registrations SET phase = 'code_issued', issued_code_id = ? WHERE registration_id = 'r1'" (Only $ pcId code)
r2 <- reg st "r2"
write st r2 {nrPhase = PTaken} `shouldReturn` Written 2
taken <- reg st "r2"
runMigrations st $ MTRUp dropCodes
issuedCode `shouldReturn` (False, False)
worth <$> reg st "r1" `shouldReturn` (PTaken, 0, False, 2)
reg st "r2" `shouldReturn` taken
withTransaction st (\db -> getPrepaidCodeById db (pcId code)) `shouldReturn` Just code
runMigrations st $ MTRDown (mapMaybe toDownMigration dropCodes)
issuedCode `shouldReturn` (True, True)
worth <$> reg st "r1" `shouldReturn` (PTaken, 0, False, 2)
withTransaction st (\db -> DB.execute db "UPDATE sx_badge_service_name_registrations SET issued_code_id = ? WHERE registration_id = 'r1'" (Only $ pcId code + 1)) `shouldThrow` foreignKeyViolation
testOrderHashFields :: IO ()
testOrderHashFields = do
let o = order "alicebakery" 1
paid = OTInvoice btc price
base = orderHash ownerA o paid
variants =
[ ("labelHash" :: Text, orderHash ownerA o {ofLabelHash = labelHash "alicebakers"} paid),
("length", orderHash ownerA o {ofLength = 12} paid),
("duration", orderHash ownerA o {ofDuration = 69292801} paid),
("owner", orderHash ownerB o paid),
("commitment", orderHash ownerA o {ofCommitment = digestFixture 2} paid),
("sealed", orderHash ownerA o {ofSealed = ofSealed o <> "x"} paid),
("method", orderHash ownerA o (OTInvoice (SPMCard CPStripe) price)),
("price", orderHash ownerA o (OTInvoice btc (price + 1))),
("code instead of invoice", orderHash ownerA o (OTCode $ digestFixture 3)),
("another code", orderHash ownerA o (OTCode $ digestFixture 4))
]
orderHash ownerA (order "alicebakery" 1) paid `shouldBe` base
forM_ variants $ \(field, h) -> (field, h == base) `shouldBe` (field, False)
orderHash ownerA o (OTCode $ digestFixture 3) `shouldNotBe` orderHash ownerA o (OTCode $ digestFixture 4)
testOrderHashBoundaries :: IO ()
testOrderHashBoundaries = do
let o = order "alicebakery" 1
orderHash ownerA o {ofSealed = "ab"} (OTCode "c") `shouldNotBe` orderHash ownerA o {ofSealed = "a"} (OTCode "bc")
testCreatePaid :: IO ()
testCreatePaid = withServiceStore $ \st -> do
let o = order "alicebakery" 1
placePaid st "r1" ownerA o (at 60) `shouldReturn` Right ()
r <- reg st "r1"
r
`shouldBe` NameRegistration
{ nrId = RegistrationId "r1",
nrVersion = 1,
nrLabelHash = ofLabelHash o,
nrLength = 11,
nrDuration = 69292800,
nrOwner = ownerA,
nrCommitment = ofCommitment o,
nrSealed = ofSealed o,
nrPhase = PUnpaid,
nrYears = twoYears,
nrPrice = price,
nrPayment = RPInvoice btc (InvoiceId "inv-r1"),
nrReveal = Nothing,
nrCommitTx = Nothing,
nrCommitBlock = Nothing,
nrRegisterTx = Nothing,
nrRegisterBlock = Nothing,
nrRevealAfter = Nothing,
nrRevealBefore = Nothing,
nrExpiresAt = Nothing,
nrRegisteredAt = Nothing,
nrFailedAt = Nothing,
nrError = Nothing,
nrLive = True,
nrOrderHash = orderHash ownerA o (OTInvoice btc price),
nrMoves = 0,
nrLinksRefusedAt = Nothing,
nrCreatedAt = t0,
nrUpdatedAt = t0
}
testCreateCode :: IO ()
testCreateCode = withServiceStore $ \st -> do
let o = order "alicebakery" 1
code@PrepaidCode {pcId, pcCodeHash} <- issue st 1 usable
placeCode st "r1" ownerA o code `shouldReturn` Right ()
r <- reg st "r1"
(nrPhase r, nrLive r, nrPrice r, nrPayment r, nrVersion r) `shouldBe` (PQueued, True, 0, RPCode pcId, 1)
nrOrderHash r `shouldBe` orderHash ownerA o (OTCode pcCodeHash)
held <- withTransaction st $ \db -> getPrepaidCode db pcCodeHash
(pcReservedBy =<< held, pcReservedAt =<< held) `shouldBe` (Just (RegistrationId "r1"), Just t0)
testLiveUnique :: IO ()
testLiveUnique = withServiceStore $ \st -> do
let o = order "alicebakery" 1
placePaid st "r1" ownerA o (at 60) `shouldReturn` Right ()
placePaid st "r2" ownerA o {ofCommitment = digestFixture 2} (at 60) `shouldReturn` Left RRLiveOrder
placePaid st "r3" ownerB o (at 60) `shouldReturn` Left RRLiveOrder
code <- issue st 9 usable
placeCode st "r4" ownerA (order "alicebakery" 3) code `shouldReturn` Left RRLiveOrder
placePaid st "r5" ownerB (order "alicebakery" 5) (at 60) `shouldReturn` Right ()
existing <- withTransaction st $ \db -> mapM (getRegistration db . RegistrationId) ["r2", "r3", "r4"]
existing `shouldBe` [Nothing, Nothing, Nothing]
free <- withTransaction st $ \db -> getPrepaidCodeById db (pcId code)
(pcReservedBy =<< free) `shouldBe` Nothing
testCodeNotReservable :: IO ()
testCodeNotReservable = withServiceStore $ \st -> do
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
placeCode st "r2" ownerB (order "bobsbakery" 2) code `shouldReturn` Left RRCodeNotReservable
withTransaction st (\db -> getRegistration db (RegistrationId "r2")) `shouldReturn` Nothing
held <- withTransaction st $ \db -> getPrepaidCodeById db (pcId code)
(pcReservedBy =<< held) `shouldBe` Just (RegistrationId "r1")
testOrderHashLookup :: IO ()
testOrderHashLookup = withServiceStore $ \st -> do
let o = order "alicebakery" 1
placePaid st "r1" ownerA o (at 1) `shouldReturn` Right ()
r <- reg st "r1"
closed <- withTransaction st $ \db -> closeOverdue db r (at 2)
closed `shouldBe` Just 2
found <- withTransaction st $ \db -> getRegistrationByOrderHash db (orderHash ownerA o (OTInvoice btc price))
(nrId <$> found, nrLive <$> found) `shouldBe` (Just (RegistrationId "r1"), Just False)
withTransaction st (\db -> getRegistrationByOrderHash db (orderHash ownerA o (OTInvoice btc (price + 1)))) `shouldReturn` Nothing
testLiveOrdersOverdue :: IO ()
testLiveOrdersOverdue = withServiceStore $ \st -> do
let o = order "alicebakery" 1
live now = withTransaction st $ \db -> map (\LiveOrder {loRegistration, loOverdue} -> (nrId loRegistration, loOverdue)) <$> getLiveOrders db (ofCommitment o) ownerA (ofLabelHash o) now
setStatus status = withTransaction st $ \db -> DB.execute db "UPDATE sx_badge_service_invoices SET status = ? WHERE invoice_id = ?" (status :: Text, "inv-r1" :: Text)
placePaid st "r1" ownerA o (at 60) `shouldReturn` Right ()
placePaid st "r2" ownerB (order "alicebakery" 2) (at 60) `shouldReturn` Right ()
live (at 30) `shouldReturn` [(RegistrationId "r1", False)]
live (at 61) `shouldReturn` [(RegistrationId "r1", True)]
withTransaction st (\db -> map (nrId . loRegistration) <$> getLiveOrders db (ofCommitment o) ownerB (labelHash "zzzzzzzz") (at 30))
`shouldReturn` [RegistrationId "r1"]
setStatus "expired"
live (at 61) `shouldReturn` [(RegistrationId "r1", True)]
setStatus "paid"
live (at 61) `shouldReturn` [(RegistrationId "r1", False)]
testCloseOverdue :: IO ()
testCloseOverdue = withServiceStore $ \st -> do
let o = order "alicebakery" 1
o' = o {ofCommitment = digestFixture 2, ofSealed = "new"}
placePaid st "r1" ownerA o (at 60) `shouldReturn` Right ()
placed <- withTransaction st $ \db -> do
[LiveOrder {loRegistration, loOverdue = True}] <- getLiveOrders db (ofCommitment o') ownerA (ofLabelHash o') (at 61)
void $ closeOverdue db loRegistration (at 61)
insertInvoiceRow db "inv-r2" (at 120) "open"
createPaidRegistration db (newReg "r2" ownerA o') (paidOrder "inv-r2") (at 61)
placed `shouldBe` Right ()
old <- reg st "r1"
(nrLive old, nrPhase old, nrVersion old) `shouldBe` (False, PUnpaid, 2)
invoiceStatus st "inv-r1" `shouldReturn` "expired"
invoiceStatus st "inv-r2" `shouldReturn` "open"
testCloseOverdueStale :: IO ()
testCloseOverdueStale = withServiceStore $ \st -> do
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
r <- reg st "r1"
write st r {nrPhase = PQueued} `shouldReturn` Written 2
withTransaction st (\db -> closeOverdue db r (at 61)) `shouldReturn` Nothing
invoiceStatus st "inv-r1" `shouldReturn` "open"
(nrLive &&& nrPhase) <$> reg st "r1" `shouldReturn` (True, PQueued)
invoiceStatus :: DBStore -> Text -> IO Text
invoiceStatus st invId = withTransaction st $ \db ->
DB.query db "SELECT status FROM sx_badge_service_invoices WHERE invoice_id = ?" (Only invId) >>= \case
[Only status] -> pure status
rows -> fail $ "invoice " <> show invId <> ": " <> show (length rows) <> " rows"
reveal :: NameReveal
reveal =
NameReveal
{ rvLabel = "alicebakery",
rvSecret = digestFixture 7,
rvContactLink = Just "https://smp8.simplex.im/a#abc",
rvChannelLink = Nothing,
rvNonce = 3,
rvDeadline = 1792915140,
rvSignature = signature
}
testVersionBumps :: IO ()
testVersionBumps = withServiceStore $ \st -> do
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
r1 <- reg st "r1"
write st r1 {nrPhase = PCommitting, nrCommitTx = Just (TxHash $ digestFixture 8)} `shouldReturn` Written 2
r2 <- reg st "r1"
write st r2 {nrPhase = PCommitted, nrRevealAfter = Just 1792828800, nrRevealBefore = Just 1792915140} `shouldReturn` Written 3
r3 <- reg st "r1"
write st r3 {nrReveal = Just reveal} `shouldReturn` Written 4
write st r3 {nrLinksRefusedAt = Just (at 5)} `shouldReturn` VersionChanged
write st r1 {nrPhase = PFailed} `shouldReturn` VersionChanged
r4 <- reg st "r1"
(nrVersion r4, nrPhase r4, nrReveal r4, nrLinksRefusedAt r4) `shouldBe` (4, PCommitted, Just reveal, Nothing)
testRoundTrip :: IO ()
testRoundTrip = withServiceStore $ \st -> do
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
r <- reg st "r1"
let changed =
r
{ nrPhase = PRegistered,
nrReveal = Just reveal {rvChannelLink = Just "simplex:/c#xyz"},
nrCommitTx = Just (TxHash $ digestFixture 8),
nrCommitBlock = Just 100,
nrRegisterTx = Just (TxHash $ digestFixture 9),
nrRegisterBlock = Just 120,
nrRevealAfter = Just 1792828800,
nrRevealBefore = Just 1792915140,
nrExpiresAt = Just 1861833600,
nrRegisteredAt = Just (at 3),
nrFailedAt = Just (at 2),
nrError = Just "The name was not signed in time",
nrLinksRefusedAt = Just (at 4),
nrMoves = 2
}
write st changed `shouldReturn` Written 2
reg st "r1" `shouldReturn` changed {nrVersion = 2, nrLive = False, nrUpdatedAt = at 1}
write st changed {nrVersion = 2, nrReveal = Nothing} `shouldReturn` Written 3
nrReveal <$> reg st "r1" `shouldReturn` Nothing
testLiveFollowsPhase :: IO ()
testLiveFollowsPhase = withServiceStore $ \st -> do
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
code <- issue st 1 usable
placeCode st "r2" ownerB (order "bobsbakery" 2) code `shouldReturn` Right ()
let step rid phase expected = do
r <- reg st rid
write st r {nrPhase = phase} `shouldReturn` Written (nrVersion r + 1)
(nrPhase &&& nrLive) <$> reg st rid `shouldReturn` (phase, expected)
step "r1" PQueued True
step "r1" PFailed True
step "r1" PTaken False
r1 <- reg st "r1"
write st r1 {nrPhase = PFailed} `shouldReturn` NotLive
step "r2" PRegistering True
step "r2" PTaken False
placePaid st "r3" ownerA (order "carolsbakery" 3) (at 60) `shouldReturn` Right ()
r3 <- reg st "r3"
write st r3 {nrLive = False} `shouldReturn` Written 2
nrLive <$> reg st "r3" `shouldReturn` False
testOrderLive :: IO ()
testOrderLive = withServiceStore $ \st -> do
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
paid <- reg st "r1"
let code = paid {nrPayment = RPCode 1}
liveIn r phase = (phase, orderLive r {nrPhase = phase})
map (liveIn paid) [minBound .. maxBound]
`shouldBe` [(PUnpaid, True), (PQueued, True), (PCommitting, True), (PCommitted, True), (PRegistering, True), (PRegistered, False), (PTaken, False), (PFailed, True)]
map (liveIn code) [PTaken, PFailed, PRegistered] `shouldBe` [(PTaken, False), (PFailed, True), (PRegistered, False)]
orderLive paid {nrLive = False} `shouldBe` False
orderLive paid {nrLive = False, nrPhase = PQueued} `shouldBe` True
testReorderAfterRegistered :: IO ()
testReorderAfterRegistered = withServiceStore $ \st -> do
let o = order "alicebakery" 1
code <- issue st 1 usable
placeCode st "r1" ownerA o code `shouldReturn` Right ()
placePaid st "r2" ownerA o {ofCommitment = digestFixture 2} (at 60) `shouldReturn` Left RRLiveOrder
r <- reg st "r1"
write st r {nrPhase = PRegistered, nrRegisteredAt = Just (at 1)} `shouldReturn` Written 2
nrLive <$> reg st "r1" `shouldReturn` False
placePaid st "r3" ownerA o {ofCommitment = digestFixture 2} (at 60) `shouldReturn` Right ()
testLatePayment :: IO ()
testLatePayment = withServiceStore $ \st -> do
let o = order "alicebakery" 1
o' = o {ofCommitment = digestFixture 2, ofSealed = "new"}
placePaid st "r1" ownerA o (at 60) `shouldReturn` Right ()
closed <- reg st "r1"
withTransaction st (\db -> closeOverdue db closed (at 61)) `shouldReturn` Just 2
r1 <- reg st "r1"
write st r1 {nrPhase = PQueued} `shouldReturn` NotLive
reg st "r1" `shouldReturn` r1
placePaid st "r2" ownerA o' (at 120) `shouldReturn` Right ()
write st r1 {nrPhase = PQueued} `shouldReturn` NotLive
reg st "r1" `shouldReturn` r1
(nrPhase &&& nrLive) <$> reg st "r2" `shouldReturn` (PUnpaid, True)
write st r1 {nrVersion = 1, nrPhase = PQueued} `shouldReturn` VersionChanged
testFind :: IO ()
testFind = withServiceStore $ \st -> do
forM_ [1 .. 52 :: Int] $ \i -> withTransaction st $ \db -> do
let rid = "r" <> T.pack (show i)
o = order ("alicebakery" <> T.pack (show i)) (fromIntegral i)
insertInvoiceRow db ("inv-" <> rid) (at 60) "open"
createPaidRegistration db (newReg rid ownerA o) (paidOrder $ "inv-" <> rid) (at i) `shouldReturn` Right ()
placePaid st "other" ownerB (order "bobsbakery" 99) (at 60) `shouldReturn` Right ()
found <- withTransaction st $ \db -> findRegistrations db ownerA
map nrId found `shouldBe` [RegistrationId $ "r" <> T.pack (show i) | i <- [52, 51 .. 3 :: Int]]
withTransaction st (\db -> findRegistrations db (address "0x0000000000000000000000000000000000000001")) `shouldReturn` []
testSameSecondOrder :: IO ()
testSameSecondOrder = withServiceStore $ \st -> do
let o = order "alicebakery" 1
ids = ["r2", "r3", "r1"]
forM_ (zip ids [10 ..]) $ \(rid, n) -> do
placePaid st rid ownerA (order ("alicebakery" <> rid) n) (at 60) `shouldReturn` Right ()
r <- reg st rid
write st r {nrPhase = PQueued} `shouldReturn` Written 2
map nrId <$> withTransaction st (`findRegistrations` ownerA) `shouldReturn` map RegistrationId ["r3", "r2", "r1"]
map nrId <$> withTransaction st activeRegistrations `shouldReturn` map RegistrationId ["r1", "r2", "r3"]
forM_ ["r5", "r4"] $ \rid -> do
placePaid st rid ownerB o (at 60) `shouldReturn` Right ()
r <- reg st rid
withTransaction st (\db -> closeOverdue db r (at 61)) `shouldReturn` Just 2
found <- withTransaction st $ \db -> getRegistrationByOrderHash db (orderHash ownerB o (OTInvoice btc price))
nrId <$> found `shouldBe` Just (RegistrationId "r5")
testLabelRegistering :: IO ()
testLabelRegistering = withServiceStore $ \st -> do
let o = order "alicebakery" 1
registering = withTransaction st $ \db -> isLabelRegistering db (ofLabelHash o)
code <- issue st 1 usable
placeCode st "r1" ownerA o code `shouldReturn` Right ()
registering `shouldReturn` False
r <- reg st "r1"
void $ write st r {nrPhase = PRegistering}
registering `shouldReturn` True
r' <- reg st "r1"
void $ write st r' {nrPhase = PRegistered}
registering `shouldReturn` False
testActive :: IO ()
testActive = withServiceStore $ \st -> do
let phases = [PUnpaid ..]
forM_ (zip [1 ..] phases) $ \(i, phase) -> do
let rid = "r" <> T.pack (show i)
placePaid st rid ownerA (order ("alicebakery" <> T.pack (show i)) i) (at 60) `shouldReturn` Right ()
r <- reg st rid
void $ write st r {nrPhase = phase}
active <- withTransaction st activeRegistrations
sort (map (fromEnum . nrPhase) active) `shouldBe` map fromEnum [PQueued, PCommitting, PCommitted, PRegistering]
testUnpaidCleanup :: IO ()
testUnpaidCleanup = withServiceStore $ \st -> do
placePaid st "old" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
placePaid st "funded" ownerA (order "bobsbakery" 2) (at 60) `shouldReturn` Right ()
placePaid st "queued" ownerA (order "carolsbakery" 3) (at 60) `shouldReturn` Right ()
placePaid st "open" ownerA (order "davesbakery" 4) (at 120) `shouldReturn` Right ()
withTransaction st $ \db -> insertPayment db "inv-funded"
r <- reg st "queued"
void $ write st r {nrPhase = PQueued}
candidates <- withTransaction st $ \db -> unpaidCleanupCandidates db (at 61)
map (\(RegistrationId rid, InvoiceId invId) -> (rid, invId)) candidates `shouldBe` [("old", "inv-old")]
withTransaction st (\db -> mapM (deleteUnpaidRegistration db . RegistrationId) ["old", "funded", "queued"]) `shouldReturn` [True, False, False]
withTransaction st (\db -> getRegistration db (RegistrationId "old")) `shouldReturn` Nothing
invoiceCount st "inv-old" `shouldReturn` 0
invoiceCount st "inv-funded" `shouldReturn` 1
nrPhase <$> reg st "funded" `shouldReturn` PUnpaid
insertPayment :: DB.Connection -> Text -> IO ()
insertPayment db invId =
DB.execute
db
"INSERT INTO sx_badge_service_payments (payment_id, invoice_id, provider, status, created_at, updated_at) VALUES (?,?,?,?,?,?)"
(invId, invId, "crypto" :: Text, "pending" :: Text, t0, t0)
foreignKeyViolation :: Selector DB.SQLError
#if defined(dbPostgres)
foreignKeyViolation e = case constraintViolation e of
Just ForeignKeyViolation {} -> True
_ -> False
#else
foreignKeyViolation e = sqlError e == ErrorConstraint && "FOREIGN KEY" `T.isInfixOf` sqlErrorDetails e
#endif
indexExists :: DBStore -> Text -> IO Bool
indexExists st index = withTransaction st $ \db -> do
rows <- DB.query db indexQuery (Only index)
pure $ not $ null (rows :: [Only Text])
where
#if defined(dbPostgres)
indexQuery = "SELECT indexname FROM pg_indexes WHERE schemaname = current_schema() AND indexname = ?"
#else
indexQuery = "SELECT name FROM sqlite_master WHERE type = 'index' AND name = ?"
#endif
invoiceCount :: DBStore -> Text -> IO Int
invoiceCount st invId = withTransaction st $ \db ->
DB.query db "SELECT COUNT(*) FROM sx_badge_service_invoices WHERE invoice_id = ?" (Only invId) >>= \case
[Only n] -> pure n
rows -> fail $ "count: " <> show (length rows) <> " rows"
testFailedCodeOrders :: IO ()
testFailedCodeOrders = withServiceStore $ \st -> do
codes@[oldCode, _, releasedCode, _] <- mapM (\n -> issue st n usable) [1, 2, 3, 4]
forM_ (zip3 ["old", "recent", "released", "queued"] [1 ..] codes) $ \(rid, n, code) ->
placeCode st rid ownerA (order ("alicebakery" <> rid) n) code `shouldReturn` Right ()
let failAt rid t = reg st rid >>= \r -> void (write st r {nrPhase = PFailed, nrFailedAt = Just t})
failAt "old" (at 1)
failAt "recent" (at 30)
failAt "released" (at 1)
withTransaction st (\db -> releasePrepaidCode db (pcId releasedCode) (RegistrationId "released")) `shouldReturn` True
withTransaction st (\db -> failedCodeOrdersBefore db (at 10)) `shouldReturn` [(RegistrationId "old", pcId oldCode)]
testIssueCode :: IO ()
testIssueCode = withServiceStore $ \st -> do
code <- issue st 1 usable {npcMinLength = 6, npcYears = 5, npcPaymentStatus = CPSFree, npcExpiresAt = Just (at 100)}
(pcMinLength code, pcYears code, pcPaymentStatus code, pcExpiresAt code, pcCreatedAt code) `shouldBe` (6, 5, CPSFree, Just (at 100), t0)
withTransaction st (\db -> insertPrepaidCode db usable {npcCodeHash = digestFixture 1} t0) `shouldReturn` Left CodeHashTaken
withTransaction st (\db -> getPrepaidCode db (digestFixture 1)) `shouldReturn` Just code
testReserveReleaseSpend :: IO ()
testReserveReleaseSpend = withServiceStore $ \st -> do
PrepaidCode {pcId} <- issue st 1 usable
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
placePaid st "r2" ownerB (order "bobsbakery" 2) (at 60) `shouldReturn` Right ()
let r1 = RegistrationId "r1"
r2 = RegistrationId "r2"
run :: (DB.Connection -> IO a) -> IO a
run = withTransaction st
run (\db -> releasePrepaidCode db pcId r1) `shouldReturn` False
run (\db -> spendPrepaidCode db pcId r1 t0) `shouldReturn` False
run (\db -> reservePrepaidCode db pcId r1 (at 1)) `shouldReturn` True
run (\db -> reservePrepaidCode db pcId r2 (at 1)) `shouldReturn` False
run (\db -> releasePrepaidCode db pcId r2) `shouldReturn` False
run (\db -> spendPrepaidCode db pcId r2 (at 2)) `shouldReturn` False
run (\db -> releasePrepaidCode db pcId r1) `shouldReturn` True
run (\db -> reservePrepaidCode db pcId r2 (at 2)) `shouldReturn` True
run (\db -> spendPrepaidCode db pcId r2 (at 3)) `shouldReturn` True
run (\db -> releasePrepaidCode db pcId r2) `shouldReturn` False
run (\db -> reservePrepaidCode db pcId r1 (at 4)) `shouldReturn` False
run (\db -> spendPrepaidCode db pcId r2 (at 4)) `shouldReturn` False
spent <- run $ \db -> getPrepaidCodeById db pcId
(pcReservedBy =<< spent, pcSpentAt =<< spent) `shouldBe` (Just r2, Just (at 3))
testReserveRefused :: IO ()
testReserveRefused = withServiceStore $ \st -> do
placePaid st "r1" ownerA (order "alicebakery" 1) (at 60) `shouldReturn` Right ()
unpaid <- issue st 1 usable {npcPaymentStatus = CPSUnpaid}
expired <- issue st 2 usable {npcExpiresAt = Just (at 10)}
revoked <- issue st 3 usable
free <- issue st 4 usable {npcPaymentStatus = CPSFree, npcExpiresAt = Just (at 30)}
withTransaction st (\db -> revokePrepaidCode db (pcCodeHash revoked) t0) `shouldReturn` Revoked (pcId revoked)
let reserve code = withTransaction st $ \db -> reservePrepaidCode db (pcId code) (RegistrationId "r1") (at 20)
mapM reserve [unpaid, expired, revoked] `shouldReturn` [False, False, False]
reserve free `shouldReturn` True
testOneCodePerRegistration :: IO ()
testOneCodePerRegistration = withServiceStore $ \st -> do
first <- issue st 1 usable
second <- issue st 2 usable
placeCode st "r1" ownerA (order "alicebakery" 1) first `shouldReturn` Right ()
withTransaction st (\db -> reservePrepaidCode db (pcId second) (RegistrationId "r1") t0) `shouldThrow` anyException
free <- withTransaction st $ \db -> getPrepaidCodeById db (pcId second)
(pcReservedBy =<< free) `shouldBe` Nothing
testRevoke :: IO ()
testRevoke = withServiceStore $ \st -> do
reserved <- issue st 1 usable
spent <- issue st 2 usable
unused <- issue st 3 usable
placeCode st "r1" ownerA (order "alicebakery" 1) reserved `shouldReturn` Right ()
placeCode st "r2" ownerA (order "bobsbakery" 2) spent `shouldReturn` Right ()
withTransaction st (\db -> spendPrepaidCode db (pcId spent) (RegistrationId "r2") t0) `shouldReturn` True
let revoke code = withTransaction st $ \db -> revokePrepaidCode db (pcCodeHash code) (at 1)
revoke reserved `shouldReturn` Revoked (pcId reserved)
revoke unused `shouldReturn` Revoked (pcId unused)
revoke unused `shouldReturn` AlreadyRevoked (pcId unused)
revoke spent `shouldReturn` AlreadyRedeemed
withTransaction st (\db -> revokePrepaidCode db (digestFixture 9) t0) `shouldReturn` NoSuchCode
held <- withTransaction st $ \db -> getPrepaidCodeById db (pcId reserved)
(pcReservedBy =<< held, pcRevokedAt =<< held) `shouldBe` (Just (RegistrationId "r1"), Just (at 1))
testTransactions :: IO ()
testTransactions = withServiceStore $ \st -> do
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
let r1 = RegistrationId "r1"
tx :: Word8 -> NewTransaction
tx n = NewTransaction {ntxRaw = digestFixture (n + 100), ntxHash = TxHash $ digestFixture n, ntxNonce = fromIntegral n}
[commitId, registerId] <- withTransaction st $ \db ->
sequence [insertTransaction db (TxCommit r1) (tx 2) (at 1), insertTransaction db (TxRegister r1) (tx 3) (at 3)]
unsettled <- withTransaction st pendingTransactions
map (\NameTransaction {ntFor, ntNonce, ntStatus} -> (ntFor, ntNonce, ntStatus)) unsettled
`shouldBe` [(TxCommit r1, 2, TSPending), (TxRegister r1, 3, TSPending)]
map ntRaw unsettled `shouldBe` map (\n -> digestFixture (n + 100)) [2, 3]
let outcome n from status block = withTransaction st $ \db -> recordTransactionOutcome db (TxHash $ digestFixture n) from status block
outcome 2 TSPending TSMined (Just 77) `shouldReturn` True
outcome 50 TSPending TSMined (Just 79) `shouldReturn` False
outcome 3 TSMined TSPending Nothing `shouldReturn` False
map ntFor <$> withTransaction st pendingTransactions `shouldReturn` [TxRegister r1]
ofRegistration <- withTransaction st $ \db -> registrationTransactions db r1
map (\NameTransaction {ntId, ntFor, ntMinedBlock, ntStatus, ntSentAt} -> (ntId, ntFor, ntMinedBlock, ntStatus, ntSentAt)) ofRegistration
`shouldBe` [(commitId, TxCommit r1, Just 77, TSMined, at 1), (registerId, TxRegister r1, Nothing, TSPending, at 3)]
testTransactionFromStatus :: IO ()
testTransactionFromStatus = withServiceStore $ \st -> do
code <- issue st 1 usable
placeCode st "r1" ownerA (order "alicebakery" 1) code `shouldReturn` Right ()
let outcome from status block = withTransaction st $ \db -> recordTransactionOutcome db (TxHash $ digestFixture 2) from status block
current = withTransaction st $ \db -> map (\NameTransaction {ntStatus, ntMinedBlock} -> (ntStatus, ntMinedBlock)) <$> registrationTransactions db (RegistrationId "r1")
void $ withTransaction st $ \db -> insertTransaction db (TxCommit $ RegistrationId "r1") NewTransaction {ntxRaw = "raw", ntxHash = TxHash $ digestFixture 2, ntxNonce = 0} t0
outcome TSPending TSMined (Just 77) `shouldReturn` True
outcome TSPending TSDropped Nothing `shouldReturn` False
current `shouldReturn` [(TSMined, Just 77)]
outcome TSMined TSPending Nothing `shouldReturn` True
current `shouldReturn` [(TSPending, Nothing)]