From e82eb07076a0f0101308c3f9e5556d00e0a2e250 Mon Sep 17 00:00:00 2001 From: sh-agents <350651734+sh-agents@users.noreply.github.com> Date: Sun, 1 Nov 2026 15:27:04 +0000 Subject: [PATCH] store: commit and register queued orders --- .../src/StoreService/Names/Codes.hs | 8 +- .../src/StoreService/Names/Contracts.hs | 7 +- .../src/StoreService/Names/Env.hs | 6 +- .../src/StoreService/Names/Store.hs | 16 + .../src/StoreService/Names/Turns.hs | 6 +- .../src/StoreService/Names/Worker.hs | 460 ++++++++ .../src/StoreService/Service.hs | 12 +- .../StoreService/GroupIntegrationTests.hs | 41 +- tests/Bots/StoreService/NamesOrdersTests.hs | 1 + tests/Bots/StoreService/NamesOwnerTests.hs | 132 +++ tests/Bots/StoreService/NamesWorkerTests.hs | 1043 +++++++++++++++++ 11 files changed, 1724 insertions(+), 8 deletions(-) create mode 100644 apps/simplex-store-service/src/StoreService/Names/Worker.hs create mode 100644 tests/Bots/StoreService/NamesOwnerTests.hs create mode 100644 tests/Bots/StoreService/NamesWorkerTests.hs diff --git a/apps/simplex-store-service/src/StoreService/Names/Codes.hs b/apps/simplex-store-service/src/StoreService/Names/Codes.hs index 5b0d44c03d..deca04c756 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Codes.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Codes.hs @@ -15,6 +15,7 @@ module StoreService.Names.Codes reserveCode, releaseCode, spendCode, + spendLandedCode, issueNameCode, revokeNameCode, ) @@ -37,7 +38,7 @@ import qualified Simplex.Messaging.Agent.Store.DB as DB import StoreService.Config (minNameYears) import StoreService.Group.Command (maxNameYears) import StoreService.Names.Phases (RegistrationId) -import StoreService.Names.Store (CodeHashTaken (..), NewPrepaidCode (..), PrepaidCode (..), getPrepaidCode, getPrepaidCodeById, insertPrepaidCode, releasePrepaidCode, reservePrepaidCode, revokePrepaidCode, spendPrepaidCode) +import StoreService.Names.Store (CodeHashTaken (..), NewPrepaidCode (..), PrepaidCode (..), getPrepaidCode, getPrepaidCodeById, insertPrepaidCode, releasePrepaidCode, reservePrepaidCode, revokePrepaidCode, spendLandedPrepaidCode, spendPrepaidCode) import StoreService.Names.Turns (Turns, withCodeTurn) import StoreService.Store (RevokeResult (..)) @@ -137,6 +138,11 @@ releaseCode turns st codeId rid = afterWrite turns st codeId (\db -> releasePrep 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) +-- | As spendCode, for a registration whose register went through: a code it no longer holds is spent too while still usable. +-- False when the code was released and then spent, revoked or expired meanwhile. +spendLandedCode :: Turns -> DBStore -> UTCTime -> Int64 -> RegistrationId -> (DB.Connection -> IO (Either e a)) -> IO (Either e (a, Bool)) +spendLandedCode turns st now codeId rid = afterWrite turns st codeId (\db -> spendLandedPrepaidCode 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 diff --git a/apps/simplex-store-service/src/StoreService/Names/Contracts.hs b/apps/simplex-store-service/src/StoreService/Names/Contracts.hs index 712e2e963c..76a7971240 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Contracts.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Contracts.hs @@ -16,6 +16,7 @@ module StoreService.Names.Contracts chainPriceCents, sponsorNonce, resolverNonce, + confirmedTag, ownerOfToken, nameExpires, commitmentTime, @@ -40,7 +41,7 @@ import Simplex.Messaging.SimplexName (LabelHash (..), SimplexTLD) import Simplex.Messaging.Util (tshow) import StoreService.Config (ChainConfig (..)) import StoreService.Names.Abi -import StoreService.Names.Chain (Block (..), BlockTag (..), ChainClient (..), ChainError (..), ethCallAt, latestBlock) +import StoreService.Names.Chain (Block (..), BlockTag (..), ChainClient (..), ChainError (..), confirmedNumber, ethCallAt, latestBlock) import StoreService.Names.Registration (channelRecordKey, contactRecordKey, labelNode, nodeBytes) import StoreService.Names.Revert (RevertName (..)) import System.Timeout (timeout) @@ -137,6 +138,10 @@ sponsorNonce ct owner = call ct (cSponsor $ chainConfig ct) ("nonces(address)", resolverNonce :: Contracts -> Address -> IO (Either ChainError Word64) resolverNonce ct owner = call ct (resolver ct) ("nonces(address)", addressWord owner) decodeWord64 +-- | The newest block at the configured confirmation depth, so a read there sees only what a reorg cannot undo. +confirmedTag :: Contracts -> IO (Either ChainError BlockTag) +confirmedTag Contracts {ctChain} = fmap (AtBlock . confirmedNumber ctChain . blockNumber) <$> latestBlock ctChain + -- | Nothing when nobody holds the name: @ownerOf@ then fails the registrar's bare @require@ on the expiry, -- a revert without data. Any other revert is a failed read. ownerOfToken :: Contracts -> BlockTag -> LabelHash -> IO (Either ChainError (Maybe Address)) diff --git a/apps/simplex-store-service/src/StoreService/Names/Env.hs b/apps/simplex-store-service/src/StoreService/Names/Env.hs index 759563c223..b9c7d07dfd 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Env.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Env.hs @@ -2,6 +2,7 @@ module StoreService.Names.Env (NamesEnv (..), newNamesEnv) where +import Data.Time.Clock (getCurrentTime) import Simplex.Chat.Controller (ChatController (..)) import Simplex.Messaging.Agent.Protocol (UserId) import Simplex.Messaging.Agent.Store.Common (DBStore) @@ -10,6 +11,7 @@ import StoreService.Names.Chain (ChainClient, newChainClient) import StoreService.Names.Contracts (Contracts, newContracts) import StoreService.Names.Phases (Phases, newPhases) import StoreService.Names.Profiles (Profiles, chatProfile, defaultProfileLimits, monotonicSeconds, newProfiles, systemResolver) +import StoreService.Names.Sender (Sender, newSender) import StoreService.Names.Turns (Turns) import StoreService.Providers (Provider) import StoreService.Waiters (Waiters) @@ -24,6 +26,7 @@ data NamesEnv = NamesEnv neChain :: ChainClient, neContracts :: Contracts, neProfiles :: Profiles, + neSender :: Sender, neWaiters :: Waiters, neProviders :: [Provider] } @@ -34,4 +37,5 @@ newNamesEnv neChat@ChatController {random} neUserId neConfig@NamesConfig {nTLD, neChain <- newChainClient random nChain neContracts <- newContracts nTLD neChain neProfiles <- newProfiles defaultProfileLimits monotonicSeconds (chatProfile neChat neUserId) systemResolver - pure NamesEnv {neChat, neUserId, neConfig, neStore, nePhases, neTurns, neChain, neContracts, neProfiles, neWaiters, neProviders} + neSender <- newSender random neChain neStore getCurrentTime + pure NamesEnv {neChat, neUserId, neConfig, neStore, nePhases, neTurns, neChain, neContracts, neProfiles, neSender, neWaiters, neProviders} diff --git a/apps/simplex-store-service/src/StoreService/Names/Store.hs b/apps/simplex-store-service/src/StoreService/Names/Store.hs index 9d66e0f8b4..c29f672d38 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Store.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Store.hs @@ -48,6 +48,7 @@ module StoreService.Names.Store reservePrepaidCode, releasePrepaidCode, spendPrepaidCode, + spendLandedPrepaidCode, revokePrepaidCode, insertTransaction, recordTransactionOutcome, @@ -677,6 +678,21 @@ spendPrepaidCode db codeId (RegistrationId rid) now = "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) +-- | For a registration whose register went through: spends the code it holds, or one released and still usable; False otherwise. +spendLandedPrepaidCode :: DB.Connection -> Int64 -> RegistrationId -> UTCTime -> IO Bool +spendLandedPrepaidCode db codeId (RegistrationId rid) now' = + (> 0) + <$> executeChanging + db + [sql| + UPDATE sx_badge_service_name_prepaid_codes SET reserved_by = ?, reserved_at = COALESCE(reserved_at, ?), spent_at = ? + WHERE name_prepaid_code_id = ? AND spent_at IS NULL + AND (reserved_by = ? OR (reserved_by IS NULL AND revoked_at IS NULL AND code_payment_status <> ? AND (expires_at IS NULL OR expires_at > ?))) + |] + (rid, now, now, codeId, rid, CPSUnpaid, now) + where + now = truncateToSecond now' + -- | 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 diff --git a/apps/simplex-store-service/src/StoreService/Names/Turns.hs b/apps/simplex-store-service/src/StoreService/Names/Turns.hs index ee0e4d57bc..3a20633f9a 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Turns.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Turns.hs @@ -1,7 +1,7 @@ {-# LANGUAGE NamedFieldPuns #-} -- | 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 +module StoreService.Names.Turns (Turns, newTurns, withLabelTurn, withCodeTurn, turnsCount, labelTurnCount) where import Control.Concurrent.STM import Control.Exception (bracket, bracket_) @@ -25,6 +25,10 @@ withLabelTurn Turns {labelTurns} (LabelHash h) = withTurn labelTurns h turnsCount :: Turns -> IO Int turnsCount Turns {labelTurns, codeTurns} = atomically $ (+) <$> (Map.size <$> readTVar labelTurns) <*> (Map.size <$> readTVar codeTurns) +-- | The requests holding or waiting for the label hash's turn. +labelTurnCount :: Turns -> LabelHash -> STM Int +labelTurnCount Turns {labelTurns} (LabelHash h) = maybe 0 snd . Map.lookup h <$> readTVar labelTurns + -- | Keyed by the code's SHA-256 hash. withCodeTurn :: Turns -> ByteString -> IO a -> IO a withCodeTurn Turns {codeTurns} = withTurn codeTurns diff --git a/apps/simplex-store-service/src/StoreService/Names/Worker.hs b/apps/simplex-store-service/src/StoreService/Names/Worker.hs new file mode 100644 index 0000000000..59b33dc345 --- /dev/null +++ b/apps/simplex-store-service/src/StoreService/Names/Worker.hs @@ -0,0 +1,460 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} + +-- | Each registration from queued to registered, taken or failed: its commit, the wait for the page's reveal, and its register; +-- and Try again, which queues a failed one again. A step starts from the stored registration, the sender's transactions in flight +-- and the chain, so a restart resumes any phase. +module StoreService.Names.Worker + ( Worker, + Next (..), + newWorker, + stepRegistration, + runWorkers, + sweepFailedCodes, + runCodeSweep, + maxUnexpiredWaits, + Retried (..), + RetryRefusal (..), + retryRegistration, + ) +where + +import Control.Concurrent (threadDelay) +import Control.Concurrent.Async (Async, asyncWithUnmask, cancel, poll) +import Control.Concurrent.STM +import Control.Exception (finally, mask_) +import Control.Monad (forM, forM_, forever, void, when) +import Control.Monad.Except (ExceptT (..), runExceptT) +import Data.Functor ((<&>)) +import Data.Int (Int64) +import Data.Map.Strict (Map) +import qualified Data.Map.Strict as M +import Data.Text (Text) +import qualified Data.Text as T +import Data.Time.Clock (NominalDiffTime, UTCTime, addUTCTime, diffUTCTime) +import Data.Time.Clock.POSIX (posixSecondsToUTCTime, utcTimeToPOSIXSeconds) +import Data.Word (Word64) +import Simplex.Messaging.Agent.Store.Common (withTransaction) +import Simplex.Messaging.Util (tshow) +import StoreService.Config (ChainConfig (..), NamesConfig (..)) +import StoreService.Log (logError, logInfo, logWarn, safely, safelyWith) +import StoreService.Names.Chain (Block (..), ChainClient, ChainError (..), TxHash, blockAt) +import StoreService.Names.Codes (CodeRefusal (..), codeRefusal, releaseCode, reserveCode) +import StoreService.Names.Contracts (CommitmentAges (..), commitmentAges, commitmentTime, controllerAvailable, sponsorNonce) +import StoreService.Names.Orders (Landing (..), OrdersEnv (..), WriteRefusal (..), confirmLanded, versionWritten) +import StoreService.Names.Phases (RegistrationId (..), awaitChange, publish) +import StoreService.Names.Registration (commitCalldata, registerWithCreditCalldata, sponsorDomain, verifyRegisterIntent) +import StoreService.Names.Reveal (intentOf) +import StoreService.Names.Revert (RevertName (..)) +import StoreService.Names.Sender (PendingTx, SendError (..), Sender, awaitOutcome, inFlightTransaction, ptHash, submitTransaction) +import StoreService.Names.Store +import StoreService.Names.Turns (withLabelTurn) +import StoreService.Names.View (lapseMoment, notSignedInTime, registrationAt, registrationVersion) + +data Worker = Worker + { wkOrders :: OrdersEnv, + wkChain :: ChainClient, + wkSender :: Sender, + -- | the thread following each registration, kept by the scan + wkThreads :: TVar (Map RegistrationId (Async ())), + -- | the one-second waits in a row after a commit's dry run reverted UnexpiredCommitmentExists + wkUnexpiredWaits :: TVar (Map RegistrationId Int) + } + +-- | What a step leaves to the next one. +data Next + = -- | the registration is in none of the worker's phases + Done + | -- | the step wrote, or the registration changed since it was read + Again + | -- | nothing to do before this time, unless the registration moves on from this version + WaitUntil Int64 UTCTime + | -- | a chain read or a send failed, and the phase is kept + Retry Int64 Text + | -- | a transaction of the registration is in flight + Await PendingTx + +-- | How often the stored registrations are scanned for one without a thread, such as an order just paid or requeued. +scanInterval :: Int +scanInterval = 5000000 + +retryInterval :: NominalDiffTime +retryInterval = 15 + +-- | The registration is read again after this wait for its transaction's outcome. +outcomeWait :: Int +outcomeWait = 60000000 + +-- | A long wait is cut into waits of at most this, so a clock adjustment delays a moment by no more. +maxWait :: NominalDiffTime +maxWait = 60 + +-- | One-second waits in a row after a commit's dry run reverts UnexpiredCommitmentExists, before the usual retry interval: +-- enough for the node's block to pass the lapse second, not to spin on a node that keeps disagreeing with its own read. +maxUnexpiredWaits :: Int +maxUnexpiredWaits = 3 + +-- | Block times are whole seconds. +chainSecond :: NominalDiffTime +chainSecond = 1 + +-- | A failed code order keeps its code this long for Try again. +failedCodeHold :: NominalDiffTime +failedCodeHold = 30 * 86400 + +sweepInterval :: Int +sweepInterval = 86400 * 1000000 + +notRegistered :: Text +notRegistered = "The name could not be registered" + +newWorker :: OrdersEnv -> ChainClient -> Sender -> IO Worker +newWorker wkOrders wkChain wkSender = Worker wkOrders wkChain wkSender <$> newTVarIO M.empty <*> newTVarIO M.empty + +-- | A thread for each registration in the worker's phases, started by a scan every scanInterval; they stop with it. +runWorkers :: Worker -> IO () +runWorkers w@Worker {wkThreads} = + forever (safely "names worker: the scan" (startWorkers w) >> threadDelay scanInterval) + `finally` (readTVarIO wkThreads >>= mapM_ cancel) + +startWorkers :: Worker -> IO () +startWorkers w@Worker {wkOrders = OrdersEnv {oeStore}, wkThreads} = do + running <- readTVarIO wkThreads >>= M.traverseMaybeWithKey (\_ a -> maybe (Just a) (const Nothing) <$> poll a) + atomically $ writeTVar wkThreads running + active <- withTransaction oeStore activeRegistrations + forM_ [nrId | NameRegistration {nrId} <- active, M.notMember nrId running] $ \rid -> + mask_ $ asyncWithUnmask (\unmask -> unmask $ work w rid) >>= atomically . modifyTVar' wkThreads . M.insert rid + +work :: Worker -> RegistrationId -> IO () +work w rid@(RegistrationId ridText) = void $ safely ("names worker: registration " <> ridText) $ follow w rid Nothing + +-- | Steps until the registration leaves the worker's phases, logging a lasting failure once. +follow :: Worker -> RegistrationId -> Maybe Text -> IO () +follow w@Worker {wkOrders = OrdersEnv {oeStore, oePhases, oeNow}} rid@(RegistrationId ridText) lastFailure = + stepRegistration w rid >>= \case + Done -> pure () + Again -> follow w rid Nothing + WaitUntil v t -> waitFor v t >> follow w rid Nothing + Retry v reason -> do + when (Just reason /= lastFailure) $ logWarn $ "names worker: registration " <> ridText <> " waits: " <> reason + now <- oeNow + waitFor v $ addUTCTime retryInterval now + follow w rid $ Just reason + Await p -> awaitOutcome outcomeWait p >> follow w rid Nothing + where + waitFor v t = do + now <- oeNow + let micros = max 0 $ ceiling $ min maxWait (diffUTCTime t now) * 1000000 + void $ awaitChange oePhases rid (registrationVersion oeStore rid) v micros + +stepRegistration :: Worker -> RegistrationId -> IO Next +stepRegistration w@Worker {wkOrders = OrdersEnv {oeStore, oeNow}} rid = do + now <- oeNow + withTransaction oeStore (`getRegistration` rid) >>= \case + Nothing -> pure Done + Just r -> case nrPhase r of + PQueued -> commit w now r + PCommitting -> commit w now r + PCommitted -> committed w now r + PRegistering -> registering w now r + _ -> pure Done + +-- | A commit of the registration in flight is waited for; otherwise commitments(commitment) decides. +commit :: Worker -> UTCTime -> NameRegistration -> IO Next +commit w@Worker {wkOrders = OrdersEnv {oeContracts}, wkSender} now r@NameRegistration {nrId, nrCommitment} = + inFlightTransaction wkSender (TxCommit nrId) >>= \case + Just p -> commitSent w now r p + Nothing -> + runExceptT ((,) <$> ExceptT (commitmentAges oeContracts) <*> ExceptT (commitmentTime oeContracts nrCommitment)) >>= \case + Left e -> pure $ failure r e + Right (_, Nothing) -> sendCommit w now r + Right (ages, Just t) -> fromCommitment w now r ages t + +-- | At the lapse second a commitment can neither register nor be committed again, so the worker waits a second past it, +-- then commits again with the stale fields cleared. +fromCommitment :: Worker -> UTCTime -> NameRegistration -> CommitmentAges -> Word64 -> IO Next +fromCommitment w@Worker {wkOrders = OrdersEnv {oeConfig}} now r ages t + | reusable oeConfig now lapse = toCommitted w now r ages t + | lapse >= unixSeconds now = pure $ waitUntil r $ addUTCTime chainSecond $ secondsTime lapse + | lapsedFields r /= r = save w now $ lapsedFields r + | otherwise = sendCommit w now r + where + lapse = commitmentLapse ages t + +-- | The revealBefore of a commitment committed at this time. +commitmentLapse :: CommitmentAges -> Word64 -> Integer +commitmentLapse CommitmentAges {caMax} t = toInteger t + caMax + +-- | A live commitment is reused while revealMargin is left before its lapse, time for the page's reveal and the register to mine. +reusable :: NamesConfig -> UTCTime -> Integer -> Bool +reusable NamesConfig {nRevealMarginSeconds} now lapse = lapse - unixSeconds now >= toInteger nRevealMarginSeconds + +-- | The intent's deadline is the lapsed revealBefore, so it goes with the old transactions and reveal times; the page signs again. +lapsedFields :: NameRegistration -> NameRegistration +lapsedFields r = + r + { nrReveal = Nothing, + nrError = Nothing, + nrCommitTx = Nothing, + nrCommitBlock = Nothing, + nrRegisterTx = Nothing, + nrRegisterBlock = Nothing, + nrRevealAfter = Nothing, + nrRevealBefore = Nothing + } + +-- | The reveal times come from the commitment's time. When that is not the block of our commit mined with status 1, +-- someone committed it again after a lapse, so our commit and the reveal signed for its window are cleared. +toCommitted :: Worker -> UTCTime -> NameRegistration -> CommitmentAges -> Word64 -> IO Next +toCommitted w now r@NameRegistration {nrId} CommitmentAges {caMin, caMax} t = + unexpiredDone w nrId >> ourCommit w r t >>= \case + Left e -> pure $ failure r e + Right ours -> save w now (minedBy ours) {nrPhase = PCommitted, nrRevealAfter = Just $ after caMin, nrRevealBefore = Just $ after caMax} + where + after age = fromInteger $ toInteger t + age + minedBy = \case + Just (h, block) -> r {nrCommitTx = Just h, nrCommitBlock = Just block} + Nothing -> r {nrReveal = Nothing, nrCommitTx = Nothing, nrCommitBlock = Nothing} + +-- | Among the signatures of the commit last sent, the one mined with status 1 at the commitment's time. +ourCommit :: Worker -> NameRegistration -> Word64 -> IO (Either ChainError (Maybe (TxHash, Word64))) +ourCommit Worker {wkOrders = OrdersEnv {oeStore}, wkChain} NameRegistration {nrId, nrCommitTx} t = do + txs <- withTransaction oeStore (`registrationTransactions` nrId) + let commits = [tx | tx@NameTransaction {ntFor = TxCommit _} <- txs] + lastSent = [ntNonce | NameTransaction {ntHash, ntNonce} <- commits, Just ntHash == nrCommitTx] + case [(ntHash, block) | NameTransaction {ntHash, ntNonce, ntStatus = TSMined, ntMinedBlock = Just block} <- commits, ntNonce `elem` lastSent] of + (h, block) : _ -> fmap (\Block {blockTimestamp} -> if blockTimestamp == t then Just (h, block) else Nothing) <$> blockAt wkChain block + [] -> pure $ Right Nothing + +sendCommit :: Worker -> UTCTime -> NameRegistration -> IO Next +sendCommit w@Worker {wkOrders = OrdersEnv {oeConfig}, wkSender} now r@NameRegistration {nrId, nrCommitment} = + submitTransaction wkSender (TxCommit nrId) (cController $ nChain oeConfig) (commitCalldata nrCommitment) >>= \case + -- a commit mined since the read, or a latest block still at the lapse second + Left (SEChain (ChainReverted (Just RNUnexpiredCommitmentExists))) -> unexpired w now r + sendResult -> do + unexpiredDone w nrId + case sendResult of + Right p -> commitSent w now r p + Left SEInFlight -> pure Again + Left e -> pure $ failure r e + +unexpired :: Worker -> UTCTime -> NameRegistration -> IO Next +unexpired Worker {wkUnexpiredWaits} now r@NameRegistration {nrId = rid@(RegistrationId ridText)} = do + waits <- atomically $ stateTVar wkUnexpiredWaits $ \m -> let n = M.findWithDefault 0 rid m + 1 in (n, M.insert rid n m) + if waits <= maxUnexpiredWaits + then do + logWarn $ "names worker: registration " <> ridText <> ": the commit's dry run reverted UnexpiredCommitmentExists, wait " <> tshow waits <> " of a second" + pure $ waitUntil r $ addUTCTime chainSecond now + else pure $ Retry (nrVersion r) "the commit's dry run keeps reverting UnexpiredCommitmentExists" + +unexpiredDone :: Worker -> RegistrationId -> IO () +unexpiredDone Worker {wkUnexpiredWaits} = atomically . modifyTVar' wkUnexpiredWaits . M.delete + +-- | Recorded with the newest signature's hash, so a fee-bumped replacement is the one the view shows. +commitSent :: Worker -> UTCTime -> NameRegistration -> PendingTx -> IO Next +commitSent w now r@NameRegistration {nrPhase, nrCommitTx} p + | nrPhase == PCommitting && nrCommitTx == Just (ptHash p) = pure $ Await p + | otherwise = save w now r {nrPhase = PCommitting, nrCommitTx = Just $ ptHash p, nrCommitBlock = Nothing} + +-- | Waits for the page's reveal until the lapse, and for revealAfter, then registers. +committed :: Worker -> UTCTime -> NameRegistration -> IO Next +committed w@Worker {wkSender} now r@NameRegistration {nrId, nrReveal, nrRevealAfter} = + inFlightTransaction wkSender (TxRegister nrId) >>= \case + Just p -> registerSent w now r p + Nothing -> case nrReveal of + Nothing -> case lapseMoment r of + Just lapse | now <= lapse -> pure $ waitUntil r $ addUTCTime chainSecond lapse + _ -> save w now r {nrPhase = PFailed, nrFailedAt = Just now, nrError = Just notSignedInTime} + Just rv -> case secondsTime . toInteger <$> nrRevealAfter of + Just revealAfter | now < revealAfter -> pure $ waitUntil r revealAfter + _ -> sendRegister w now r rv + +-- | The stored intent is checked before its dry run, whose revert decides at once; no label turn is held across the send. +sendRegister :: Worker -> UTCTime -> NameRegistration -> NameReveal -> IO Next +sendRegister w@Worker {wkOrders = OrdersEnv {oeConfig = cfg@NamesConfig {nChain = ChainConfig {cChainId, cSponsor}}}, wkSender} now r@NameRegistration {nrId = regId@(RegistrationId rid)} rv = + verifyRegisterIntent (sponsorDomain cChainId cSponsor) (fromInteger $ unixSeconds now) intent >>= \case + -- past its deadline the commitment has lapsed too; a wrong signer follows a change of the chain settings since the reveal + Left refusal -> do + logWarn $ "names worker: registration " <> rid <> ": its stored intent is refused, " <> T.pack refusal + judge w now r Nothing + Right () -> + submitTransaction wkSender (TxRegister regId) cSponsor (registerWithCreditCalldata intent) >>= \case + Right p -> registerSent w now r p + Left SEInFlight -> pure Again + Left (SEChain (ChainReverted reason)) -> judge w now r reason + Left e -> pure $ failure r e + where + intent = intentOf cfg r rv + +registerSent :: Worker -> UTCTime -> NameRegistration -> PendingTx -> IO Next +registerSent w now r@NameRegistration {nrPhase, nrRegisterTx} p + | nrPhase == PRegistering && nrRegisterTx == Just (ptHash p) = pure $ Await p + | otherwise = save w now r {nrPhase = PRegistering, nrRegisterTx = Just $ ptHash p, nrRegisterBlock = Nothing} + +-- | With none of its register transactions in flight, none can be mined any more: each mined, or its nonce taken. +registering :: Worker -> UTCTime -> NameRegistration -> IO Next +registering w@Worker {wkSender} now r@NameRegistration {nrId} = + inFlightTransaction wkSender (TxRegister nrId) >>= \case + Just p -> registerSent w now r p + Nothing -> judge w now r Nothing + +-- | A register that did not go through, by its dry run's revert or once every transaction settled: registered when one mined +-- with status 1 or the owner holds the name; committed again on InvalidNonce, for the page to sign again; taken on any revert +-- while the name is not available at the latest block; failed otherwise, unless the dry run named the name as gone. +judge :: Worker -> UTCTime -> NameRegistration -> Maybe RevertName -> IO Next +judge w@Worker {wkOrders = oe@OrdersEnv {oeContracts}} now r@NameRegistration {nrReveal} reason = + inTurn w r $ + confirmLanded oe r >>= \case + LRegistered v -> pure (Just v, Again) + LChanged -> pure (Nothing, Again) + LUnread -> pure (Nothing, Retry (nrVersion r) "the register check's chain read failed") + LNotLanded -> case reason of + Just RNInvalidNonce -> store w now r {nrReveal = Nothing} + Just RNCommitmentTooNew -> pure (Nothing, waitUntil r $ addUTCTime chainSecond now) + _ -> case nrReveal of + Just NameReveal {rvLabel} -> + controllerAvailable oeContracts rvLabel >>= \case + Left e -> pure (Nothing, failure r e) + Right False -> taken w now r + -- the dry run runs on the pending block, where a competitor's register that may never mine can hold the name + Right True + | reason `elem` map Just [RNNameNotAvailable, RNNameReserved] -> pure (Nothing, Retry (nrVersion r) "the dry run reverted the name as gone, but it reads available") + | otherwise -> failed w now r reason + Nothing -> failed w now r reason + +-- | The payment is kept, and a code order's code released. +taken :: Worker -> UTCTime -> NameRegistration -> IO (Maybe Int64, Next) +taken Worker {wkOrders = OrdersEnv {oeStore, oeTurns}} now r@NameRegistration {nrId, nrPayment} = case nrPayment of + RPInvoice {} -> written r <$> withTransaction oeStore write + RPCode codeId -> written r . fmap fst <$> releaseCode oeTurns oeStore codeId nrId write + where + write db = versionWritten <$> updateRegistration db r {nrPhase = PTaken, nrError = Nothing} now + +-- | A code order keeps its code for Try again. +failed :: Worker -> UTCTime -> NameRegistration -> Maybe RevertName -> IO (Maybe Int64, Next) +failed w now r@NameRegistration {nrId = RegistrationId rid} reason = do + when (reason == Just RNInsufficientAllowance) $ + logError $ "names worker: registration " <> rid <> " failed: the registrar's allowance on the sponsor is used up; the guardian raises it with setRegistrarAllowance" + store w now r {nrPhase = PFailed, nrFailedAt = Just now, nrError = Just notRegistered} + +-- | A compare-and-set on the version read, in the caller's turn of the name. +store :: Worker -> UTCTime -> NameRegistration -> IO (Maybe Int64, Next) +store Worker {wkOrders = OrdersEnv {oeStore}} now r = written r <$> withTransaction oeStore (\db -> versionWritten <$> updateRegistration db r now) + +save :: Worker -> UTCTime -> NameRegistration -> IO Next +save w now r = inTurn w r $ store w now r + +-- | In the name's turn, as the requests that change an order; the version written is published after the turn. +inTurn :: Worker -> NameRegistration -> IO (Maybe Int64, Next) -> IO Next +inTurn Worker {wkOrders = OrdersEnv {oeTurns, oePhases}} NameRegistration {nrId, nrLabelHash} action = do + (v, next) <- withLabelTurn oeTurns nrLabelHash action + mapM_ (atomically . publish oePhases nrId) v + pure next + +written :: NameRegistration -> Either WriteRefusal Int64 -> (Maybe Int64, Next) +written r = \case + Right v -> (Just v, Again) + Left WRChanged -> (Nothing, Again) + Left (WRRefused refusal) -> (Nothing, Retry (nrVersion r) $ "its write was refused: " <> tshow refusal) + +failure :: Show e => NameRegistration -> e -> Next +failure r e = Retry (nrVersion r) $ tshow e + +waitUntil :: NameRegistration -> UTCTime -> Next +waitUntil r = WaitUntil (nrVersion r) + +unixSeconds :: UTCTime -> Integer +unixSeconds = floor . utcTimeToPOSIXSeconds + +secondsTime :: Integer -> UTCTime +secondsTime = posixSecondsToUTCTime . fromInteger + +-- | What Try again did: the version it wrote, the order changed since it was read, or a refusal. +data Retried = RTWritten Int64 | RTChanged | RTRefused RetryRefusal + +data RetryRefusal = RFNotFailed | RFLinksRefused | RFCode CodeRefusal | RFUnread + deriving (Eq, Show) + +-- | Try again, in the caller's turn of the order's name: registered when its register went through; else a code order's code +-- must still pay for it; else queued again at no charge, a released code reserved again in the code's turn. +retryRegistration :: OrdersEnv -> NameRegistration -> IO Retried +retryRegistration oe@OrdersEnv {oeNow} current = do + now <- oeNow + case registrationAt now current of + -- its commitment fixes the refused links, so only another name can register + NameRegistration {nrPhase = PFailed, nrLinksRefusedAt = Just _} -> pure $ RTRefused RFLinksRefused + r@NameRegistration {nrPhase = PFailed} -> + confirmLanded oe r >>= \case + LRegistered v -> pure $ RTWritten v + LChanged -> pure RTChanged + LUnread -> pure $ RTRefused RFUnread + LNotLanded -> retryCode oe now r >>= either (pure . RTRefused . RFCode) (requeue oe now r) + _ -> pure $ RTRefused RFNotFailed + +-- | The code a code order still holds, though revoked or expired since, or a released one it can reserve again. +retryCode :: OrdersEnv -> UTCTime -> NameRegistration -> IO (Either CodeRefusal (Maybe PrepaidCode)) +retryCode OrdersEnv {oeStore} now NameRegistration {nrId, nrLength, nrPayment} = case nrPayment of + RPInvoice {} -> pure $ Right Nothing + RPCode codeId -> + withTransaction oeStore (`getPrepaidCodeById` codeId) <&> \case + Just code -> maybe (Right $ Just code) Left $ codeRefusal now nrId nrLength code + Nothing -> Left CRInvalid + +-- | The register's transactions, which confirmLanded has read, are cleared with the failure; the reveal unless its intent still serves. +requeue :: OrdersEnv -> UTCTime -> NameRegistration -> Maybe PrepaidCode -> IO Retried +requeue oe@OrdersEnv {oeStore, oeTurns} now r@NameRegistration {nrId, nrLength} code = + servingReveal oe now r >>= \case + Left e -> RTRefused RFUnread <$ logWarn ("names: a retry's chain read failed: " <> tshow e) + Right reveal -> do + let requeued = r {nrPhase = PQueued, nrReveal = reveal, nrFailedAt = Nothing, nrError = Nothing, nrRegisterTx = Nothing, nrRegisterBlock = Nothing} + write db = versionWritten <$> updateRegistration db requeued now + outcome <- case code of + Nothing -> Right <$> withTransaction oeStore write + Just PrepaidCode {pcCodeHash} -> reserveCode oeTurns oeStore now pcCodeHash nrId nrLength write + pure $ case outcome of + Left refusal -> RTRefused $ RFCode refusal + Right (Right v) -> RTWritten v + -- a failed order is already live, so only a changed version refuses the write + Right (Left _) -> RTChanged + +-- | The stored reveal while its intent can still register: accepted by the worker's check before sending, the sponsor nonce unmoved, +-- and the commitment live with revealMargin left in a window the intent's deadline covers. A new commit or another's re-commit +-- opens a window the old deadline cannot serve. +servingReveal :: OrdersEnv -> UTCTime -> NameRegistration -> IO (Either ChainError (Maybe NameReveal)) +servingReveal OrdersEnv {oeConfig = cfg@NamesConfig {nChain = ChainConfig {cChainId, cSponsor}}, oeContracts} now r@NameRegistration {nrOwner, nrCommitment, nrReveal} = case nrReveal of + Nothing -> pure $ Right Nothing + Just rv@NameReveal {rvNonce, rvDeadline} -> + verifyRegisterIntent (sponsorDomain cChainId cSponsor) (fromInteger $ unixSeconds now) (intentOf cfg r rv) >>= \case + Left _ -> pure $ Right Nothing + Right () -> runExceptT $ do + nonce <- ExceptT $ sponsorNonce oeContracts nrOwner + if nonce /= rvNonce + then pure Nothing + else do + ages <- ExceptT $ commitmentAges oeContracts + committedAt <- ExceptT $ commitmentTime oeContracts nrCommitment + pure $ case commitmentLapse ages <$> committedAt of + Just lapse | reusable cfg now lapse && lapse <= toInteger rvDeadline -> Just rv + _ -> Nothing + +-- | Each code order failed for failedCodeHold gives its code back, in its name's and its code's turns, unless it was requeued meanwhile. +sweepFailedCodes :: Worker -> IO () +sweepFailedCodes Worker {wkOrders = OrdersEnv {oeStore, oeTurns, oeNow}} = do + cutoff <- addUTCTime (negate failedCodeHold) <$> oeNow + orders <- withTransaction oeStore (`failedCodeOrdersBefore` cutoff) + released <- forM orders $ \(rid@(RegistrationId ridText), codeId) -> + safelyWith ("names code sweep: registration " <> ridText) False $ + withTransaction oeStore (`getRegistration` rid) >>= \case + Just NameRegistration {nrLabelHash} -> withLabelTurn oeTurns nrLabelHash $ either (const False) snd <$> releaseCode oeTurns oeStore codeId rid (stillFailed cutoff rid) + Nothing -> pure False + let count = length $ filter id released + when (count > 0) $ logInfo $ "names code sweep: released the codes of " <> tshow count <> " failed order(s)" + where + stillFailed cutoff rid db = + getRegistration db rid <&> \case + Just NameRegistration {nrPhase = PFailed, nrFailedAt = Just failedAt} | failedAt < cutoff -> Right () + _ -> Left () + +runCodeSweep :: Worker -> IO () +runCodeSweep w = forever $ safely "names code sweep" (sweepFailedCodes w) >> threadDelay sweepInterval diff --git a/apps/simplex-store-service/src/StoreService/Service.hs b/apps/simplex-store-service/src/StoreService/Service.hs index c66280bdad..f88cd35623 100644 --- a/apps/simplex-store-service/src/StoreService/Service.hs +++ b/apps/simplex-store-service/src/StoreService/Service.hs @@ -42,7 +42,10 @@ import StoreService.Group (GroupEvent, ensureManagedGroup, groupEvent, hasTracke import StoreService.Group.Command (badgeTypeP, codeP, maxMonths, maxNameYears, nameCodeP, prepaidCodeP, textTokenP) import StoreService.Names.Codes (issueNameCode, revokeNameCode) import StoreService.Names.Env (NamesEnv (..), newNamesEnv) +import StoreService.Names.Orders (ordersEnv) +import StoreService.Names.Sender (runSender) import StoreService.Names.Turns (Turns, newTurns) +import StoreService.Names.Worker (newWorker, runCodeSweep, runWorkers) import StoreService.Options import StoreService.Poller (newPollerEnv, newReadHints, runPoller) import StoreService.Providers (Provider) @@ -244,7 +247,8 @@ storeService opts@StoreServiceOpts {serviceConfigFile} cfg env = do webEnv <- newWebEnv chatStore sc ws hints providers namesEnv exportWebapp sc pollerEnv <- newPollerEnv chatStore ws (nePhases <$> namesEnv) hints providers (poll sc) - pure [runWebListeners webEnv, runPoller pollerEnv] + nameLanes <- maybe (pure []) namesLanes namesEnv + pure $ [runWebListeners webEnv, runPoller pollerEnv] <> nameLanes startNames :: ChatController -> Turns -> Waiters -> [Provider] -> NamesConfig -> IO NamesEnv startNames cc@ChatController {chatStore} turns waiters providers nc@NamesConfig {nTLD, nCodesOnly, nChain = ChainConfig {cChainId}} = @@ -256,6 +260,12 @@ startNames cc@ChatController {chatStore} turns waiters providers nc@NamesConfig where codesOnlyNote = if nCodesOnly then ", codes only: registration needs a prepaid code" else "" +-- | The workers resume every registration in their phases, and the code sweep runs at the start and then daily. +namesLanes :: NamesEnv -> IO [IO ()] +namesLanes ne@NamesEnv {neChain, neSender} = do + worker <- newWorker (ordersEnv ne) neChain neSender + pure [runSender neSender, runWorkers worker, runCodeSweep worker] + seedServiceCatalog :: DBStore -> IO () seedServiceCatalog st = do now <- truncateToSecond <$> getCurrentTime diff --git a/tests/Bots/StoreService/GroupIntegrationTests.hs b/tests/Bots/StoreService/GroupIntegrationTests.hs index c851e4e8af..6f9980bc72 100644 --- a/tests/Bots/StoreService/GroupIntegrationTests.hs +++ b/tests/Bots/StoreService/GroupIntegrationTests.hs @@ -8,11 +8,12 @@ {-# LANGUAGE TupleSections #-} -- Members' messages reach a console over separate connections in no fixed order, so gating is asserted from the bot's store. -module Bots.StoreService.GroupIntegrationTests (badgeGroupIntegrationTests, namesBootTests, namesCodesChatTests) where +module Bots.StoreService.GroupIntegrationTests (badgeGroupIntegrationTests, namesBootTests, namesCodesChatTests, namesWorkerBootTests) where import StoreService.Config (BadgeIssuerKey (..), GroupConfig (..)) import StoreService.Group (GroupAction (..), GroupEvent (..), codeInTracker, ensureManagedGroup) import StoreService.Group.Command (maxUses) +import StoreService.Names.Abi (selector, uint256) import StoreService.Names.Codes (issueNameCode, reserveCode, revokeNameCode) import StoreService.Names.Phases (RegistrationId (..)) import StoreService.Names.Store (PrepaidCode (..), getPrepaidCode, spendPrepaidCode) @@ -21,7 +22,9 @@ import StoreService.Options (StoreServiceOpts (..)) import StoreService.Service (ServiceState (..), newServiceState, storeService) import StoreService.Store (ManagedGroup (..), getManagedGroup) import Bots.StoreService.BotTests (badgeBotName, badgeCmdUsage, badgeProfile, badgeTypeOf, credentialOf, entryOf, issueCode, issueRaw, mkStoreServiceOpts, newPurchaseKeys, redeemWithQueue, requestObject, revokeRaw, serviceDbPrefix, shouldAnswerError, statementOf, stopStoreService, testIssuerKeyIdx) -import Bots.StoreService.ConfigTests (chainSection, namesSection) +import Bots.StoreService.ConfigTests (chainSection, controllerAddr, namesSection) +import Bots.StoreService.FakeEthNode (CallAnswer (..), FakeEthNode (..), answerCall, awaitSent, withFakeEthNode) +import Bots.StoreService.WebTests (digestFixture) import Bots.StoreService.NamesSearchTests (aliceHex) import Bots.StoreService.NamesStoreTests (order, ownerA, placeCode, placePaid) import ChatClient @@ -139,7 +142,7 @@ badgeGroupIntegrationTests = do namesBootTests :: SpecWith TestParams namesBootTests = do it "boots codes-only, refusing paid name orders 403 codes_only and answering code orders and code checks, the badges shell as built" testNamesBootCodesOnly - it "boots with [names] and [chain], routing fixed /api/name paths ahead of a search, registrations to GET, a path no route knows and a taken order's code to 404, and code checks and orders under one limit" testNamesBoot + it "boots with [names] and [chain], routing fixed /api/name paths ahead of a search, registrations to GET, a reveal and a retry to POST, a path no route knows and a taken order's code to 404, code checks and orders under one limit, and retries under another" testNamesBoot testNamesBoot :: HasCallStack => TestParams -> IO () testNamesBoot ps = do @@ -163,6 +166,17 @@ testNamesBoot ps = do (statusCode $ responseStatus posted, lookup "Allow" $ responseHeaders posted) `shouldBe` (405, Just "GET") coded <- request "/api/registration/t2Jk8RmQ4vXw9NcP3yLb6g/code" answer coded {method = "POST", requestBody = RequestBodyLBS "{}"} `shouldReturn` (404, Just $ J.object ["error" J..= ("not_found" :: Text)]) + revealed <- request "/api/registration/t2Jk8RmQ4vXw9NcP3yLb6g/reveal" + answer revealed {method = "POST", requestBody = RequestBodyLBS "{}"} `shouldReturn` (404, Just $ J.object ["error" J..= ("not_found" :: Text)]) + revealedByGet <- httpLbs revealed mgr + (statusCode $ responseStatus revealedByGet, lookup "Allow" $ responseHeaders revealedByGet) `shouldBe` (405, Just "POST") + retried <- request "/api/registration/t2Jk8RmQ4vXw9NcP3yLb6g/retry" + answer retried {method = "POST"} `shouldReturn` (404, Just $ J.object ["error" J..= ("not_found" :: Text)]) + retriedByGet <- httpLbs retried mgr + (statusCode $ responseStatus retriedByGet, lookup "Allow" $ responseHeaders retriedByGet) `shouldBe` (405, Just "POST") + -- the retry above took 1 of this client's 5 create requests a minute + replicateM_ 4 $ statusCode . responseStatus <$> httpLbs retried {method = "POST"} mgr `shouldReturn` 404 + statusCode . responseStatus <$> httpLbs retried {method = "POST"} mgr `shouldReturn` 429 -- the register above took the first of this client's 10 code requests a minute, which the code check shares let codeRequest path = request path >>= \r -> statusCode . responseStatus <$> httpLbs r {method = "POST", requestBody = RequestBodyLBS "{}"} mgr forM_ (take 9 $ cycle ["/api/code/check", "/api/name/register"]) $ \path -> (path,) <$> codeRequest path `shouldReturn` (path, 400) @@ -194,6 +208,27 @@ testNamesBootCodesOnly ps = do codesOnlyNames :: [Text] codesOnlyNames = namesSection <> ["codes_only = on"] +namesWorkerBootTests :: SpecWith TestParams +namesWorkerBootTests = it "starts the workers with the service, sending the commit of an order queued after the start" testWorkerBoot + +testWorkerBoot :: HasCallStack => TestParams -> IO () +testWorkerBoot ps = withFakeEthNode $ \node@FakeEthNode {fnUrl} -> do + svc <- prepareGroupService ps + let onFakeNode line = if "rpc_url" `T.isPrefixOf` line then "rpc_url = " <> T.pack fnUrl else line + controller = either error id $ strDecode $ encodeUtf8 controllerAddr + -- the order's commitment, digestFixture 1, not yet committed + forM_ [("minCommitmentAge()", "", 60 :: Int), ("maxCommitmentAge()", "", 86400), ("commitments(bytes32)", digestFixture 1, 0)] $ \(signature, args, value) -> + answerCall node controller (selector signature <> args) $ Returns $ uint256 value + (t, cc, _, port) <- startGroupService svc {gsIniSections = "" : namesSection <> map onFakeNode chainSection} Nothing + flip finally (stopGroupService t cc) $ do + pollUntilTrue (listening port) + let st = chatStore cc + code <- issueNameRaw cc "name 8" + row <- fromMaybe (error "no prepaid code row") <$> withTransaction st (`getPrepaidCode` namePrepaidCodeHash code) + placeCode st "r1" ownerA (order "alicebakery" 1) row `shouldReturn` Right () + timeout waitLimit (awaitSent node 1) >>= (`shouldSatisfy` isJust) + poll t >>= (`shouldSatisfy` isNothing) + namesCodesChatTests :: SpecWith TestParams namesCodesChatTests = describe "StoreService names: prepaid codes" $ do it "issues prepaid codes on /issue name and /bulk name, answering the usage to years below 2" testGroupNameCodes diff --git a/tests/Bots/StoreService/NamesOrdersTests.hs b/tests/Bots/StoreService/NamesOrdersTests.hs index eadbe69955..e8157f89c0 100644 --- a/tests/Bots/StoreService/NamesOrdersTests.hs +++ b/tests/Bots/StoreService/NamesOrdersTests.hs @@ -296,6 +296,7 @@ testNamesConfig node = nYears = 2, nTermStart = termStart, nTermSlackSeconds = slackSeconds, + nRevealMarginSeconds = 900, nCodesOnly = False, nChain = fakeChainConfig node } diff --git a/tests/Bots/StoreService/NamesOwnerTests.hs b/tests/Bots/StoreService/NamesOwnerTests.hs new file mode 100644 index 0000000000..feefaaf2f2 --- /dev/null +++ b/tests/Bots/StoreService/NamesOwnerTests.hs @@ -0,0 +1,132 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TupleSections #-} + +module Bots.StoreService.NamesOwnerTests + ( answerExpiry, + answerFree, + answerOwner, + answerUnowned, + byB, + codeIn, + committedPhase, + dynamisOrder, + failedPhase, + labelBytes, + ownerOfSelector, + paidIn, + rewrite, + sentRegister, + stored, + ) +where + +import Bots.StoreService.FakeEthNode +import Bots.StoreService.NamesContractsTests (registrarOf, unhex) +import Bots.StoreService.NamesOrdersTests +import Bots.StoreService.WebTests (digestFixture) +import Control.Monad (void) +import Data.ByteString (ByteString) +import Data.IORef (readIORef) +import Data.Maybe (fromJust) +import Data.Text (Text) +import Data.Time.Clock (UTCTime) +import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds) +import Data.Word (Word64, Word8) +import Simplex.Chat.PaymentService.Types (InvoiceStatus (..)) +import Simplex.Messaging.Agent.Store.Common (withTransaction) +import Simplex.Messaging.Eth.Address (Address) +import Simplex.Messaging.SimplexName (LabelHash (..), labelHash) +import StoreService.Names.Abi (addressWord, uint256) +import StoreService.Names.Chain (TxHash (..)) +import StoreService.Names.Store hiding (findLimit) +import Test.Hspec + +seconds :: UTCTime -> Word64 +seconds = floor . utcTimeToPOSIXSeconds + +byB :: Order -> Order +byB o = o {oOwner = ownerBText, oKey = keyB} + +dynamisOrder :: Order +dynamisOrder = aliceOrder {oLabel = "dynamis", oCommitment = commitmentOf 3, oSealed = "sealed-dynamis-3", oPrice = 20000} + +-- viem's selectors of nameExpires(uint256), reservedNames(bytes32) and ownerOf(uint256), as in the calls of the contracts tests +nameExpiresSelector, reservedNamesSelector, ownerOfSelector :: ByteString +nameExpiresSelector = unhex "d6e4fa86" +reservedNamesSelector = unhex "389c0748" +ownerOfSelector = unhex "6352211e" + +labelBytes :: Text -> ByteString +labelBytes label = lh + where + LabelHash lh = labelHash label + +-- | ownerOf of a name nobody holds: the registrar's bare require, a revert without data. +answerUnowned :: Ctx -> Text -> IO () +answerUnowned Ctx {cNode} label = answerCall cNode (registrarOf cNode) (ownerOfSelector <> labelBytes label) $ Reverts "" + +answerOwner :: Ctx -> Text -> Address -> IO () +answerOwner Ctx {cNode} label owner = answerCall cNode (registrarOf cNode) (ownerOfSelector <> labelBytes label) $ Returns $ addressWord owner + +answerExpiry :: Ctx -> Text -> Word64 -> IO () +answerExpiry Ctx {cNode} label expiry = answerCall cNode (registrarOf cNode) (nameExpiresSelector <> labelBytes label) $ Returns $ uint256 expiry + +-- | A register transaction of the order as the sender saves it, then moved to this outcome. +sentRegister :: Ctx -> NameRegistration -> Word8 -> TxStatus -> IO TxHash +sentRegister Ctx {cStore} NameRegistration {nrId} n status = withTransaction cStore $ \db -> do + let h = TxHash $ digestFixture n + void $ insertTransaction db (TxRegister nrId) NewTransaction {ntxRaw = "raw", ntxHash = h, ntxNonce = fromIntegral n} orderTime + recordTransactionOutcome db h TSPending status (Just 120) `shouldReturn` True + pure h + +-- | The chain answers the name as available and held by nobody. +answerFree :: Ctx -> Text -> IO () +answerFree ctx label = answerReserved ctx label 0 >> answerUnowned ctx label + +answerReserved :: Ctx -> Text -> Int -> IO () +answerReserved Ctx {cNode} label reason = do + answerCall cNode (registrarOf cNode) (nameExpiresSelector <> lh) $ Returns $ uint256 (0 :: Int) + answerCall cNode fakeController (reservedNamesSelector <> lh) $ Returns $ uint256 reason + where + LabelHash lh = labelHash label + +-- | A paid order, settled, then written as the worker would write it. +paidIn :: Ctx -> Order -> (NameRegistration -> NameRegistration) -> IO NameRegistration +paidIn ctx o change = do + (invId, _) <- placed ctx o + settleNow ctx invId settled `shouldReturn` Right ISPaid + r <- invoiceRegistration ctx invId + rewrite ctx r change + +-- | A code order of a code of this length, then written as the worker would write it. +codeIn :: Ctx -> Int -> Order -> (NameRegistration -> NameRegistration) -> IO (NameRegistration, PrepaidCode) +codeIn ctx len o change = do + (text, code) <- issueCode ctx len 2 id + r <- registrationById ctx =<< registered ctx text o + (,code) <$> rewrite ctx r change + +-- | A write outside the turns, as the worker's, at the stored version. +rewrite :: Ctx -> NameRegistration -> (NameRegistration -> NameRegistration) -> IO NameRegistration +rewrite Ctx {cStore, cClock} NameRegistration {nrId} change = do + t <- readIORef cClock + withTransaction cStore $ \db -> do + current <- fromJust <$> getRegistration db nrId + updateRegistration db (change current) t >>= \case + Written _ -> fromJust <$> getRegistration db nrId + refused -> error $ "not written: " <> show refused + +stored :: Ctx -> NameRegistration -> IO NameRegistration +stored ctx = registrationById ctx . nrId + +failedPhase, committedPhase :: NameRegistration -> NameRegistration +failedPhase r = r {nrPhase = PFailed, nrFailedAt = Just orderTime, nrError = Just "The name could not be registered"} +committedPhase r = + r + { nrPhase = PCommitted, + nrCommitTx = Just (TxHash $ digestFixture 8), + nrCommitBlock = Just 100, + nrRevealAfter = Just (seconds orderTime + 60), + nrRevealBefore = Just (seconds orderTime + 86400) + } \ No newline at end of file diff --git a/tests/Bots/StoreService/NamesWorkerTests.hs b/tests/Bots/StoreService/NamesWorkerTests.hs new file mode 100644 index 0000000000..d14bb68c90 --- /dev/null +++ b/tests/Bots/StoreService/NamesWorkerTests.hs @@ -0,0 +1,1043 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE TupleSections #-} + +module Bots.StoreService.NamesWorkerTests (namesWorkerTests) where + +import Bots.StoreService.FakeEthNode +import Bots.StoreService.NamesContractsTests (availableCall, maxCommitmentAgeCall, minCommitmentAgeCall, noncesCall, registrarOf, unhex) +import Bots.StoreService.NamesOrdersTests +import Bots.StoreService.NamesOwnerTests (answerExpiry, answerFree, answerOwner, answerUnowned, byB, codeIn, committedPhase, dynamisOrder, failedPhase, labelBytes, ownerOfSelector, paidIn, rewrite, sentRegister, stored) +import Bots.StoreService.NamesPhasesTests (held, prompt, registrationPath, woken) +import Bots.StoreService.NamesStoreTests (reveal) +import Bots.StoreService.WebTests (capturingStderr, jsonObject, statusOf, stubCalls, webGet, webRequestBody) +import Control.Applicative ((<|>)) +import Control.Arrow ((&&&)) +import Control.Concurrent.Async (wait, withAsync) +import Control.Concurrent.MVar (newEmptyMVar, putMVar, takeMVar) +import Control.Concurrent.STM (atomically, check) +import Control.Monad (forM_, replicateM, replicateM_, void) +import Data.ByteString (ByteString) +import qualified Data.Aeson as J +import qualified Data.Aeson.KeyMap as KM +import Data.IORef (readIORef) +import Data.Maybe (fromJust, fromMaybe, isJust) +import Data.Text (Text) +import qualified Data.Text as T +import Data.Time.Clock (NominalDiffTime, UTCTime, addUTCTime) +import Data.Time.Clock.POSIX (posixSecondsToUTCTime, utcTimeToPOSIXSeconds) +import Data.Word (Word64) +import Network.HTTP.Client (defaultManagerSettings, newManager, responseBody) +import qualified Network.Wai.Handler.Warp as Warp +import Simplex.Messaging.Agent.Store.Common (withTransaction) +import qualified Simplex.Messaging.Agent.Store.DB as DB +import Simplex.Messaging.Crypto (keccak256) +import Simplex.Messaging.Crypto.Secp256k1 (Secp256k1PrivateKey, signRecoverable) +import Simplex.Messaging.SimplexName (labelHash) +import Simplex.Messaging.Util (tshow) +import StoreService.Config (NamesConfig) +import StoreService.Names.Abi (abiBytes, abiTuple, addressWord, AbiValue (..), hex, selector, uint256) +import StoreService.Names.Chain (Block (..), ChainClient, Receipt (..), TxHash (..), TxRequest (..), blockAt, decodeSignedTx, newChainClient) +import StoreService.Names.Orders (Landing (..), OrdersEnv (..), confirmLanded) +import StoreService.Names.Phases (RegistrationId (..), awaitChange) +import StoreService.Names.Registration (RegisterIntent (..), commitCalldata, registerIntentDigest, registerWithCreditCalldata, sponsorDomain) +import StoreService.Names.Reveal (intentOf) +import StoreService.Names.Sender +import StoreService.Names.Store +import StoreService.Names.Turns (labelTurnCount, withLabelTurn) +import StoreService.Names.Worker +import StoreService.Web.Http (createLimit, holdMicros, readLimit) +import StoreService.Web.Names (Route (..), namesApp) +import StoreService.Web.Names.Registration (registrationHandler, retryHandler) +import StoreService.Web.Server (WebEnv (..), webApp) +import System.Timeout (timeout) +import Test.Hspec + +namesWorkerTests :: Spec +namesWorkerTests = describe "StoreService names: worker" $ do + describe "commit" $ do + it "commits, waits for the reveal and revealAfter, and registers a code order, spending its code and publishing each change" testCommitWaitRegister + it "registers a code order with codes_only on, from the code check to the registered view, refusing a paid order" testCodesOnlyRegister + it "waits for a pending commit without sending another, following its fee-bumped replacement" testPendingCommit + it "goes to committed when the commit reverts UnexpiredCommitmentExists, in its dry run or mined, with the commitment's times" testUnexpiredCommitment + it "sends a commit mined out of gas again" testCommitOutOfGas + it "waits a second at the lapse second, and again when the dry run still reverts, then commits" testLapseSecond + it "waits a second at most a few times in a row for UnexpiredCommitmentExists, logging each, then keeps the phase" testUnexpiredBounded + it "clears a requeued order's stale intent before committing again after a lapse, and a third party's commitment's" testStaleIntent + it "keeps the phase while the latest block needs more than the fee cap, then commits" testFeeAboveCap + describe "writes" $ do + it "writes nothing when the registration changed since it was read" testLostRace + it "writes in the name's turn" testInNameTurn + describe "register" $ do + it "ends the later of two wallets' paid orders for one name taken, not live, with its value kept" testTwoWallets + it "ends taken on any revert while the name is not available, releasing a code" testRevertTaken + it "keeps the phase on NameNotAvailable while the name still reads available, as for a pending competitor" testPendingCompetitor + it "ends failed on a revert while the name is available, alerting on InsufficientAllowance and keeping a code" testRevertFailed + it "clears the reveal on InvalidNonce, staying committed" testInvalidNonce + it "relays no intent past its deadline, ending failed" testExpiredIntent + it "keeps the phase when a read of the final check fails" testCheckUnread + it "waits a second when the dry run reverts CommitmentTooNew" testCommitmentTooNew + it "ends a register mined with status 0 taken while the name is not available, releasing a code" testMinedRevertTaken + it "writes failed only once no register can still be mined, and registered when the owner holds the name" testFailedOnlySettled + describe "lapse" $ do + it "ends a committed order not revealed by revealBefore failed, keeping its code" testLapseFailed + it "wakes a held poll with failed at the lapse, and answers an old version at once after it" testLapsePoll + describe "restart" $ do + it "resumes every phase after a restart, a commit saved but not recorded included" testRestart + it "waits for a register saved but not recorded before a restart, sending no other" testRestartRegisterSaved + describe "lanes" $ do + it "starts a worker for each registration in its phases" testRunWorkers + it "releases the codes of code orders failed for 30 days, and no others" testCodeSweep + describe "confirmation depth" $ + it "judges a register landed by ownerOf only once the owner holds the name at the confirmation depth" testLandedAtDepth + describe "sender" $ + it "bounds the wait for a transaction's outcome" testOutcomeBound + describe "retry" $ do + it "refuses Try again outside failed with bad_request, changing nothing, and answers an unknown order 404" testRetryNotFailed + it "refuses Try again of a failed order whose links were refused with bad_request, changing nothing" testRetryLinksRefused + it "registers a failed order whose register went through: by its mined register after a redeem, spending its code, and by ownerOf with no register shown" testRetryLanded + it "answers provider_unavailable when the register check or a read for the stored intent fails, changing nothing" testRetryUnread + it "answers a released code's error while it cannot pay again, before any read for the intent, and reserves it again while unused" testRetryReleasedCode + it "requeues clearing failed_at, error and the register's hashes, waking a held poll" testRetryRequeue + it "keeps the intent while our commitment is live with revealMargin left, going straight to committed" testRetryLiveCommitment + it "clears the label and intent when the sponsor nonce moved, our live commit keeping its hashes" testRetryNonceMoved + it "clears the label and an intent the worker would refuse, while our commitment is live with revealMargin left" testRetryRefusedIntent + it "clears the intent of a third party's live re-commit, and the worker the commit's hashes" testRetryThirdParty + it "clears the intent with less than revealMargin left, committing again a second after revealBefore" testRetryMargin + it "requeues a lapsed committed order, which reads failed, answering an old version at once after it" testRetryLapsed + it "answers registration_changed with the current view when the order changed during its checks, writing nothing" testRetryLostRace + it "runs in the name's turn, answering registration_changed for an order moved to another name meanwhile" testRetryInNameTurn + it "takes one create token per request" testRetryLimit + +-- fixtures + +data W = W + { wCtx :: Ctx, + wChain :: ChainClient, + wSender :: Sender, + wWorker :: Worker + } + +-- | The worker over the orders' store and fake node, with the registration poll and Try again as namesRoutes registers them. +withWorker :: (W -> IO a) -> IO a +withWorker = withWorkerAs id + +-- | With the names settings changed, as the service reads them at startup. +withWorkerAs :: (NamesConfig -> NamesConfig) -> (W -> IO a) -> IO a +withWorkerAs settings action = withOrders $ \open -> do + let ctx@Ctx {cNode, cOrders, cWeb} = configured settings open + answerCall cNode fakeController minCommitmentAgeCall $ Returns $ uint256 minAge + answerCall cNode fakeController maxCommitmentAgeCall $ Returns $ uint256 maxAge + answerUnowned ctx "alicebakery" + let web = cWeb {weOrders = Just cOrders} + routes path = registrationRoute path <|> codeRoutes cOrders (weProviders web) (weWaiters web) path + registrationRoute = \case + ["api", "registration", rid] -> Just Route {rMethod = "GET", rLimit = readLimit, rHandler = registrationHandler cOrders holdMicros rid} + ["api", "registration", rid, "retry"] -> Just Route {rMethod = "POST", rLimit = createLimit, rHandler = retryHandler cOrders rid} + _ -> Nothing + app req respond = fromMaybe (webApp web req respond) (namesApp (weHttp web) routes req respond) + mgr <- newManager defaultManagerSettings + Warp.testWithApplication (pure app) $ \port -> started ctx {cWeb = web, cClient = (mgr, "http://127.0.0.1:" <> show port)} >>= action + +-- | A new sender and worker over the same store, as after a restart. +started :: Ctx -> IO W +started wCtx@Ctx {cNode, cStore, cRandom, cClock, cOrders} = do + wChain <- newChainClient cRandom $ fakeChainConfig cNode + wSender <- newSender cRandom wChain cStore (readIORef cClock) + wWorker <- newWorker cOrders wChain wSender + pure W {wCtx, wChain, wSender, wWorker} + +minAge, maxAge :: Word64 +minAge = 60 +maxAge = 86400 + +orderSeconds :: Word64 +orderSeconds = floor $ utcTimeToPOSIXSeconds orderTime + +expiry :: Word64 +expiry = orderSeconds + 2 * 31536000 + +at :: Word64 -> UTCTime +at = posixSecondsToUTCTime . fromIntegral + +day :: NominalDiffTime +day = 86400 + +-- | Committed a minute before the order. +openPhase :: NameRegistration -> NameRegistration +openPhase r = (committedPhase r) {nrRevealAfter = Just (orderSeconds - minAge), nrRevealBefore = Just (orderSeconds - minAge + maxAge)} + +-- | The reveal the page sends, its intent signed with the owner's key. +signedReveal :: Ctx -> Secp256k1PrivateKey -> NameReveal -> NameRegistration -> IO NameReveal +signedReveal Ctx {cRandom, cOrders} key rv r = do + let RegisterIntent {riRegistration} = intentOf (oeConfig cOrders) r rv + sig <- either (error . show) id <$> signRecoverable cRandom key (registerIntentDigest (sponsorDomain fakeChainId fakeSponsor) riRegistration (rvNonce rv) (rvDeadline rv)) + pure rv {rvSignature = sig} + +-- | The registration with the page's reveal of the label accepted. +revealed :: Ctx -> Secp256k1PrivateKey -> Text -> NameRegistration -> IO NameRegistration +revealed ctx key label r = signedReveal ctx key reveal {rvLabel = label} r >>= \rv -> rewrite ctx r (\o -> o {nrReveal = Just rv}) + +-- | Steps until the worker has nothing to do at once. +steps :: W -> NameRegistration -> IO Next +steps W {wWorker} NameRegistration {nrId} = go (10 :: Int) + where + go 0 = fail "the worker kept stepping" + go n = + stepRegistration wWorker nrId >>= \case + Again -> go (n - 1) + next -> pure next + +shape :: Next -> String +shape = \case + Done -> "Done" + Again -> "Again" + WaitUntil v t -> "WaitUntil " <> show v <> " " <> show t + Retry v reason -> "Retry " <> show v <> " " <> T.unpack reason + Await p -> "Await " <> show (ptHash p) + +awaiting :: Next -> IO PendingTx +awaiting = \case + Await p -> pure p + next -> fail $ "not awaiting a transaction: " <> shape next + +waitingUntil :: Next -> IO UTCTime +waitingUntil = \case + WaitUntil _ t -> pure t + next -> fail $ "not waiting: " <> shape next + +retrying :: Next -> IO () +retrying = \case + Retry {} -> pure () + next -> fail $ "not retrying: " <> shape next + +done :: Next -> IO () +done = \case + Done -> pure () + next -> fail $ "not done: " <> shape next + +-- | The raw transactions the node received, in the order they were sent. +sent :: W -> IO [ByteString] +sent W {wCtx = Ctx {cNode}} = sentTransactions cNode + +newestHash :: W -> IO TxHash +newestHash w = TxHash . keccak256 . last <$> sent w + +-- | Mines the newest transaction sent, with this status, and the blocks after it that settle it; the receipt's block. +mineNewest :: W -> Bool -> IO Word64 +mineNewest w@W {wCtx = Ctx {cNode}, wSender} ok = do + TxHash h <- newestHash w + block <- mine cNode [(h, ok)] + replicateM_ 2 $ mine cNode [] + followTransactions wSender + pure block + +blockTime :: W -> Word64 -> IO Word64 +blockTime W {wChain} n = either (error . show) blockTimestamp <$> blockAt wChain n + +commitmentsCall :: NameRegistration -> ByteString +commitmentsCall NameRegistration {nrCommitment} = selector "commitments(bytes32)" <> nrCommitment + +-- | The commitment's time on chain, 0 for none. +answerCommitment :: W -> NameRegistration -> Word64 -> IO () +answerCommitment W {wCtx = Ctx {cNode}} r t = answerCall cNode fakeController (commitmentsCall r) $ Returns $ uint256 t + +answerAvailable :: W -> Bool -> IO () +answerAvailable W {wCtx = Ctx {cNode}} available = answerCall cNode fakeController availableCall $ Returns $ uint256 (if available then 1 else 0 :: Int) + +-- | The dry runs revert with the contracts' error of this signature. +dryRunsRevert :: W -> ByteString -> ByteString -> IO () +dryRunsRevert W {wCtx = Ctx {cNode}} signature args = setFault cNode "eth_estimateGas" $ revertFault $ selector signature <> args + +dryRunsPass :: W -> IO () +dryRunsPass W {wCtx = Ctx {cNode}} = clearFault cNode "eth_estimateGas" + +-- | The action's result, failing unless it published the version it wrote to a poll held at the version before. +published :: W -> NameRegistration -> IO a -> IO a +published W {wCtx = ctx} r action = do + NameRegistration {nrId, nrVersion} <- stored ctx r + poll <- held ctx (0, 1) $ registrationPath nrId <> "?seenVersion=" <> show nrVersion + a <- action + (status, view) <- woken "the registration poll" poll + NameRegistration {nrVersion = written} <- stored ctx r + (status, field "version" view, written > nrVersion) `shouldBe` (200, Just (J.toJSON written), True) + pure a + +traverseFst :: (a -> IO c) -> (a, b) -> IO (c, b) +traverseFst f (a, b) = (,b) <$> f a + +codeOf :: Ctx -> PrepaidCode -> IO PrepaidCode +codeOf Ctx {cStore} PrepaidCode {pcId} = withTransaction cStore $ \db -> fromJust <$> getPrepaidCodeById db pcId + +nowOf :: Ctx -> IO UTCTime +nowOf Ctx {cClock} = readIORef cClock + +-- tests + +testCommitWaitRegister :: IO () +testCommitWaitRegister = withWorker $ \w@W {wCtx = ctx} -> codeIn ctx 8 aliceOrder id >>= commitWaitRegister w + +testCodesOnlyRegister :: IO () +testCodesOnlyRegister = withWorkerAs codesOnly $ \w@W {wCtx = ctx@Ctx {cClient}} -> do + (text, code) <- issueCode ctx 8 2 id + (status, coverage) <- post ctx "/api/code/check" (J.encode $ J.object ["code" J..= text]) + (status, field "state" =<< coverage) `shouldBe` (200, Just "unused") + placeOrder ctx aliceOrder `shouldReturn` refusedWith 403 "codes_only" + r <- registrationById ctx =<< registered ctx text aliceOrder + commitWaitRegister w (r, code) + (status', view) <- (statusOf &&& J.decode . responseBody) <$> webGet cClient (registrationPath $ nrId r) + (status', field "phase" =<< view) `shouldBe` (200, Just "registered") + stubCalls (cStub ctx) `shouldReturn` [] + +-- | A queued code order, committed, revealed and registered. +commitWaitRegister :: W -> (NameRegistration, PrepaidCode) -> IO () +commitWaitRegister w@W {wCtx = ctx} (r, code) = do + answerExpiry ctx "alicebakery" expiry + answerCommitment w r 0 + void $ published w r $ steps w r >>= awaiting + [commitRaw] <- sent w + committing <- stored ctx r + (nrPhase committing, nrCommitTx committing, nrVersion committing) `shouldBe` (PCommitting, Just (TxHash $ keccak256 commitRaw), nrVersion r + 1) + -- the commit in flight is waited for + steps w r >>= awaiting >>= (`shouldBe` TxHash (keccak256 commitRaw)) . ptHash + length <$> sent w `shouldReturn` 1 + commitBlock <- mineNewest w True + t <- blockTime w commitBlock + answerCommitment w r t + -- committed, waiting for the reveal until the lapse + published w r (steps w r >>= waitingUntil) `shouldReturn` at (t + maxAge + 1) + committed <- stored ctx r + (nrPhase committed, nrRevealAfter committed, nrRevealBefore committed, nrCommitTx committed, nrCommitBlock committed) + `shouldBe` (PCommitted, Just (t + minAge), Just (t + maxAge), Just (TxHash $ keccak256 commitRaw), Just commitBlock) + -- the page reveals before revealAfter + void $ revealed ctx keyA "alicebakery" r + steps w r >>= waitingUntil >>= (`shouldBe` at (t + minAge)) + advance ctx $ fromIntegral (t + minAge) - fromIntegral orderSeconds + void $ published w r $ steps w r >>= awaiting + registerTx <- newestHash w + registering <- stored ctx r + (nrPhase registering, nrRegisterTx registering) `shouldBe` (PRegistering, Just registerTx) + registerBlock <- mineNewest w True + now <- nowOf ctx + published w r (steps w r) >>= done + x <- stored ctx r + (nrPhase x, nrRegisterTx x, nrRegisterBlock x, nrExpiresAt x, nrRegisteredAt x, nrLive x) `shouldBe` (PRegistered, Just registerTx, Just registerBlock, Just expiry, Just now, False) + isJust . pcSpentAt <$> codeOf ctx code `shouldReturn` True + steps w r >>= done + +testPendingCommit :: IO () +testPendingCommit = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}, wSender} -> do + r <- paidIn ctx aliceOrder id + answerCommitment w r 0 + first <- ptHash <$> (steps w r >>= awaiting) + replicateM_ 3 $ steps w r >>= awaiting >>= (`shouldBe` first) . ptHash + length <$> sent w `shouldReturn` 1 + -- the market's fees pass the commit's, so the sender replaces it + setFees cNode (2 * fakeTip) (2 * fakeBaseFee) + advance ctx 181 + followTransactions wSender + replacement <- newestHash w + replacement `shouldNotBe` first + inFlight <- stored ctx r + steps w r >>= awaiting >>= (`shouldBe` replacement) . ptHash + x <- stored ctx r + (nrPhase x, nrCommitTx x, nrVersion x) `shouldBe` (PCommitting, Just replacement, nrVersion inFlight + 1) + length <$> sent w `shouldReturn` 2 + +testUnexpiredCommitment :: IO () +testUnexpiredCommitment = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + -- an earlier commit of the commitment mined between the read and the dry run + r <- paidIn ctx aliceOrder id + let t = orderSeconds - 600 + answerCommitment w r t + answerCallOnce cNode fakeController (commitmentsCall r) $ Returns $ uint256 (0 :: Int) + dryRunsRevert w "UnexpiredCommitmentExists(bytes32)" (nrCommitment r) + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime 1 orderTime) + sent w `shouldReturn` [] + stored ctx r `shouldReturn` r + dryRunsPass w + steps w r >>= waitingUntil >>= (`shouldBe` at (t + maxAge + 1)) + x <- stored ctx r + (nrPhase x, nrRevealAfter x, nrRevealBefore x, nrCommitTx x) `shouldBe` (PCommitted, Just (t + minAge), Just (t + maxAge), Nothing) + -- a commit sent, mined with status 0 after another commit of it + r2 <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} id + answerCommitment w r2 0 + void $ steps w r2 >>= awaiting + void $ mineNewest w False + let t2 = orderSeconds - 30 + answerCommitment w r2 t2 + steps w r2 >>= waitingUntil >>= (`shouldBe` at (t2 + maxAge + 1)) + x2 <- stored ctx r2 + (nrPhase x2, nrRevealBefore x2, nrCommitTx x2, nrCommitBlock x2) `shouldBe` (PCommitted, Just (t2 + maxAge), Nothing, Nothing) + length <$> sent w `shouldReturn` 1 + +testCommitOutOfGas :: IO () +testCommitOutOfGas = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder id + answerCommitment w r 0 + first <- ptHash <$> (steps w r >>= awaiting) + void $ mineNewest w False + second <- ptHash <$> (steps w r >>= awaiting) + second `shouldNotBe` first + [_, raw] <- sent w + trNonce <$> either error pure (decodeSignedTx raw) `shouldReturn` 1 + x <- stored ctx r + (nrPhase x, nrCommitTx x) `shouldBe` (PCommitting, Just second) + +testLapseSecond :: IO () +testLapseSecond = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder id + -- a live commitment with less than the reveal margin left is not reused + answerCommitment w r (orderSeconds + 600 - maxAge) + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime 601 orderTime) + -- at the lapse second it can neither register nor be committed again + advance ctx 600 + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime 601 orderTime) + stored ctx r `shouldReturn` r + advance ctx 1 + -- the node's latest block is still at the lapse second + dryRunsRevert w "UnexpiredCommitmentExists(bytes32)" (nrCommitment r) + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime 602 orderTime) + sent w `shouldReturn` [] + stored ctx r `shouldReturn` r + dryRunsPass w + advance ctx 1 + void $ steps w r >>= awaiting + nrPhase <$> stored ctx r `shouldReturn` PCommitting + length <$> sent w `shouldReturn` 1 + +testUnexpiredBounded :: IO () +testUnexpiredBounded = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder id + -- lapsed by the service's clock, while the node's pending block keeps refusing a new commit + answerCommitment w r (orderSeconds - maxAge - 1) + dryRunsRevert w "UnexpiredCommitmentExists(bytes32)" (nrCommitment r) + logs <- capturingStderr $ forM_ [1 .. maxUnexpiredWaits] $ \n -> do + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime (fromIntegral n) orderTime) + advance ctx 1 + -- the capture can also hold earlier tests' lines, so only this order's count + let RegistrationId rid = nrId r + length (T.breakOnAll ("registration " <> rid <> ": the commit's dry run reverted UnexpiredCommitmentExists") logs) `shouldBe` maxUnexpiredWaits + steps w r >>= retrying + stored ctx r `shouldReturn` r + sent w `shouldReturn` [] + dryRunsPass w + void $ steps w r >>= awaiting + nrPhase <$> stored ctx r `shouldReturn` PCommitting + +testStaleIntent :: IO () +testStaleIntent = withWorker $ \w@W {wCtx = ctx} -> do + -- requeued by Try again with its intent, its commitment lapsed + r <- paidIn ctx aliceOrder $ \o -> (openPhase o) {nrPhase = PQueued, nrReveal = Just reveal} + answerCommitment w r (orderSeconds - maxAge - 1) + void $ steps w r >>= awaiting + x <- stored ctx r + commitTx <- newestHash w + (nrPhase x, nrReveal x, nrRevealAfter x, nrRevealBefore x, nrCommitTx x, nrVersion x) `shouldBe` (PCommitting, Nothing, Nothing, Nothing, Just commitTx, nrVersion r + 2) + -- requeued with its intent while a third party's commit of the commitment is live: not ours, so the intent goes + r2 <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} $ \o -> (openPhase o) {nrPhase = PQueued, nrReveal = Just reveal} + answerCommitment w r2 (orderSeconds - 60) + steps w r2 >>= waitingUntil >>= (`shouldBe` at (orderSeconds - 60 + maxAge + 1)) + x2 <- stored ctx r2 + (nrPhase x2, nrReveal x2, nrCommitTx x2, nrRevealBefore x2) `shouldBe` (PCommitted, Nothing, Nothing, Just (orderSeconds - 60 + maxAge)) + length <$> sent w `shouldReturn` 1 + +testFeeAboveCap :: IO () +testFeeAboveCap = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + r <- paidIn ctx aliceOrder id + answerCommitment w r 0 + setFees cNode fakeTip fakeMaxFeePerGas + steps w r >>= retrying + stored ctx r `shouldReturn` r + sent w `shouldReturn` [] + setFees cNode fakeTip fakeBaseFee + void $ steps w r >>= awaiting + nrPhase <$> stored ctx r `shouldReturn` PCommitting + +testLostRace :: IO () +testLostRace = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}, wWorker} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + answerAvailable w False + dryRunsRevert w "NameNotAvailable(string)" $ abiTuple [Dynamic $ abiBytes "alicebakery"] + -- held at the register check's ownerOf read, after the registration was read + (stepping, gate) <- pausedAt cNode "eth_call" $ stepRegistration wWorker (nrId r) + changed <- rewrite ctx r $ \o -> o {nrRevealAfter = (+ 1) <$> nrRevealAfter o} + releaseGate gate + timeout prompt (wait stepping) >>= maybe (fail "the step did not finish") (pure . shape) >>= (`shouldBe` "Again") + stored ctx r `shouldReturn` changed + -- held at the commitment's read, a fresh worker's first chain read + r2 <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} id + answerCommitment w r2 $ orderSeconds - 60 + W {wWorker = fresh} <- started ctx + (stepping', gate') <- pausedAt cNode "eth_call" $ stepRegistration fresh (nrId r2) + changed' <- rewrite ctx r2 $ \o -> o {nrError = Just "changed"} + releaseGate gate' + timeout prompt (wait stepping') >>= maybe (fail "the step did not finish") (pure . shape) >>= (`shouldBe` "Again") + stored ctx r2 `shouldReturn` changed' + +testInNameTurn :: IO () +testInNameTurn = withWorker $ \w@W {wCtx = ctx@Ctx {cOrders}} -> do + r <- paidIn ctx aliceOrder committedPhase + advance ctx $ day + 1 + holding <- newEmptyMVar + release <- newEmptyMVar + withAsync (withLabelTurn (oeTurns cOrders) (nrLabelHash r) $ putMVar holding () >> takeMVar release) $ \_ -> do + takeMVar holding + withAsync (steps w r) $ \stepping -> do + -- the lapse's write waits for the turn the holder has + timeout prompt (atomically $ labelTurnCount (oeTurns cOrders) (nrLabelHash r) >>= check . (== 2)) >>= maybe (fail "the worker did not queue on the turn") pure + stored ctx r `shouldReturn` r + putMVar release () + timeout prompt (wait stepping) >>= maybe (fail "the step did not finish") done + nrPhase <$> stored ctx r `shouldReturn` PFailed + +testTwoWallets :: IO () +testTwoWallets = withWorker $ \w@W {wCtx = ctx} -> do + a <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + b <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} openPhase >>= revealed ctx keyB "alicebakery" + answerExpiry ctx "alicebakery" expiry + void $ steps w a >>= awaiting + void $ mineNewest w True + steps w a >>= done + nrPhase <$> stored ctx a `shouldReturn` PRegistered + answerOwner ctx "alicebakery" (nrOwner a) + answerAvailable w False + dryRunsRevert w "NameNotAvailable(string)" $ abiTuple [Dynamic $ abiBytes "alicebakery"] + published w b (steps w b) >>= done + x <- stored ctx b + (nrPhase x, nrLive x, nrPrice x, nrPayment x, nrError x) `shouldBe` (PTaken, False, nrPrice b, nrPayment b, Nothing) + length <$> sent w `shouldReturn` 1 + +testPendingCompetitor :: IO () +testPendingCompetitor = withWorker $ \w@W {wCtx = ctx} -> do + (r, code) <- codeIn ctx 8 aliceOrder openPhase >>= traverseFst (revealed ctx keyA "alicebakery") + -- a competitor's register in the node's pending block, never mined + answerAvailable w True + dryRunsRevert w "NameNotAvailable(string)" $ abiTuple [Dynamic $ abiBytes "alicebakery"] + steps w r >>= retrying + stored ctx r `shouldReturn` r + pcReservedBy <$> codeOf ctx code `shouldReturn` Just (nrId r) + -- the competitor's register dropped + dryRunsPass w + void $ steps w r >>= awaiting + nrPhase <$> stored ctx r `shouldReturn` PRegistering + +testRevertTaken :: IO () +testRevertTaken = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + (r, code) <- codeIn ctx 8 aliceOrder openPhase >>= traverseFst (revealed ctx keyA "alicebakery") + answerAvailable w False + -- a reason kept in the message without data: not one of the contracts' errors + setFault cNode "eth_estimateGas" $ RpcError 3 "execution reverted: ERC721: invalid token ID" Nothing + published w r (steps w r) >>= done + x <- stored ctx r + (nrPhase x, nrLive x) `shouldBe` (PTaken, False) + PrepaidCode {pcReservedBy, pcSpentAt} <- codeOf ctx code + (pcReservedBy, pcSpentAt) `shouldBe` (Nothing, Nothing) + sent w `shouldReturn` [] + +testRevertFailed :: IO () +testRevertFailed = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + (r, code) <- codeIn ctx 8 aliceOrder openPhase >>= traverseFst (revealed ctx keyA "alicebakery") + answerAvailable w True + -- viem's encodeErrorResult of InsufficientAllowance(10000, 2500) + setFault cNode "eth_estimateGas" $ revertFault $ unhex "2a1b2dd8000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000009c4" + logs <- capturingStderr $ steps w r >>= done + logs `shouldSatisfy` T.isInfixOf "setRegistrarAllowance" + now <- nowOf ctx + x <- stored ctx r + (nrPhase x, nrFailedAt x, nrError x, nrLive x) `shouldBe` (PFailed, Just now, Just "The name could not be registered", True) + pcReservedBy <$> codeOf ctx code `shouldReturn` Just (nrId r) + -- a revert without data while the name is available fails a paid order too + p <- paidIn ctx dynamisOrder openPhase >>= revealed ctx keyA "dynamis" + answerCall cNode fakeController (selector "available(string)" <> abiTuple [Dynamic $ abiBytes "dynamis"]) $ Returns $ uint256 (1 :: Int) + answerUnowned ctx "dynamis" + setFault cNode "eth_estimateGas" $ RpcError (-32000) "execution reverted" Nothing + steps w p >>= done + nrPhase <$> stored ctx p `shouldReturn` PFailed + sent w `shouldReturn` [] + +testInvalidNonce :: IO () +testInvalidNonce = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + dryRunsRevert w "InvalidNonce()" "" + published w r (steps w r >>= waitingUntil) `shouldReturn` at (orderSeconds - minAge + maxAge + 1) + x <- stored ctx r + (nrPhase x, nrReveal x, nrVersion x, nrRevealBefore x) `shouldBe` (PCommitted, Nothing, nrVersion r + 1, nrRevealBefore r) + sent w `shouldReturn` [] + +testCheckUnread :: IO () +testCheckUnread = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + setFault cNode "eth_estimateGas" $ RpcError (-32000) "execution reverted" Nothing + -- no answer for available(label) + steps w r >>= retrying + stored ctx r `shouldReturn` r + -- ownerOf reverting with data is a failed read, not an unowned name + answerAvailable w False + answerCall cNode (registrarOf cNode) (ownerOfSelector <> labelBytes "alicebakery") $ Reverts $ unhex "37ed32e8" + steps w r >>= retrying + stored ctx r `shouldReturn` r + sent w `shouldReturn` [] + +testCommitmentTooNew :: IO () +testCommitmentTooNew = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + answerAvailable w True + -- the node's latest block still before revealAfter + dryRunsRevert w "CommitmentTooNew(bytes32,uint256,uint256)" $ nrCommitment r <> uint256 (orderSeconds - minAge) <> uint256 orderSeconds + steps w r >>= waitingUntil >>= (`shouldBe` addUTCTime 1 orderTime) + stored ctx r `shouldReturn` r + sent w `shouldReturn` [] + +testMinedRevertTaken :: IO () +testMinedRevertTaken = withWorker $ \w@W {wCtx = ctx} -> do + (r, code) <- codeIn ctx 8 aliceOrder openPhase >>= traverseFst (revealed ctx keyA "alicebakery") + answerAvailable w True + void $ steps w r >>= awaiting + -- another register for the name mined first + answerAvailable w False + void $ mineNewest w False + steps w r >>= done + x <- stored ctx r + (nrPhase x, nrLive x) `shouldBe` (PTaken, False) + pcReservedBy <$> codeOf ctx code `shouldReturn` Nothing + +testExpiredIntent :: IO () +testExpiredIntent = withWorker $ \w@W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder (\o -> (openPhase o) {nrRevealBefore = Just (rvDeadline reveal)}) >>= revealed ctx keyA "alicebakery" + answerAvailable w True + advance ctx $ fromIntegral (rvDeadline reveal - orderSeconds) + 1 + logs <- capturingStderr $ steps w r >>= done + let RegistrationId rid = nrId r + logs `shouldSatisfy` T.isInfixOf ("registration " <> rid <> ": its stored intent is refused, intent expired") + nrPhase <$> stored ctx r `shouldReturn` PFailed + sent w `shouldReturn` [] + +testFailedOnlySettled :: IO () +testFailedOnlySettled = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}, wSender} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + r2 <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} (\o -> (openPhase o) {nrRevealBefore = Just (orderSeconds + 3 * 86400)}) >>= revealed ctx keyB "alicebakery" + answerAvailable w True + p <- steps w r >>= awaiting + -- past revealBefore, the register in flight can still be mined + advance ctx $ 2 * day + steps w r >>= awaiting >>= (`shouldBe` ptHash p) . ptHash + nrPhase <$> stored ctx r `shouldReturn` PRegistering + void $ mineNewest w False + steps w r >>= done + nrPhase <$> stored ctx r `shouldReturn` PFailed + -- a register whose nonce another transaction took, while the owner holds the name: it went through + p2 <- steps w r2 >>= awaiting + useNextNonce cNode + followTransactions wSender + steps w r2 >>= awaiting >>= (`shouldBe` ptHash p2) . ptHash + replicateM_ 2 $ mine cNode [] + followTransactions wSender + answerOwner ctx "alicebakery" (nrOwner r2) + answerExpiry ctx "alicebakery" expiry + steps w r2 >>= done + -- judged from chain state with no hash known to have mined: no register transaction (contract section 6) + x2 <- stored ctx r2 + (nrPhase x2, nrExpiresAt x2, nrRegisterTx x2, nrRegisterBlock x2) `shouldBe` (PRegistered, Just expiry, Nothing, Nothing) + +testLapseFailed :: IO () +testLapseFailed = withWorker $ \w@W {wCtx = ctx} -> do + (r, code) <- codeIn ctx 8 aliceOrder committedPhase + steps w r >>= waitingUntil >>= (`shouldBe` at (orderSeconds + maxAge + 1)) + advance ctx $ day + 1 + published w r (steps w r) >>= done + now <- nowOf ctx + x <- stored ctx r + (nrPhase x, nrFailedAt x, nrError x, nrLive x) `shouldBe` (PFailed, Just now, Just "The name was not signed in time", True) + pcReservedBy <$> codeOf ctx code `shouldReturn` Just (nrId r) + +testLapsePoll :: IO () +testLapsePoll = withWorker $ \w@W {wCtx = ctx@Ctx {cClient}} -> do + r <- paidIn ctx aliceOrder committedPhase + advance ctx $ day + 1 + let path = registrationPath (nrId r) <> "?seenVersion=" <> show (nrVersion r) + -- the lapse alone changes no version, so a poll with the version seen before it is held + poll <- held ctx (0, 1) path + steps w r >>= done + (status, view) <- woken "the poll held at the lapse" poll + (status, field "version" view, field "phase" view) `shouldBe` (200, Just (J.toJSON $ nrVersion r + 1), Just "failed") + -- prompt is far below the 30-second hold + (status', view') <- timeout prompt (webGet cClient path >>= \resp -> (statusOf resp,) <$> jsonObject resp) >>= maybe (fail "the old version was held") pure + (status', field "phase" view') `shouldBe` (200, Just "failed") + +testRestart :: IO () +testRestart = withWorker $ \w@W {wCtx = ctx@Ctx {cStore}, wSender} -> do + (r, code) <- codeIn ctx 8 aliceOrder id + answerExpiry ctx "alicebakery" expiry + answerCommitment w r 0 + -- the commit saved and sent, the service stopped before recording committing + Right p <- submitTransaction wSender (TxCommit $ nrId r) fakeController (commitCalldata $ nrCommitment r) + w1 <- started ctx + steps w1 r >>= awaiting >>= (`shouldBe` ptHash p) . ptHash + x <- stored ctx r + (nrPhase x, nrCommitTx x) `shouldBe` (PCommitting, Just (ptHash p)) + length <$> sent w `shouldReturn` 1 + commitBlock <- mineNewest w1 True + t <- blockTime w1 commitBlock + answerCommitment w r t + w2 <- started ctx + void $ steps w2 r >>= waitingUntil + nrPhase <$> stored ctx r `shouldReturn` PCommitted + void $ revealed ctx keyA "alicebakery" r + advance ctx $ fromIntegral (t + minAge) - fromIntegral orderSeconds + register <- steps w2 r >>= awaiting + w3 <- started ctx + steps w3 r >>= awaiting >>= (`shouldBe` ptHash register) . ptHash + nrPhase <$> stored ctx r `shouldReturn` PRegistering + void $ mineNewest w3 True + w4 <- started ctx + steps w4 r >>= done + nrPhase <$> stored ctx r `shouldReturn` PRegistered + isJust . pcSpentAt <$> codeOf ctx code `shouldReturn` True + map ntStatus <$> withTransaction cStore (`registrationTransactions` nrId r) `shouldReturn` [TSMined, TSMined] + length <$> sent w `shouldReturn` 2 + +testRestartRegisterSaved :: IO () +testRestartRegisterSaved = withWorker $ \w@W {wCtx = ctx@Ctx {cOrders}, wSender} -> do + r <- paidIn ctx aliceOrder openPhase >>= revealed ctx keyA "alicebakery" + rv <- maybe (fail "no reveal") pure $ nrReveal r + -- the register saved and sent, the service stopped before recording registering + Right p <- submitTransaction wSender (TxRegister $ nrId r) fakeSponsor (registerWithCreditCalldata $ intentOf (oeConfig cOrders) r rv) + w1 <- started ctx + steps w1 r >>= awaiting >>= (`shouldBe` ptHash p) . ptHash + x <- stored ctx r + (nrPhase x, nrRegisterTx x) `shouldBe` (PRegistering, Just (ptHash p)) + steps w1 r >>= awaiting >>= (`shouldBe` ptHash p) . ptHash + length <$> sent w `shouldReturn` 1 + +testRunWorkers :: IO () +testRunWorkers = withWorker $ \w@W {wCtx = ctx@Ctx {cNode, cOrders}, wWorker} -> do + r <- paidIn ctx aliceOrder id + (unpaid, _) <- placed ctx (byB aliceOrder) {oCommitment = commitmentOf 2} + answerCommitment w r 0 + withAsync (runWorkers wWorker) $ \_ -> do + timeout prompt (awaitSent cNode 1) >>= maybe (fail "no commit was sent") (const $ pure ()) + changed <- awaitChange (oePhases cOrders) (nrId r) (nrVersion <$> stored ctx r) (nrVersion r) prompt + changed `shouldBe` True + nrPhase <$> stored ctx r `shouldReturn` PCommitting + nrPhase <$> invoiceRegistration ctx unpaid `shouldReturn` PUnpaid + length <$> sent w `shouldReturn` 1 + +testCodeSweep :: IO () +testCodeSweep = withWorker $ \W {wCtx = ctx, wWorker} -> do + (old, oldCode) <- codeIn ctx 8 aliceOrder failedPhase + (recent, recentCode) <- codeIn ctx 7 dynamisOrder $ \x -> (failedPhase x) {nrFailedAt = Just $ addUTCTime (2 * day) orderTime} + -- failed long ago, then requeued by Try again + (requeued, requeuedCode) <- codeIn ctx 8 (byB aliceOrder) {oCommitment = commitmentOf 2} $ \x -> (failedPhase x) {nrPhase = PQueued} + advance ctx $ 31 * day + sweepFailedCodes wWorker + map pcReservedBy <$> mapM (codeOf ctx) [oldCode, recentCode, requeuedCode] `shouldReturn` [Nothing, Just (nrId recent), Just (nrId requeued)] + mapM (stored ctx) [old, recent, requeued] `shouldReturn` [old, recent, requeued] + +testLandedAtDepth :: IO () +testLandedAtDepth = withOrders $ \ctx@Ctx {cNode, cOrders} -> do + r <- paidIn ctx aliceOrder failedPhase + answerUnowned ctx "alicebakery" + answerExpiry ctx "alicebakery" expiry + -- the owner's own register, mined in the latest block + latest <- mine cNode [] + answerCallFrom cNode latest (registrarOf cNode) (ownerOfSelector <> labelBytes "alicebakery") $ Returns $ addressWord $ nrOwner r + confirmLanded cOrders r `shouldReturn` LNotLanded + stored ctx r `shouldReturn` r + -- confirmations 3: two more blocks put it at the depth + replicateM_ 2 $ mine cNode [] + confirmLanded cOrders r `shouldReturn` LRegistered (nrVersion r + 1) + x <- stored ctx r + (nrPhase x, nrExpiresAt x, nrRegisterTx x) `shouldBe` (PRegistered, Just expiry, Nothing) + +testOutcomeBound :: IO () +testOutcomeBound = withOrders $ \ctx@Ctx {cNode, cStore, cRandom, cClock} -> do + r@NameRegistration {nrId, nrCommitment} <- paidIn ctx aliceOrder id + chain <- newChainClient cRandom $ fakeChainConfig cNode + sender <- newSender cRandom chain cStore (readIORef cClock) + Right p <- submitTransaction sender (TxCommit nrId) fakeController (commitCalldata nrCommitment) + timeout prompt (awaitOutcome shortWait p) `shouldReturn` Just Nothing + let TxHash h = ptHash p + block <- mine cNode [(h, True)] + replicateM_ 2 $ mine cNode [] + followTransactions sender + awaitOutcome shortWait p `shouldReturn` Just (TOConfirmed (ptHash p) Receipt {receiptSuccess = True, receiptBlock = block}) + stored ctx r `shouldReturn` r + where + shortWait = 300000 + +-- retry + +retryOf :: Ctx -> NameRegistration -> IO (Int, Maybe J.Object) +retryOf ctx NameRegistration {nrId} = post ctx (registrationPath nrId <> "/retry") "" + +-- | The view of an accepted Try again, failing the test otherwise. +retried :: Ctx -> NameRegistration -> IO J.Object +retried ctx r = + retryOf ctx r >>= \case + (200, Just v) -> pure v + other -> fail $ "retry refused: " <> show other + +viewOf :: Ctx -> NameRegistration -> IO J.Object +viewOf Ctx {cClient} NameRegistration {nrId} = webGet cClient (registrationPath nrId) >>= jsonObject + +answerNonce :: W -> Word64 -> IO () +answerNonce W {wCtx = Ctx {cNode}} n = answerCall cNode fakeSponsor noncesCall $ Returns $ uint256 n + +txJSON :: Maybe TxHash -> Maybe J.Value +txJSON = Just . maybe J.Null (\(TxHash h) -> J.String $ hex h) + +-- | Committed by the worker's own commit; its block's time. +committedByUs :: W -> NameRegistration -> IO (NameRegistration, Word64) +committedByUs w@W {wCtx = ctx} r = do + answerCommitment w r 0 + void $ steps w r >>= awaiting + t <- mineNewest w True >>= blockTime w + answerCommitment w r t + void $ steps w r >>= waitingUntil + (,t) <$> stored ctx r + +-- | Failed after its register reverted, with the intent the page signed for the commit's window. +failedAfterRegister :: W -> NameRegistration -> IO NameRegistration +failedAfterRegister W {wCtx = ctx} r = do + rv <- signedReveal ctx keyA reveal {rvDeadline = fromJust $ nrRevealBefore r} r + h <- sentRegister ctx r 2 TSReverted + rewrite ctx r $ \o -> (failedPhase o) {nrReveal = Just rv, nrRegisterTx = Just h, nrRegisterBlock = Just 120} + +testRetryNotFailed :: IO () +testRetryNotFailed = withWorker $ \W {wCtx = ctx} -> do + queued <- paidIn ctx aliceOrder id + committed <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} committedPhase + registeredOrder <- paidIn ctx dynamisOrder $ \o -> o {nrPhase = PRegistered, nrExpiresAt = Just expiry} + taken <- paidIn ctx (byB dynamisOrder) {oCommitment = commitmentOf 4} $ \o -> o {nrPhase = PTaken} + forM_ [queued, committed, registeredOrder, taken] $ \r -> do + (nrPhase r,) <$> retryOf ctx r `shouldReturn` (nrPhase r, refusedWith 400 "bad_request") + stored ctx r `shouldReturn` r + retryOf ctx queued {nrId = RegistrationId "t2Jk8RmQ4vXw9NcP3yLb6g"} `shouldReturn` refusedWith 404 "not_found" + +testRetryLinksRefused :: IO () +testRetryLinksRefused = withWorker $ \W {wCtx = ctx} -> do + r <- paidIn ctx aliceOrder $ \o -> (failedPhase o) {nrLinksRefusedAt = Just orderTime} + -- unowned with no reveal stored, so only its refused links keep it from being queued again + answerUnowned ctx "alicebakery" + retryOf ctx r `shouldReturn` refusedWith 400 "bad_request" + stored ctx r `shouldReturn` r + +testRetryLanded :: IO () +testRetryLanded = withWorker $ \W {wCtx = ctx} -> do + -- redeemed since its register mined: the name left the owner, and the register consumed its commitment + (redeemed, code) <- codeIn ctx 8 aliceOrder failedPhase + TxHash minedHash <- sentRegister ctx redeemed 1 TSMined + answerExpiry ctx "alicebakery" expiry + v <- retried ctx redeemed + (field "phase" v, field "registerTx" v, field "expiresAt" v, field "error" v) `shouldBe` (Just "registered", Just (J.String $ hex minedHash), Just (J.toJSON expiry), Just J.Null) + x <- stored ctx redeemed + (nrPhase x, nrVersion x, nrFailedAt x, nrLive x) `shouldBe` (PRegistered, nrVersion redeemed + 1, Nothing, False) + isJust . pcSpentAt <$> codeOf ctx code `shouldReturn` True + -- no register known to have mined: judged by ownerOf, none is shown + owned <- paidIn ctx dynamisOrder failedPhase + answerOwner ctx "dynamis" (nrOwner owned) + answerExpiry ctx "dynamis" expiry + v' <- retried ctx owned + (field "phase" v', field "registerTx" v', field "expiresAt" v') `shouldBe` (Just "registered", Just J.Null, Just (J.toJSON expiry)) + +testRetryUnread :: IO () +testRetryUnread = withWorker $ \w@W {wCtx = ctx@Ctx {cNode}} -> do + r <- paidIn ctx aliceOrder failedPhase + -- a revert with data is a failed read, not an unowned name + answerCall cNode (registrarOf cNode) (ownerOfSelector <> labelBytes "alicebakery") $ Reverts $ unhex "37ed32e8" + retryOf ctx r `shouldReturn` refusedWith 503 "provider_unavailable" + stored ctx r `shouldReturn` r + -- with an intent stored, the sponsor nonce and then the commitment unanswered + p <- paidIn ctx dynamisOrder openPhase >>= revealed ctx keyA "dynamis" >>= \x -> rewrite ctx x failedPhase + answerUnowned ctx "dynamis" + retryOf ctx p `shouldReturn` refusedWith 503 "provider_unavailable" + answerNonce w $ rvNonce reveal + retryOf ctx p `shouldReturn` refusedWith 503 "provider_unavailable" + stored ctx p `shouldReturn` p + +testRetryReleasedCode :: IO () +testRetryReleasedCode = withWorker $ \W {wCtx = ctx@Ctx {cStore}} -> do + spender <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 20} id + holder <- paidIn ctx (byB dynamisOrder) {oCommitment = commitmentOf 21} id + let codeOrder n change = do + let label = "codeorder" <> tshow n + answerFree ctx label + codeIn ctx 8 aliceOrder {oLabel = label, oCommitment = commitmentOf (30 + n)} change + released (r, code) = (r, code) <$ (withTransaction cStore (\db -> releasePrepaidCode db (pcId code) (nrId r)) `shouldReturn` True) + refusals :: [(Text, PrepaidCode -> DB.Connection -> IO (), (Int, Maybe J.Object))] + refusals = + [ ("spent", \PrepaidCode {pcId} db -> reservePrepaidCode db pcId (nrId spender) orderTime >> void (spendPrepaidCode db pcId (nrId spender) orderTime), refusedWith 409 "code_used"), + ("held", \PrepaidCode {pcId} db -> void $ reservePrepaidCode db pcId (nrId holder) orderTime, refusedWith 409 "code_reserved"), + ("revoked", \PrepaidCode {pcCodeHash} db -> void $ revokePrepaidCode db pcCodeHash orderTime, refusedWith 400 "code_invalid"), + ("expired", \PrepaidCode {pcCodeHash} db -> expire db pcCodeHash, refusedWith 409 "code_expired") + ] + expire :: DB.Connection -> ByteString -> IO () + expire db codeHash = DB.execute db "UPDATE sx_badge_service_name_prepaid_codes SET expires_at = ? WHERE code_hash = ?" (orderTime, DB.Binary codeHash) + forM_ (zip [1 :: Int ..] refusals) $ \(n, (what, change, refusal)) -> do + (r, code) <- codeOrder n failedPhase >>= released + withTransaction cStore $ change code + (what,) <$> retryOf ctx r `shouldReturn` (what, refusal) + stored ctx r `shouldReturn` r + -- with an intent stored and the sponsor nonce unanswered, the code's error still comes first + (withIntent, spentCode) <- codeOrder 5 openPhase >>= traverseFst (revealed ctx keyA "codeorder5") >>= traverseFst (\x -> rewrite ctx x failedPhase) >>= released + -- a registration holds one code at most + answerFree ctx "anotherpays" + spender' <- paidIn ctx (byB aliceOrder) {oLabel = "anotherpays", oCommitment = commitmentOf 22} id + withTransaction cStore $ \db -> reservePrepaidCode db (pcId spentCode) (nrId spender') orderTime >> void (spendPrepaidCode db (pcId spentCode) (nrId spender') orderTime) + retryOf ctx withIntent `shouldReturn` refusedWith 409 "code_used" + -- a code its order still holds stays good for it, though revoked and expired since + (holding, heldCode@PrepaidCode {pcCodeHash}) <- codeOrder 6 failedPhase + withTransaction cStore $ \db -> revokePrepaidCode db pcCodeHash orderTime >> expire db pcCodeHash + field "phase" <$> retried ctx holding `shouldReturn` Just "queued" + pcReservedBy <$> codeOf ctx heldCode `shouldReturn` Just (nrId holding) + -- a released code still unused is reserved again + (unused, unusedCode) <- codeOrder 7 failedPhase >>= released + field "phase" <$> retried ctx unused `shouldReturn` Just "queued" + (pcReservedBy &&& pcSpentAt) <$> codeOf ctx unusedCode `shouldReturn` (Just (nrId unused), Nothing) + +testRetryRequeue :: IO () +testRetryRequeue = withWorker $ \w@W {wCtx = ctx} -> do + committed <- paidIn ctx aliceOrder openPhase + h <- sentRegister ctx committed 1 TSReverted + r <- rewrite ctx committed $ \o -> (failedPhase o) {nrRegisterTx = Just h, nrRegisterBlock = Just 120} + v <- published w r $ retried ctx r + (field "phase" v, field "registerTx" v, field "error" v, field "version" v) `shouldBe` (Just "queued", Just J.Null, Just J.Null, Just (J.toJSON $ nrVersion r + 1)) + x <- stored ctx r + (nrPhase x, nrFailedAt x, nrError x, nrRegisterTx x, nrRegisterBlock x, nrLive x) `shouldBe` (PQueued, Nothing, Nothing, Nothing, Nothing, True) + (nrCommitTx x, nrCommitBlock x, nrRevealAfter x, nrRevealBefore x) `shouldBe` (nrCommitTx r, nrCommitBlock r, nrRevealAfter r, nrRevealBefore r) + +testRetryLiveCommitment :: IO () +testRetryLiveCommitment = withWorker $ \w@W {wCtx = ctx} -> do + (r, t) <- paidIn ctx aliceOrder id >>= committedByUs w + f <- failedAfterRegister w r + answerNonce w $ rvNonce reveal + v <- retried ctx f + (field "phase" v, field "label" v) `shouldBe` (Just "queued", Just "alicebakery") + steps w f >>= waitingUntil >>= (`shouldBe` at (t + minAge)) + x <- stored ctx f + (nrPhase x, nrReveal x, nrCommitTx x, nrCommitBlock x, nrRevealBefore x) `shouldBe` (PCommitted, nrReveal f, nrCommitTx f, nrCommitBlock f, Just (t + maxAge)) + length <$> sent w `shouldReturn` 1 + +testRetryNonceMoved :: IO () +testRetryNonceMoved = withWorker $ \w@W {wCtx = ctx} -> do + (r, t) <- paidIn ctx aliceOrder id >>= committedByUs w + f <- failedAfterRegister w r + answerNonce w $ rvNonce reveal + 1 + v <- retried ctx f + (field "phase" v, field "label" v, field "commitTx" v) `shouldBe` (Just "queued", Just J.Null, txJSON (nrCommitTx f)) + nrReveal <$> stored ctx f `shouldReturn` Nothing + steps w f >>= waitingUntil >>= (`shouldBe` at (t + maxAge + 1)) + x <- stored ctx f + (nrPhase x, nrReveal x, nrCommitTx x, nrCommitBlock x, nrRevealBefore x) `shouldBe` (PCommitted, Nothing, nrCommitTx f, nrCommitBlock f, Just (t + maxAge)) + field "commitTx" <$> viewOf ctx f `shouldReturn` txJSON (nrCommitTx f) + +testRetryRefusedIntent :: IO () +testRetryRefusedIntent = withWorker $ \w@W {wCtx = ctx} -> do + (r, _) <- paidIn ctx aliceOrder id >>= committedByUs w + f <- failedAfterRegister w r + -- not signed by the owner, as the worker's check reads an intent after a change of the [chain] settings + rv <- signedReveal ctx keyB reveal {rvDeadline = fromJust $ nrRevealBefore r} r + f' <- rewrite ctx f $ \o -> o {nrReveal = Just rv} + answerNonce w $ rvNonce reveal + v <- retried ctx f' + (field "phase" v, field "label" v) `shouldBe` (Just "queued", Just J.Null) + nrReveal <$> stored ctx f' `shouldReturn` Nothing + +testRetryThirdParty :: IO () +testRetryThirdParty = withWorker $ \w@W {wCtx = ctx} -> do + (r, t) <- paidIn ctx aliceOrder id >>= committedByUs w + f <- failedAfterRegister w r + answerNonce w $ rvNonce reveal + -- our commitment lapsed, and someone committed it again + let t' = t + maxAge + 100 + answerCommitment w f t' + advance ctx $ fromIntegral (t' + 10 - orderSeconds) + v <- retried ctx f + (field "label" v, field "commitTx" v) `shouldBe` (Just J.Null, txJSON (nrCommitTx f)) + steps w f >>= waitingUntil >>= (`shouldBe` at (t' + maxAge + 1)) + x <- stored ctx f + (nrPhase x, nrReveal x, nrCommitTx x, nrCommitBlock x, nrRevealBefore x) `shouldBe` (PCommitted, Nothing, Nothing, Nothing, Just (t' + maxAge)) + field "commitTx" <$> viewOf ctx f `shouldReturn` Just J.Null + length <$> sent w `shouldReturn` 1 + +testRetryMargin :: IO () +testRetryMargin = withWorker $ \w@W {wCtx = ctx} -> do + (r, t) <- paidIn ctx aliceOrder id >>= committedByUs w + f <- failedAfterRegister w r + answerNonce w $ rvNonce reveal + let lapse = t + maxAge + advance ctx $ fromIntegral (lapse - 600 - orderSeconds) + field "label" <$> retried ctx f `shouldReturn` Just J.Null + steps w f >>= waitingUntil >>= (`shouldBe` at (lapse + 1)) + advance ctx 601 + void $ steps w f >>= awaiting + commitTx <- newestHash w + x <- stored ctx f + (nrPhase x, nrReveal x, nrCommitTx x, nrRevealBefore x) `shouldBe` (PCommitting, Nothing, Just commitTx, Nothing) + length <$> sent w `shouldReturn` 2 + +testRetryLapsed :: IO () +testRetryLapsed = withWorker $ \w@W {wCtx = ctx@Ctx {cClient}} -> do + (r, code) <- codeIn ctx 8 aliceOrder committedPhase + advance ctx $ day + 1 + -- the lapse alone changes no version, so a poll with the version seen before it is held + let path = registrationPath (nrId r) <> "?seenVersion=" <> show (nrVersion r) + poll <- held ctx (0, 1) path + v <- retried ctx r + (field "phase" v, field "version" v, field "error" v) `shouldBe` (Just "queued", Just (J.toJSON $ nrVersion r + 1), Just J.Null) + (status, view) <- woken "the poll held at the lapse" poll + (status, field "phase" view) `shouldBe` (200, Just "queued") + -- prompt is far below the 30-second hold + (status', view') <- timeout prompt (webGet cClient path >>= \resp -> (statusOf resp,) <$> jsonObject resp) >>= maybe (fail "the old version was held") pure + (status', field "version" view') `shouldBe` (200, Just (J.toJSON $ nrVersion r + 1)) + pcReservedBy <$> codeOf ctx code `shouldReturn` Just (nrId r) + -- the commitment lapsed, so the worker commits it again + answerCommitment w r $ fromJust (nrRevealBefore r) - maxAge + void $ steps w r >>= awaiting + nrPhase <$> stored ctx r `shouldReturn` PCommitting + +testRetryLostRace :: IO () +testRetryLostRace = withWorker $ \W {wCtx = ctx@Ctx {cNode}} -> do + r <- paidIn ctx aliceOrder failedPhase + -- held at the register check's ownerOf read, in the name's turn + (retrying', gate) <- pausedAt cNode "eth_call" $ retryOf ctx r + changed <- rewrite ctx r id + releaseGate gate + answer <- timeout prompt (wait retrying') >>= maybe (fail "the retry did not finish") pure + view <- viewOf ctx r + answer `shouldBe` (409, Just $ KM.fromList [("error", "registration_changed"), ("registration", J.Object view)]) + field "version" view `shouldBe` Just (J.toJSON $ nrVersion r + 1) + stored ctx r `shouldReturn` changed + +testRetryInNameTurn :: IO () +testRetryInNameTurn = withWorker $ \W {wCtx = ctx@Ctx {cOrders}} -> do + r <- paidIn ctx aliceOrder failedPhase + moving <- paidIn ctx (byB aliceOrder) {oCommitment = commitmentOf 2} failedPhase + answerUnowned ctx "dynamis" + let turns = oeTurns cOrders + whileHeld :: IO a -> IO () -> IO a + whileHeld request meanwhile = do + holding <- newEmptyMVar + release <- newEmptyMVar + withAsync (withLabelTurn turns (nrLabelHash r) $ putMVar holding () >> takeMVar release) $ \_ -> do + takeMVar holding + withAsync request $ \requesting -> do + timeout prompt (atomically $ labelTurnCount turns (nrLabelHash r) >>= check . (== 2)) >>= maybe (fail "the retry did not queue on the turn") pure + meanwhile + putMVar release () + timeout prompt (wait requesting) >>= maybe (fail "the retry did not finish") pure + (status, v) <- whileHeld (retryOf ctx r) (stored ctx r `shouldReturn` r) + (status, field "phase" =<< v) `shouldBe` (200, Just "queued") + -- moved to another name while the retry waited for the old name's turn + (status', v') <- whileHeld (retryOf ctx moving) (void $ rewrite ctx moving $ \o -> o {nrLabelHash = labelHash "dynamis", nrLength = 7}) + (status', field "error" =<< v') `shouldBe` (409, Just "registration_changed") + nrPhase <$> stored ctx moving `shouldReturn` PFailed + +testRetryLimit :: IO () +testRetryLimit = withWorker $ \W {wCtx = ctx@Ctx {cClient}} -> do + r <- paidIn ctx aliceOrder id + let fromClient = statusOf <$> webRequestBody cClient "POST" (registrationPath (nrId r) <> "/retry") [("X-Forwarded-For", "203.0.113.8")] "" + replicateM 5 fromClient `shouldReturn` replicate 5 400 + fromClient `shouldReturn` 429