diff --git a/apps/simplex-store-service/src/StoreService/Names/Abi.hs b/apps/simplex-store-service/src/StoreService/Names/Abi.hs index 1fdb733926..51ed93b362 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Abi.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Abi.hs @@ -3,50 +3,127 @@ module StoreService.Names.Abi ( AbiValue (..), + AbiError (..), abiTuple, abiBytes, abiArray, uint256, addressWord, + addressFromBytes, selector, hex, + decodeUint256, + decodeWord64, + decodeAddress, + decodeBool, + decodeString, ) where -import Crypto.Number.Serialize (i2ospOf_) +import Control.Monad (unless) +import Crypto.Number.Serialize (i2ospOf_, os2ip) +import Data.Bifunctor (first) import Data.ByteArray.Encoding (Base (Base16), convertToBase) import Data.ByteString (ByteString) import qualified Data.ByteString as B import Data.List (mapAccumL) import Data.Text (Text) -import Data.Text.Encoding (decodeLatin1) +import Data.Text.Encoding (decodeLatin1, decodeUtf8') +import Data.Word (Word64) import Simplex.Messaging.Crypto (keccak256) +import Simplex.Messaging.Encoding.String (strDecode) import Simplex.Messaging.Eth.Address (Address, unAddress) data AbiValue = Static ByteString | Dynamic ByteString +data AbiError + = AEShort + | AEOffset + | AENotAddress + | AENotBool + | AENotUtf8 + | AERange + deriving (Eq, Show) + +abiWordSize :: Int +abiWordSize = 32 + +addressPadding :: Int +addressPadding = 12 + abiTuple :: [AbiValue] -> ByteString abiTuple values = B.concat heads <> B.concat [tl | Dynamic tl <- values] where - heads = snd $ mapAccumL encodeHead (32 * length values) values + heads = snd $ mapAccumL encodeHead (abiWordSize * length values) values encodeHead offset = \case Static w -> (offset, w) Dynamic tl -> (offset + B.length tl, uint256 offset) abiBytes :: ByteString -> ByteString -abiBytes bs = uint256 (B.length bs) <> bs <> B.replicate (negate (B.length bs) `mod` 32) 0 +abiBytes bs = uint256 (B.length bs) <> bs <> B.replicate (negate (B.length bs) `mod` abiWordSize) 0 abiArray :: [ByteString] -> ByteString abiArray items = uint256 (length items) <> abiTuple (map Dynamic items) uint256 :: Integral a => a -> ByteString -uint256 = i2ospOf_ 32 . toInteger +uint256 = i2ospOf_ abiWordSize . toInteger addressWord :: Address -> ByteString -addressWord a = B.replicate 12 0 <> unAddress a +addressWord a = B.replicate addressPadding 0 <> unAddress a selector :: ByteString -> ByteString selector = B.take 4 . keccak256 hex :: ByteString -> Text hex bs = "0x" <> decodeLatin1 (convertToBase Base16 bs) + +decodeUint256 :: ByteString -> Either AbiError Integer +decodeUint256 = uintAt 0 + +decodeWord64 :: ByteString -> Either AbiError Word64 +decodeWord64 ret = do + n <- decodeUint256 ret + if n <= toInteger (maxBound :: Word64) then Right (fromInteger n) else Left AERange + +decodeAddress :: ByteString -> Either AbiError Address +decodeAddress ret = do + (padding, a) <- B.splitAt addressPadding <$> wordAt 0 ret + unless (B.all (== 0) padding) $ Left AENotAddress + maybe (Left AENotAddress) Right $ addressFromBytes a + +-- | Address has no exported constructor; its parser takes lowercase hex without the EIP-55 check. +addressFromBytes :: ByteString -> Maybe Address +addressFromBytes = either (const Nothing) Just . strDecode . convertToBase Base16 + +decodeBool :: ByteString -> Either AbiError Bool +decodeBool ret = + uintAt 0 ret >>= \case + 0 -> Right False + 1 -> Right True + _ -> Left AENotBool + +decodeBytes :: ByteString -> Either AbiError ByteString +decodeBytes ret = offsetAt 0 ret >>= bytesAt ret + +decodeString :: ByteString -> Either AbiError Text +decodeString ret = decodeBytes ret >>= first (const AENotUtf8) . decodeUtf8' + +wordAt :: Int -> ByteString -> Either AbiError ByteString +wordAt o ret + | o + abiWordSize <= B.length ret = Right $ B.take abiWordSize $ B.drop o ret + | otherwise = Left AEShort + +uintAt :: Int -> ByteString -> Either AbiError Integer +uintAt o ret = os2ip <$> wordAt o ret + +-- an offset or a length, never more than the data's size, so it fits an Int +offsetAt :: Int -> ByteString -> Either AbiError Int +offsetAt o ret = do + n <- uintAt o ret + if n <= toInteger (B.length ret) then Right (fromInteger n) else Left AEOffset + +bytesAt :: ByteString -> Int -> Either AbiError ByteString +bytesAt ret o = do + n <- offsetAt o ret + let start = o + abiWordSize + if start + n <= B.length ret then Right $ B.take n $ B.drop start ret else Left AEShort diff --git a/apps/simplex-store-service/src/StoreService/Names/Chain.hs b/apps/simplex-store-service/src/StoreService/Names/Chain.hs index 35cd39974c..51ae815f5f 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Chain.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Chain.hs @@ -1,109 +1,329 @@ +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TupleSections #-} module StoreService.Names.Chain ( ChainClient (..), ChainError (..), TxHash (..), - sendCommit, - sendRegister, + SignedTx (..), + TxRequest (..), + Block (..), + Receipt (..), + TxState (..), + BlockTag (..), + newChainClient, + ethCall, + ethCallAt, + latestBlock, + transactionReceipt, + transactionByHash, + transactionCount, + estimateGas, + maxPriorityFee, + signTransaction, + decodeSignedTx, + sendRawTransaction, + httpFailureDetail, ) where -import StoreService.Names.Registration (RegisterIntent, commitCalldata, registerWithCreditCalldata) import Control.Concurrent.STM (TVar) -import Control.Exception (try) -import Control.Monad.Except (ExceptT, liftEither, runExceptT, throwError) -import Control.Monad.IO.Class (liftIO) +import Control.Exception (evaluate, try) +import Control.Monad ((<=<), (>=>)) +import Crypto.Number.Serialize (os2ip) import Crypto.Random (ChaChaDRG) import Data.Aeson ((.:), (.:?), (.=)) import qualified Data.Aeson as J import qualified Data.Aeson.Types as JT -import Data.ByteArray.Encoding (Base (Base16), convertFromBase, convertToBase) +import Data.ByteArray.Encoding (Base (Base16), convertFromBase) import Data.ByteString (ByteString) +import qualified Data.ByteString as B +import qualified Data.ByteString.Lazy as LB +import Data.List (foldl') import Data.Text (Text) import qualified Data.Text as T import Data.Text.Encoding (decodeLatin1, encodeUtf8) -import Data.Word (Word64) +import Data.Word (Word64, Word8) import Network.HTTP.Client (Manager) import qualified Network.HTTP.Client as HTTP -import Network.HTTP.Types (hContentType, methodPost) -import Numeric (readHex) -import Simplex.Messaging.Crypto.Secp256k1 (Secp256k1PrivateKey) +import Network.HTTP.Client.TLS (newTlsManager) +import Network.HTTP.Types (hContentType, methodPost, statusCode, statusIsSuccessful) +import Numeric (readHex, showHex) +import Simplex.Messaging.Crypto (keccak256) import Simplex.Messaging.Eth.Address (Address, addressFromPrivateKey) +import Simplex.Messaging.Eth.RLP (RLPItem (..)) import Simplex.Messaging.Eth.Transaction (Eip1559Tx (..), signEip1559Tx) -import Simplex.Messaging.Util (liftError', tshow) +import Simplex.Messaging.Util (tshow) +import StoreService.Config (ChainConfig (..)) +import StoreService.Log (logWarn) +import StoreService.Names.Abi (addressFromBytes, hex) +import StoreService.Names.Revert (RevertName (..), decodeRevert) +import System.Timeout (timeout) data ChainClient = ChainClient { ccManager :: Manager, - ccRpcUrl :: String, - ccChainId :: Word64, - ccController :: Address, - ccSponsor :: Address, - ccRegistrarKey :: Secp256k1PrivateKey + ccConfig :: ChainConfig, + ccRegistrar :: Address, + -- | microseconds for a whole call, from the request to the end of its body + ccTimeout :: Int } -newtype ChainError = ChainError Text +-- | 'ChainUnavailable' never holds the RPC URL, which can carry a provider's key. +data ChainError + = ChainReverted (Maybe RevertName) + | ChainUnavailable Text + | ChainGasAboveCap Word64 deriving (Eq, Show) newtype TxHash = TxHash ByteString deriving (Eq, Show) -sendCommit :: TVar ChaChaDRG -> ChainClient -> ByteString -> IO (Either ChainError TxHash) -sendCommit g c@ChainClient {ccController} = sendTransaction g c ccController . commitCalldata +data SignedTx = SignedTx {stRaw :: ByteString, stHash :: TxHash} + deriving (Eq, Show) -sendRegister :: TVar ChaChaDRG -> ChainClient -> RegisterIntent -> IO (Either ChainError TxHash) -sendRegister g c@ChainClient {ccSponsor} = sendTransaction g c ccSponsor . registerWithCreditCalldata +data TxRequest = TxRequest + { trTo :: Address, + trData :: ByteString, + trNonce :: Word64, + trGasLimit :: Word64, + trMaxFeePerGas :: Word64, + trMaxPriorityFeePerGas :: Word64 + } + deriving (Eq, Show) -sendTransaction :: TVar ChaChaDRG -> ChainClient -> Address -> ByteString -> IO (Either ChainError TxHash) -sendTransaction g c@ChainClient {ccChainId, ccRegistrarKey} to calldata = runExceptT $ do - from <- liftIO $ addressFromPrivateKey g ccRegistrarKey - gas <- rpc c "eth_estimateGas" [J.object ["from" .= from, "to" .= to, "data" .= hex calldata], "pending"] quantity - nonce <- rpc c "eth_getTransactionCount" [J.toJSON from, "pending"] quantity - tip <- rpc c "eth_maxPriorityFeePerGas" [] quantity - baseFee <- rpc c "eth_getBlockByNumber" ["latest", J.Bool False] $ J.withObject "block" $ \b -> quantity =<< b .: "baseFeePerGas" - let tx = - Eip1559Tx - { txChainId = ccChainId, - txNonce = nonce, - txMaxPriorityFeePerGas = tip, - txMaxFeePerGas = 2 * baseFee + tip, - txGasLimit = gas, - txTo = to, - txValue = 0, - txData = calldata - } - raw <- liftError' (ChainError . T.pack) $ signEip1559Tx g ccRegistrarKey tx - TxHash <$> rpc c "eth_sendRawTransaction" [J.String $ hex raw] bytes +data Block = Block {blockNumber :: Word64, blockTimestamp :: Word64, blockBaseFee :: Word64} + deriving (Eq, Show) -rpc :: ChainClient -> Text -> [J.Value] -> (J.Value -> JT.Parser a) -> ExceptT ChainError IO a -rpc ChainClient {ccManager, ccRpcUrl} method params parseResult = do - resp <- liftError' (\(e :: HTTP.HttpException) -> ChainError $ tshow e) $ try $ do - req <- HTTP.parseRequest ccRpcUrl - HTTP.httpLbs - req - { HTTP.method = methodPost, - HTTP.redirectCount = 0, - HTTP.requestHeaders = (hContentType, "application/json") : HTTP.requestHeaders req, - HTTP.requestBody = HTTP.RequestBodyLBS body - } - ccManager - either (throwError . ChainError . T.pack) liftEither $ JT.parseEither response =<< J.eitherDecode (HTTP.responseBody resp) +data Receipt = Receipt {receiptSuccess :: Bool, receiptBlock :: Word64} + deriving (Eq, Show) + +data TxState = TxPending | TxMined Word64 + deriving (Eq, Show) + +data BlockTag = Latest | Pending | AtBlock Word64 + +rpcTimeout :: Int +rpcTimeout = 10000000 + +-- | Far above the largest answer the service reads: a block with its transaction hashes, or two records at the link bound. +maxRpcResponseBytes :: Int +maxRpcResponseBytes = 1024 * 1024 + +revertCode :: Int +revertCode = 3 + +revertMessage :: Text +revertMessage = "execution reverted" + +-- | A node's error message is cut to this many characters. +maxNodeMessageLength :: Int +maxNodeMessageLength = 200 + +-- | The hex digits of a 256-bit quantity. +maxQuantityDigits :: Int +maxQuantityDigits = 64 + +newChainClient :: TVar ChaChaDRG -> ChainConfig -> IO ChainClient +newChainClient g ccConfig@ChainConfig {cServiceKey} = do + ccManager <- newTlsManager + ccRegistrar <- addressFromPrivateKey g cServiceKey + pure ChainClient {ccManager, ccConfig, ccRegistrar, ccTimeout = rpcTimeout} + +ethCall :: ChainClient -> Address -> ByteString -> IO (Either ChainError ByteString) +ethCall c = ethCallAt c Latest + +ethCallAt :: ChainClient -> BlockTag -> Address -> ByteString -> IO (Either ChainError ByteString) +ethCallAt c tag to calldata = rpc c "eth_call" [J.object ["to" .= to, "data" .= hex calldata], blockTagParam tag] bytes + +latestBlock :: ChainClient -> IO (Either ChainError Block) +latestBlock c = blockByNumber c "latest" + +blockByNumber :: ChainClient -> J.Value -> IO (Either ChainError Block) +blockByNumber c tag = + rpc c "eth_getBlockByNumber" [tag, J.Bool False] $ J.withObject "block" $ \b -> + Block <$> (quantity =<< b .: "number") <*> (quantity =<< b .: "timestamp") <*> (quantity =<< b .: "baseFeePerGas") + +-- | Nothing while the transaction is not mined, or after the node pruned its receipt. +transactionReceipt :: ChainClient -> TxHash -> IO (Either ChainError (Maybe Receipt)) +transactionReceipt c (TxHash h) = + rpc c "eth_getTransactionReceipt" [J.String $ hex h] $ nullable $ J.withObject "receipt" $ \r -> + Receipt <$> (status =<< r .: "status") <*> (quantity =<< r .: "blockNumber") where - body = J.encode $ J.object ["jsonrpc" .= ("2.0" :: Text), "id" .= (1 :: Int), "method" .= method, "params" .= params] - response = J.withObject "JSON-RPC response" $ \o -> o .:? "error" >>= maybe (Right <$> (parseResult =<< o .: "result")) rpcError - rpcError = J.withObject "JSON-RPC error" $ \e -> Left . ChainError <$> e .: "message" + status = + quantity >=> \case + (1 :: Word64) -> pure True + 0 -> pure False + _ -> fail "not a receipt status" -quantity :: (Eq a, Num a) => J.Value -> JT.Parser a +-- | Nothing when the node does not know the transaction. +transactionByHash :: ChainClient -> TxHash -> IO (Either ChainError (Maybe TxState)) +transactionByHash c (TxHash h) = + rpc c "eth_getTransactionByHash" [J.String $ hex h] $ nullable $ J.withObject "transaction" $ \t -> + maybe TxPending TxMined <$> (traverse quantity =<< t .:? "blockNumber") + +transactionCount :: ChainClient -> Address -> BlockTag -> IO (Either ChainError Word64) +transactionCount c a tag = rpc c "eth_getTransactionCount" [J.toJSON a, blockTagParam tag] quantity + +blockTagParam :: BlockTag -> J.Value +blockTagParam = \case + Latest -> "latest" + Pending -> "pending" + AtBlock number -> J.String $ "0x" <> T.pack (showHex number "") + +-- | The dry run of a registrar transaction; an estimate above the configured cap is refused. +estimateGas :: ChainClient -> Address -> ByteString -> IO (Either ChainError Word64) +estimateGas c@ChainClient {ccRegistrar, ccConfig = ChainConfig {cGasLimitCap}} to calldata = + (>>= capped) <$> rpc c "eth_estimateGas" [J.object ["from" .= ccRegistrar, "to" .= to, "data" .= hex calldata], "pending"] quantity + where + capped gas + | gas > cGasLimitCap = Left $ ChainGasAboveCap gas + | otherwise = Right gas + +maxPriorityFee :: ChainClient -> IO (Either ChainError Word64) +maxPriorityFee c = rpc c "eth_maxPriorityFeePerGas" [] quantity + +signTransaction :: TVar ChaChaDRG -> ChainClient -> TxRequest -> IO (Either String SignedTx) +signTransaction g ChainClient {ccConfig = ChainConfig {cChainId, cServiceKey}} TxRequest {trTo, trData, trNonce, trGasLimit, trMaxFeePerGas, trMaxPriorityFeePerGas} = + fmap signed <$> signEip1559Tx g cServiceKey tx + where + tx = + Eip1559Tx + { txChainId = cChainId, + txNonce = trNonce, + txMaxPriorityFeePerGas = fromIntegral trMaxPriorityFeePerGas, + txMaxFeePerGas = fromIntegral trMaxFeePerGas, + txGasLimit = trGasLimit, + txTo = trTo, + txValue = 0, + txData = trData + } + signed raw = SignedTx {stRaw = raw, stHash = TxHash $ keccak256 raw} + +eip1559TxType :: Word8 +eip1559TxType = 2 + +-- | The request a raw transaction from 'signTransaction' was signed from. +decodeSignedTx :: ByteString -> Either String TxRequest +decodeSignedTx raw = case B.uncons raw of + Just (txType, encoded) | txType == eip1559TxType -> case rlpItem encoded of + Right (RLPList [_chainId, nonce, tip, maxFee, gas, RLPBytes to, _value, RLPBytes trData, _accessList, _yParity, _r, _s], "") -> do + trTo <- maybe (Left "transaction: not an address") Right $ addressFromBytes to + TxRequest trTo trData <$> scalar nonce <*> scalar gas <*> scalar maxFee <*> scalar tip + Right _ -> Left "transaction: not a signed EIP-1559 transaction" + Left e -> Left e + _ -> Left "transaction: not an EIP-1559 transaction" + where + scalar = \case + RLPBytes b | B.length b <= 8 -> Right $ fromInteger $ os2ip b + _ -> Left "transaction: not a 64-bit scalar" + +rlpItem :: ByteString -> Either String (RLPItem, ByteString) +rlpItem s = case B.uncons s of + Nothing -> Left "RLP: no item" + Just (prefix, rest) + | prefix < 0x80 -> Right (RLPBytes $ B.singleton prefix, rest) + | prefix <= 0xb7 -> bytesItem (fromIntegral $ prefix - 0x80) rest + | prefix < 0xc0 -> longLength (fromIntegral $ prefix - 0xb7) rest >>= uncurry bytesItem + | prefix <= 0xf7 -> listItem (fromIntegral $ prefix - 0xc0) rest + | otherwise -> longLength (fromIntegral $ prefix - 0xf7) rest >>= uncurry listItem + where + bytesItem n r = (\(payload, r') -> (RLPBytes payload, r')) <$> split n r + listItem n r = split n r >>= \(payload, r') -> (\items -> (RLPList items, r')) <$> rlpItems payload + rlpItems payload + | B.null payload = Right [] + | otherwise = rlpItem payload >>= \(item, r) -> (item :) <$> rlpItems r + longLength n r = split n r >>= \(len, r') -> (,r') <$> fits (os2ip len) r' + fits len r + | len <= toInteger (B.length r) = Right $ fromInteger len + | otherwise = Left "RLP: truncated" + split n r + | n <= B.length r = Right $ B.splitAt n r + | otherwise = Left "RLP: truncated" + +sendRawTransaction :: ChainClient -> ByteString -> IO (Either ChainError TxHash) +sendRawTransaction c raw = rpc c "eth_sendRawTransaction" [J.String $ hex raw] (fmap TxHash . bytes) + +-- | The answer is parsed within the timeout, so a slow parse is bounded too. +rpc :: ChainClient -> Text -> [J.Value] -> (J.Value -> JT.Parser a) -> IO (Either ChainError a) +rpc ChainClient {ccManager, ccConfig = ChainConfig {cRpcUrl}, ccTimeout} method params parseResult = + timeout ccTimeout (try $ post >>= evaluate . answer) >>= \case + Nothing -> pure $ Left $ unavailable "timed out" + Just (Left (e :: HTTP.HttpException)) -> do + logWarn $ "chain RPC " <> method <> " failed: " <> httpFailureDetail cRpcUrl e + pure $ Left $ unavailable $ httpFailure e + Just (Right r) -> pure r + where + answer (status, body) + | LB.length body > fromIntegral maxRpcResponseBytes = Left $ unavailable $ "response over " <> tshow maxRpcResponseBytes <> " bytes" + | otherwise = case J.eitherDecode body of + Left _ -> refused Nothing + Right v -> either (refused . Just) id $ JT.parseEither response v + where + refused parseError + | not (statusIsSuccessful status) = Left $ unavailable $ "HTTP " <> tshow (statusCode status) + -- aeson's decode error quotes the body, which can be any page a proxy answers with + | otherwise = Left $ unavailable $ "not a JSON-RPC response" <> maybe "" ((": " <>) . T.pack) parseError + post = do + req <- HTTP.parseRequest cRpcUrl + HTTP.withResponse + req + { HTTP.method = methodPost, + HTTP.redirectCount = 0, + HTTP.requestHeaders = (hContentType, "application/json") : HTTP.requestHeaders req, + HTTP.requestBody = HTTP.RequestBodyLBS requestBody + } + ccManager + $ \resp -> (HTTP.responseStatus resp,) <$> HTTP.brReadSome (HTTP.responseBody resp) (maxRpcResponseBytes + 1) + requestBody = J.encode $ J.object ["jsonrpc" .= ("2.0" :: Text), "id" .= (1 :: Int), "method" .= method, "params" .= params] + response = J.withObject "JSON-RPC response" $ \o -> o .:? "error" >>= maybe (Right <$> (parseResult =<< o .: "result")) (fmap Left . rpcError) + rpcError = J.withObject "JSON-RPC error" $ \e -> do + code <- e .: "code" + message <- e .: "message" + revertData <- e .:? "data" + pure $ + if code == revertCode || revertMessage `T.isPrefixOf` message + then ChainReverted $ maybe (dataless message) (decodeRevert <=< JT.parseMaybe bytes) revertData + else unavailable $ "error " <> tshow code <> ": " <> T.take maxNodeMessageLength message + unavailable reason = ChainUnavailable $ method <> ": " <> reason + -- a node or proxy that drops the data can keep a reason in the message, as in "execution reverted: ERC721: invalid token ID" + dataless message + | message == revertMessage = Just RNWithoutData + | otherwise = Nothing + +-- | Only the kind of failure, for callers: an exception's text can hold the URL or its host. +httpFailure :: HTTP.HttpException -> Text +httpFailure = \case + HTTP.InvalidUrlException {} -> "invalid RPC URL" + HTTP.HttpExceptionRequest _ content -> case content of + HTTP.ResponseTimeout -> "timed out" + HTTP.ConnectionTimeout -> "connection timed out" + HTTP.ConnectionFailure _ -> "connection failed" + _ -> "request failed" + +-- | The failure's detail for the service log, with the RPC URL and its host, path and query replaced, since they can carry a provider's key. +httpFailureDetail :: String -> HTTP.HttpException -> Text +httpFailureDetail rpcUrl e = foldl' (\t secret -> T.replace secret "" t) detail secrets + where + detail = case e of + HTTP.InvalidUrlException _ reason -> "invalid URL: " <> T.pack reason + HTTP.HttpExceptionRequest _ content -> tshow content + secrets = filter ((> 1) . T.length) $ T.pack rpcUrl : maybe [] urlParts (HTTP.parseRequest rpcUrl) + urlParts req = map decodeLatin1 [HTTP.host req, HTTP.path req, HTTP.queryString req] + +nullable :: (J.Value -> JT.Parser a) -> J.Value -> JT.Parser (Maybe a) +nullable p = \case + J.Null -> pure Nothing + v -> Just <$> p v + +quantity :: forall a. (Integral a, Bounded a) => J.Value -> JT.Parser a quantity = J.withText "quantity" $ \t -> case T.stripPrefix "0x" t of - Just h | [(n, "")] <- readHex (T.unpack h) -> pure n + Just h | T.length h <= maxQuantityDigits, [(n, "")] <- readHex (T.unpack h), n <= toInteger (maxBound :: a) -> pure $ fromInteger n _ -> fail "not a quantity" bytes :: J.Value -> JT.Parser ByteString bytes = J.withText "data" $ \t -> case T.stripPrefix "0x" t of Just h | Right bs <- convertFromBase Base16 (encodeUtf8 h) -> pure bs _ -> fail "not hex data" - -hex :: ByteString -> Text -hex bs = "0x" <> decodeLatin1 (convertToBase Base16 bs) diff --git a/apps/simplex-store-service/src/StoreService/Names/Contracts.hs b/apps/simplex-store-service/src/StoreService/Names/Contracts.hs new file mode 100644 index 0000000000..712e2e963c --- /dev/null +++ b/apps/simplex-store-service/src/StoreService/Names/Contracts.hs @@ -0,0 +1,211 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} + +module StoreService.Names.Contracts + ( Contracts (ctDeadline), + NameStatus (..), + RegisteredName (..), + NameRecords (..), + CommitmentAges (..), + newContracts, + secondsPerYear, + nameStatus, + nameRecords, + textRecord, + chainPriceCents, + sponsorNonce, + resolverNonce, + ownerOfToken, + nameExpires, + commitmentTime, + controllerAvailable, + commitmentAges, + ) +where + +import Control.Concurrent.Async (Concurrently (..)) +import Control.Monad.Except (ExceptT (..), runExceptT) +import Data.Bifunctor (first) +import Data.ByteString (ByteString) +import qualified Data.ByteString.Char8 as B +import Data.Functor.Compose (Compose (..)) +import Data.IORef (IORef, atomicWriteIORef, newIORef, readIORef) +import Data.Maybe (fromMaybe) +import Data.Text (Text) +import Data.Text.Encoding (decodeLatin1, encodeUtf8) +import Data.Word (Word64) +import Simplex.Messaging.Eth.Address (Address) +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.Registration (channelRecordKey, contactRecordKey, labelNode, nodeBytes) +import StoreService.Names.Revert (RevertName (..)) +import System.Timeout (timeout) + +data Contracts = Contracts + { ctChain :: ChainClient, + ctTLD :: SimplexTLD, + ctRegistrar :: IORef (Maybe RegistrarConstants), + ctCommitmentAges :: IORef (Maybe CommitmentAges), + -- | microseconds for all the reads of one name status or of one name's records + ctDeadline :: Int + } + +data RegistrarConstants = RegistrarConstants {rcRegistry :: Address, rcGracePeriod :: Integer} + +data NameStatus = NSAvailable | NSReserved | NSRegistered RegisteredName + deriving (Eq, Show) + +data RegisteredName = RegisteredName + { rnOwner :: Address, + rnResolver :: Address, + rnExpiresAt :: Word64, + rnGracePeriod :: Integer + } + deriving (Eq, Show) + +-- | The default resolver's records ("" when unset) and the owner's nonce for the next edit. +data NameRecords = NameRecords {rdContact :: Text, rdChannel :: Text, rdNonce :: Word64} + deriving (Eq, Show) + +data CommitmentAges = CommitmentAges {caMin :: Integer, caMax :: Integer} + deriving (Eq, Show) + +secondsPerYear :: Integer +secondsPerYear = 31536000 + +attoUsdPerCent :: Integer +attoUsdPerCent = 10 ^ (16 :: Int) + +-- | One call's timeout, so a node that hangs fails a status or a records read once, not once per read. +nameReadsDeadline :: Int +nameReadsDeadline = 10000000 + +-- | Reads nothing: the registrar's constants and the commitment ages are read on first use and kept once read. +newContracts :: SimplexTLD -> ChainClient -> IO Contracts +newContracts ctTLD ctChain = do + ctRegistrar <- newIORef Nothing + ctCommitmentAges <- newIORef Nothing + pure Contracts {ctChain, ctTLD, ctRegistrar, ctCommitmentAges, ctDeadline = nameReadsDeadline} + +-- | Registered while @nameExpires + GRACE_PERIOD@ is not before the latest block's time. +nameStatus :: Contracts -> LabelHash -> IO (Either ChainError NameStatus) +nameStatus ct@Contracts {ctChain} lh = withinDeadline ct "name status" $ runExceptT $ do + (RegistrarConstants {rcRegistry, rcGracePeriod}, expires, Block {blockTimestamp}) <- + ExceptT $ together $ (,,) <$> concurrent (registrarConstants ct) <*> concurrent (nameExpires ct Latest lh) <*> concurrent (latestBlock ctChain) + if toInteger expires + rcGracePeriod >= toInteger blockTimestamp + then do + let node = nodeArg ct lh + registryRead signature = concurrent $ call ct rcRegistry (signature, node) decodeAddress + (rnOwner, rnResolver) <- ExceptT $ together $ (,) <$> registryRead "owner(bytes32)" <*> registryRead "resolver(bytes32)" + pure $ NSRegistered RegisteredName {rnOwner, rnResolver, rnExpiresAt = expires, rnGracePeriod = rcGracePeriod} + else do + reason <- ExceptT $ call ct (controller ct) ("reservedNames(bytes32)", labelHashArg lh) decodeUint256 + pure $ if reason /= 0 then NSReserved else NSAvailable + +-- | Nothing for a name on another resolver contract, or none: the service reads no records from a contract it does not know. +nameRecords :: Contracts -> LabelHash -> RegisteredName -> IO (Either ChainError (Maybe NameRecords)) +nameRecords ct lh RegisteredName {rnOwner, rnResolver} + | rnResolver /= resolver ct = pure $ Right Nothing + | otherwise = + withinDeadline ct "name records" $ together $ + (\rdContact rdChannel rdNonce -> Just NameRecords {rdContact, rdChannel, rdNonce}) + <$> concurrent (textRecord ct lh contactRecordKey) + <*> concurrent (textRecord ct lh channelRecordKey) + <*> concurrent (resolverNonce ct rnOwner) + +-- | The default resolver's record, "" when unset. +textRecord :: Contracts -> LabelHash -> ByteString -> IO (Either ChainError Text) +textRecord ct lh key = call ct (resolver ct) ("text(bytes32,string)", abiTuple [Static $ nodeArg ct lh, Dynamic $ abiBytes key]) decodeString + +-- | Cents for a label of this length and these years. The oracle prices by length only, +-- so a placeholder label of that length keeps the label from the RPC node. +chainPriceCents :: Contracts -> Int -> Int -> IO (Either ChainError Int) +chainPriceCents ct len years = call ct (controller ct) ("rentPriceUSD(string,uint256)", args) $ \ret -> do + base <- decodeUint256 ret + let cents = base `div` attoUsdPerCent + if cents <= toInteger (maxBound :: Int) then Right (fromInteger cents) else Left AERange + where + args = abiTuple [Dynamic $ abiBytes $ B.replicate len 'a', Static $ uint256 $ toInteger years * secondsPerYear] + +sponsorNonce :: Contracts -> Address -> IO (Either ChainError Word64) +sponsorNonce ct owner = call ct (cSponsor $ chainConfig ct) ("nonces(address)", addressWord owner) decodeWord64 + +resolverNonce :: Contracts -> Address -> IO (Either ChainError Word64) +resolverNonce ct owner = call ct (resolver ct) ("nonces(address)", addressWord owner) decodeWord64 + +-- | 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)) +ownerOfToken ct tag lh = + callAt ct tag (baseRegistrar ct) ("ownerOf(uint256)", labelHashArg lh) decodeAddress >>= \case + Left (ChainReverted (Just RNWithoutData)) -> pure $ Right Nothing + r -> pure $ Just <$> r + +nameExpires :: Contracts -> BlockTag -> LabelHash -> IO (Either ChainError Word64) +nameExpires ct tag lh = callAt ct tag (baseRegistrar ct) ("nameExpires(uint256)", labelHashArg lh) decodeWord64 + +-- | The block time of the commitment, Nothing when the controller holds none. +commitmentTime :: Contracts -> ByteString -> IO (Either ChainError (Maybe Word64)) +commitmentTime ct commitment = fmap nonZero <$> call ct (controller ct) ("commitments(bytes32)", commitment) decodeWord64 + where + nonZero t = if t == 0 then Nothing else Just t + +controllerAvailable :: Contracts -> Text -> IO (Either ChainError Bool) +controllerAvailable ct label = call ct (controller ct) ("available(string)", abiTuple [Dynamic $ abiBytes $ encodeUtf8 label]) decodeBool + +commitmentAges :: Contracts -> IO (Either ChainError CommitmentAges) +commitmentAges ct@Contracts {ctCommitmentAges} = readOnce ctCommitmentAges $ runExceptT $ do + caMin <- ExceptT $ call ct (controller ct) ("minCommitmentAge()", "") decodeUint256 + caMax <- ExceptT $ call ct (controller ct) ("maxCommitmentAge()", "") decodeUint256 + pure CommitmentAges {caMin, caMax} + +registrarConstants :: Contracts -> IO (Either ChainError RegistrarConstants) +registrarConstants ct@Contracts {ctRegistrar} = readOnce ctRegistrar $ runExceptT $ do + rcRegistry <- ExceptT $ call ct (baseRegistrar ct) ("ens()", "") decodeAddress + rcGracePeriod <- ExceptT $ call ct (baseRegistrar ct) ("GRACE_PERIOD()", "") decodeUint256 + pure RegistrarConstants {rcRegistry, rcGracePeriod} + +-- | Concurrent first uses may each read; they read the same immutable values. +readOnce :: IORef (Maybe a) -> IO (Either ChainError a) -> IO (Either ChainError a) +readOnce ref readChain = + readIORef ref >>= \case + Just a -> pure $ Right a + Nothing -> readChain >>= either (pure . Left) (\a -> Right a <$ atomicWriteIORef ref (Just a)) + +-- | Reads run at once; the first failure in argument order is the answer. +together :: Compose Concurrently (Either ChainError) a -> IO (Either ChainError a) +together = runConcurrently . getCompose + +concurrent :: IO (Either ChainError a) -> Compose Concurrently (Either ChainError) a +concurrent = Compose . Concurrently + +withinDeadline :: Contracts -> Text -> IO (Either ChainError a) -> IO (Either ChainError a) +withinDeadline Contracts {ctDeadline} what action = fromMaybe (Left $ ChainUnavailable $ what <> ": timed out") <$> timeout ctDeadline action + +call :: Contracts -> Address -> (ByteString, ByteString) -> (ByteString -> Either AbiError a) -> IO (Either ChainError a) +call ct = callAt ct Latest + +-- | An answer that does not decode is a node failure, as an RPC error is. +callAt :: Contracts -> BlockTag -> Address -> (ByteString, ByteString) -> (ByteString -> Either AbiError a) -> IO (Either ChainError a) +callAt Contracts {ctChain} tag to (signature, args) decode = + (>>= first malformed . decode) <$> ethCallAt ctChain tag to (selector signature <> args) + where + malformed e = ChainUnavailable $ "eth_call: " <> decodeLatin1 signature <> " answered " <> tshow e + +labelHashArg :: LabelHash -> ByteString +labelHashArg (LabelHash h) = h + +nodeArg :: Contracts -> LabelHash -> ByteString +nodeArg Contracts {ctTLD} = nodeBytes . labelNode ctTLD + +chainConfig :: Contracts -> ChainConfig +chainConfig = ccConfig . ctChain + +controller, resolver, baseRegistrar :: Contracts -> Address +controller = cController . chainConfig +resolver = cResolver . chainConfig +baseRegistrar = cBaseRegistrar . chainConfig diff --git a/apps/simplex-store-service/src/StoreService/Names/Registration.hs b/apps/simplex-store-service/src/StoreService/Names/Registration.hs index e29abb8d7a..a753fd1856 100644 --- a/apps/simplex-store-service/src/StoreService/Names/Registration.hs +++ b/apps/simplex-store-service/src/StoreService/Names/Registration.hs @@ -4,6 +4,12 @@ module StoreService.Names.Registration ( Registration (..), RegisterIntent (..), + Node, + nodeBytes, + namehash, + labelNode, + contactRecordKey, + channelRecordKey, sponsorDomain, makeCommitment, commitCalldata, @@ -17,8 +23,8 @@ import Control.Monad (unless, when) import Control.Monad.Except (ExceptT (..), runExceptT, throwError) import Data.ByteString (ByteString) import qualified Data.ByteString as B +import Data.Maybe (catMaybes) import Data.Text (Text) -import qualified Data.Text as T import Data.Text.Encoding (encodeUtf8) import Data.Word (Word64) import Simplex.Messaging.Crypto (keccak256) @@ -26,7 +32,7 @@ import Simplex.Messaging.Crypto.Secp256k1 (RecoverableSignature) import Simplex.Messaging.Encoding.String (strEncode) import Simplex.Messaging.Eth.Address (Address, recoverAddress) import Simplex.Messaging.Eth.EIP712 (Eip712Domain (..), Eip712Value (..), hashTypedData, serializeSignature) -import Simplex.Messaging.SimplexName (SimplexTLD) +import Simplex.Messaging.SimplexName (LabelHash (..), SimplexTLD) import StoreService.Names.Abi (AbiValue (..), abiArray, abiBytes, abiTuple, addressWord, selector, uint256) data Registration = Registration @@ -36,10 +42,20 @@ data Registration = Registration rDuration :: Word64, rSecret :: ByteString, rResolver :: Address, - rContactLinks :: [Text], - rChannelLinks :: [Text] + rContactLink :: Maybe Text, + rChannelLink :: Maybe Text } +-- | Only built by 'labelNode', so it always holds 32 bytes. +newtype Node = Node ByteString + +nodeBytes :: Node -> ByteString +nodeBytes (Node node) = node + +contactRecordKey, channelRecordKey :: ByteString +contactRecordKey = "simplex.contact" +channelRecordKey = "simplex.channel" + data RegisterIntent = RegisterIntent { riRegistration :: Registration, riNonce :: Word64, @@ -104,15 +120,18 @@ registrationTuple r@Registration {rLabel, rOwner, rDuration, rSecret, rResolver} referrer = B.replicate 32 0 recordCalls :: Registration -> [ByteString] -recordCalls Registration {rLabel, rTLD, rContactLinks, rChannelLinks} = - [setText key ls | (key, ls) <- [("simplex.contact", rContactLinks), ("simplex.channel", rChannelLinks)], not (null ls)] +recordCalls Registration {rLabel, rTLD, rContactLink, rChannelLink} = + catMaybes [setText contactRecordKey <$> rContactLink, setText channelRecordKey <$> rChannelLink] where - setText key ls = + setText key link = selector "setText(bytes32,string,string)" - <> abiTuple [Static node, Dynamic $ abiBytes key, Dynamic $ abiBytes $ encodeUtf8 $ T.intercalate ";" ls] - node = namehash rTLD rLabel + <> abiTuple [Static node, Dynamic $ abiBytes key, Dynamic $ abiBytes $ encodeUtf8 link] + Node node = namehash rTLD rLabel -namehash :: SimplexTLD -> Text -> ByteString -namehash tld label = keccak256 $ tldNode <> keccak256 (encodeUtf8 label) +namehash :: SimplexTLD -> Text -> Node +namehash tld = labelNode tld . LabelHash . keccak256 . encodeUtf8 + +labelNode :: SimplexTLD -> LabelHash -> Node +labelNode tld (LabelHash h) = Node $ keccak256 $ tldNode <> h where tldNode = keccak256 $ B.replicate 32 0 <> keccak256 (B.drop 1 $ strEncode tld) diff --git a/apps/simplex-store-service/src/StoreService/Names/Revert.hs b/apps/simplex-store-service/src/StoreService/Names/Revert.hs new file mode 100644 index 0000000000..fc6acd6bd5 --- /dev/null +++ b/apps/simplex-store-service/src/StoreService/Names/Revert.hs @@ -0,0 +1,119 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE OverloadedStrings #-} + +module StoreService.Names.Revert (RevertName (..), decodeRevert) where + +import Data.ByteString (ByteString) +import qualified Data.ByteString as B +import Data.Map.Strict (Map) +import qualified Data.Map.Strict as M +import StoreService.Names.Abi (selector) + +-- | The custom errors of SimplexController, SimplexSponsor, BaseRegistrarImplementation and SimplexResolver. +-- The sponsor passes the controller's and the base registrar's reverts through, so any call can revert with any of them. +data RevertName + = RNAlreadyFrozen + | RNCommitmentNotFound + | RNCommitmentTooNew + | RNCommitmentTooOld + | RNDurationTooShort + | RNFrozen + | RNInsufficientAllowance + | RNInsufficientValue + | RNInvalidEVMAddress + | RNInvalidNonce + | RNInvalidSignature + | RNLabelTooLong + | RNMaxCommitmentAgeTooHigh + | RNMaxCommitmentAgeTooLow + | RNMinCharLengthCanOnlyDecrease + | RNMinCharLengthZero + | RNMinCommitmentAgeZero + | RNNameNotAvailable + | RNNameNotReserved + | RNNameReserved + | RNNameTooShort + | RNNftGateCanOnlyBeDisabled + | RNNftRequired + | RNNodeNotOwnedByRegistrar + | RNNotBeneficiary + | RNNotNameOwner + | RNNotOffered + | RNNotOwnerOrBeneficiary + | RNNotSponsor + | RNNotSubnameRegistrar + | RNOffsetOutOfBoundsError + | RNOwnerMustBeCaller + | RNPublicSalesClosed + | RNReasonRequired + | RNRecipientMustBeCaller + | RNReentrantCall + | RNResolverRequiredWhenDataSupplied + | RNReverseRecordNotSupported + | RNSignatureExpired + | RNTransferFailed + | RNTransferToSelf + | RNUnexpiredCommitmentExists + | RNZeroAddress + | -- | a revert with empty or no data, as a bare @require@ or @revert()@ gives + RNWithoutData + deriving (Eq, Show, Enum, Bounded) + +-- | Nothing for a revert without data, which has no selector. +revertSignature :: RevertName -> Maybe ByteString +revertSignature = \case + RNAlreadyFrozen -> Just "AlreadyFrozen()" + RNCommitmentNotFound -> Just "CommitmentNotFound(bytes32)" + RNCommitmentTooNew -> Just "CommitmentTooNew(bytes32,uint256,uint256)" + RNCommitmentTooOld -> Just "CommitmentTooOld(bytes32,uint256,uint256)" + RNDurationTooShort -> Just "DurationTooShort(uint256)" + RNFrozen -> Just "Frozen()" + RNInsufficientAllowance -> Just "InsufficientAllowance(uint256,uint256)" + RNInsufficientValue -> Just "InsufficientValue()" + RNInvalidEVMAddress -> Just "InvalidEVMAddress(bytes)" + RNInvalidNonce -> Just "InvalidNonce()" + RNInvalidSignature -> Just "InvalidSignature()" + RNLabelTooLong -> Just "LabelTooLong(uint256,uint256)" + RNMaxCommitmentAgeTooHigh -> Just "MaxCommitmentAgeTooHigh()" + RNMaxCommitmentAgeTooLow -> Just "MaxCommitmentAgeTooLow()" + RNMinCharLengthCanOnlyDecrease -> Just "MinCharLengthCanOnlyDecrease()" + RNMinCharLengthZero -> Just "MinCharLengthZero()" + RNMinCommitmentAgeZero -> Just "MinCommitmentAgeZero()" + RNNameNotAvailable -> Just "NameNotAvailable(string)" + RNNameNotReserved -> Just "NameNotReserved(string)" + RNNameReserved -> Just "NameReserved(string)" + RNNameTooShort -> Just "NameTooShort(string,uint8)" + RNNftGateCanOnlyBeDisabled -> Just "NftGateCanOnlyBeDisabled()" + RNNftRequired -> Just "NftRequired()" + RNNodeNotOwnedByRegistrar -> Just "NodeNotOwnedByRegistrar()" + RNNotBeneficiary -> Just "NotBeneficiary()" + RNNotNameOwner -> Just "NotNameOwner()" + RNNotOffered -> Just "NotOffered()" + RNNotOwnerOrBeneficiary -> Just "NotOwnerOrBeneficiary()" + RNNotSponsor -> Just "NotSponsor()" + RNNotSubnameRegistrar -> Just "NotSubnameRegistrar()" + RNOffsetOutOfBoundsError -> Just "OffsetOutOfBoundsError(uint256,uint256)" + RNOwnerMustBeCaller -> Just "OwnerMustBeCaller()" + RNPublicSalesClosed -> Just "PublicSalesClosed()" + RNReasonRequired -> Just "ReasonRequired()" + RNRecipientMustBeCaller -> Just "RecipientMustBeCaller()" + RNReentrantCall -> Just "ReentrantCall()" + RNResolverRequiredWhenDataSupplied -> Just "ResolverRequiredWhenDataSupplied()" + RNReverseRecordNotSupported -> Just "ReverseRecordNotSupported()" + RNSignatureExpired -> Just "SignatureExpired()" + RNTransferFailed -> Just "TransferFailed()" + RNTransferToSelf -> Just "TransferToSelf()" + RNUnexpiredCommitmentExists -> Just "UnexpiredCommitmentExists(bytes32)" + RNZeroAddress -> Just "ZeroAddress()" + RNWithoutData -> Nothing + +revertSelectors :: Map ByteString RevertName +revertSelectors = M.fromList [(selector signature, n) | n <- [minBound .. maxBound], Just signature <- [revertSignature n]] + +-- | The error a revert's data names by its selector, if it is one of the contracts' errors. +decodeRevert :: ByteString -> Maybe RevertName +decodeRevert revertData + | B.null revertData = Just RNWithoutData + | otherwise = M.lookup (B.take selectorSize revertData) revertSelectors + where + selectorSize = 4 diff --git a/simplex-chat.cabal b/simplex-chat.cabal index df5421ad1f..32fc08df3c 100644 --- a/simplex-chat.cabal +++ b/simplex-chat.cabal @@ -762,7 +762,9 @@ test-suite simplex-chat-test Bots.StoreService.GroupIntegrationTests Bots.StoreService.GroupTests Bots.StoreService.NameRegistrationTests + Bots.StoreService.NamesChainTests Bots.StoreService.NamesCodesTests + Bots.StoreService.NamesContractsTests Bots.StoreService.NamesLabelTests Bots.StoreService.StoreVerifierTests Bots.StoreService.StripeTests @@ -789,8 +791,10 @@ test-suite simplex-chat-test StoreService.Names.Abi StoreService.Names.Chain StoreService.Names.Codes + StoreService.Names.Contracts StoreService.Names.Label StoreService.Names.Registration + StoreService.Names.Revert StoreService.Names.Store StoreService.Names.Turns StoreService.Options diff --git a/tests/Bots/StoreService/FakeEthNode.hs b/tests/Bots/StoreService/FakeEthNode.hs index bec267bd31..1562188a43 100644 --- a/tests/Bots/StoreService/FakeEthNode.hs +++ b/tests/Bots/StoreService/FakeEthNode.hs @@ -1,44 +1,92 @@ +{-# LANGUAGE LambdaCase #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE OverloadedStrings #-} module Bots.StoreService.FakeEthNode ( FakeEthNode (..), + CallAnswer (..), + Fault (..), withFakeEthNode, - revertCalls, + fakeChainConfig, + answerCall, + setFault, + clearFault, + setBlock, + mine, sentTransactions, + revertFault, + fakeChainId, + fakeController, + fakeSponsor, + fakeBaseRegistrar, + fakeResolver, + fakeRegistrarKey, fakeGas, fakeTip, fakeBaseFee, ) where +import Control.Concurrent (threadDelay) import Control.Concurrent.STM +import Control.Exception (finally) import Data.Aeson ((.:), (.=)) import qualified Data.Aeson as J import qualified Data.Aeson.Types as JT -import Data.ByteArray.Encoding (Base (Base16), convertFromBase, convertToBase) +import qualified Data.ByteArray as BA +import Data.ByteArray.Encoding (Base (Base16), convertFromBase) import Data.ByteString (ByteString) +import Data.Map.Strict (Map) +import qualified Data.Map.Strict as M import Data.Text (Text) import qualified Data.Text as T -import Data.Text.Encoding (decodeLatin1, encodeUtf8) -import Network.HTTP.Client (Manager) -import qualified Network.HTTP.Client as HTTP -import Network.HTTP.Types (badRequest400, hContentType, ok200) +import Data.Text.Encoding (encodeUtf8) +import Data.Word (Word64) +import Network.HTTP.Types (badGateway502, badRequest400, hContentType, ok200) import Network.Wai (Application, responseLBS, strictRequestBody) import qualified Network.Wai.Handler.Warp as Warp import Numeric (showHex) import Simplex.Messaging.Crypto (keccak256) +import qualified Simplex.Messaging.Crypto.Secp256k1 as S +import Simplex.Messaging.Encoding.String (strDecode) +import Simplex.Messaging.Eth.Address (Address, unAddress) import Simplex.Messaging.Util (eitherToMaybe) +import StoreService.Config (ChainConfig (..)) +import StoreService.Names.Abi (hex) +import StoreService.Names.Chain (TxRequest (..), decodeSignedTx) data FakeEthNode = FakeEthNode { fnUrl :: String, - fnManager :: Manager, fnState :: TVar FakeState } +data CallAnswer = Returns ByteString | Reverts ByteString + +data Fault + = RpcError Int Text (Maybe ByteString) + | -- | answers only once the node is closed + Hang + | HttpFailure + | -- | a 200 page that is not JSON, as a proxy may answer + NotJson + | Answers J.Value + | -- | answers as usual after this many microseconds + Slow Int + data FakeState = FakeState - { fsRevert :: Bool, - fsSent :: [ByteString] + { fsCalls :: Map (ByteString, ByteString) CallAnswer, + fsFaults :: Map Text Fault, + -- | every raw transaction received, newest first + fsSent :: [ByteString], + -- | the transactions the node knows and has not mined, by nonce + fsPool :: Map Word64 ByteString, + fsReceipts :: Map ByteString (Bool, Word64), + -- | the key's transaction count at the latest block + fsUsed :: Word64, + fsBlock :: (Word64, Word64), + -- | the suggested tip and the base fee + fsFees :: (Word64, Word64), + fsClosed :: Bool } fakeGas, fakeTip, fakeBaseFee :: Num a => a @@ -46,51 +94,162 @@ fakeGas = 200000 fakeTip = 1000000000 fakeBaseFee = 2000000000 +fakeChainId :: Word64 +fakeChainId = 31337 + +fakeController, fakeSponsor, fakeBaseRegistrar, fakeResolver :: Address +fakeController = address "0x0165878a594ca255338adfa4d48449f69242eb8f" +fakeSponsor = address "0x9a676e781a523b5d0c0e43731313a708cb607508" +fakeBaseRegistrar = address "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512" +fakeResolver = address "0x2279b7a0a67db372996a5fab50d91eaa73d2ebe6" + +fakeRegistrarKey :: S.Secp256k1PrivateKey +fakeRegistrarKey = either error id $ S.mkPrivateKey $ BA.replicate 32 0x46 + +-- | 2026-01-01, block 1; each mined block is this many seconds later. +genesisTime, blockSeconds :: Word64 +genesisTime = 1767225600 +blockSeconds = 12 + withFakeEthNode :: (FakeEthNode -> IO a) -> IO a withFakeEthNode action = do - fnState <- newTVarIO FakeState {fsRevert = False, fsSent = []} - fnManager <- HTTP.newManager HTTP.defaultManagerSettings + fnState <- + newTVarIO + FakeState + { fsCalls = M.empty, + fsFaults = M.empty, + fsSent = [], + fsPool = M.empty, + fsReceipts = M.empty, + fsUsed = 0, + fsBlock = (1, genesisTime), + fsFees = (fakeTip, fakeBaseFee), + fsClosed = False + } Warp.testWithApplication (pure $ fakeApp fnState) $ \port -> - action FakeEthNode {fnUrl = "http://127.0.0.1:" <> show port, fnManager, fnState} + action FakeEthNode {fnUrl = "http://127.0.0.1:" <> show port, fnState} + `finally` atomically (modifyTVar' fnState $ \s -> s {fsClosed = True}) -revertCalls :: FakeEthNode -> IO () -revertCalls FakeEthNode {fnState} = atomically $ modifyTVar' fnState $ \s -> s {fsRevert = True} +fakeChainConfig :: FakeEthNode -> ChainConfig +fakeChainConfig FakeEthNode {fnUrl} = + ChainConfig + { cRpcUrl = fnUrl, + cChainId = fakeChainId, + cController = fakeController, + cSponsor = fakeSponsor, + cBaseRegistrar = fakeBaseRegistrar, + cResolver = fakeResolver, + cServiceKey = fakeRegistrarKey, + cGasLimitCap = 8000000 + } +answerCall :: FakeEthNode -> Address -> ByteString -> CallAnswer -> IO () +answerCall FakeEthNode {fnState} to calldata a = atomically $ modifyTVar' fnState $ \s -> s {fsCalls = M.insert (unAddress to, calldata) a $ fsCalls s} + +-- | Every request for the method fails this way until 'clearFault'. +setFault :: FakeEthNode -> Text -> Fault -> IO () +setFault FakeEthNode {fnState} method f = atomically $ modifyTVar' fnState $ \s -> s {fsFaults = M.insert method f $ fsFaults s} + +clearFault :: FakeEthNode -> Text -> IO () +clearFault FakeEthNode {fnState} method = atomically $ modifyTVar' fnState $ \s -> s {fsFaults = M.delete method $ fsFaults s} + +revertFault :: ByteString -> Fault +revertFault = RpcError 3 "execution reverted" . Just + +-- | Sets the latest block's number and time. +setBlock :: FakeEthNode -> Word64 -> Word64 -> IO () +setBlock FakeEthNode {fnState} number time = atomically $ modifyTVar' fnState $ \s -> s {fsBlock = (number, time)} + +-- | Mines a new block with these transaction hashes and receipt statuses, and returns its number. +-- A mined transaction of the pool uses its nonce, and the pool loses every transaction below it. +mine :: FakeEthNode -> [(ByteString, Bool)] -> IO Word64 +mine FakeEthNode {fnState} txs = atomically $ do + s@FakeState {fsBlock = (number, time), fsReceipts, fsPool, fsUsed} <- readTVar fnState + let number' = number + 1 + mined = M.fromList [(h, (ok, number')) | (h, ok) <- txs] + used = maximum $ fsUsed : [nonce + 1 | (nonce, raw) <- M.toList fsPool, keccak256 raw `M.member` mined] + writeTVar fnState s {fsBlock = (number', time + blockSeconds), fsReceipts = M.union mined fsReceipts, fsPool = M.dropWhileAntitone (< used) fsPool, fsUsed = used} + pure number' + +-- | The raw transactions in the order they were sent. sentTransactions :: FakeEthNode -> IO [ByteString] -sentTransactions FakeEthNode {fnState} = fsSent <$> readTVarIO fnState +sentTransactions FakeEthNode {fnState} = reverse . fsSent <$> readTVarIO fnState fakeApp :: TVar FakeState -> Application fakeApp st req respond = do body <- strictRequestBody req case JT.parseMaybe request =<< J.decode body of - Just (method, params) -> do - reply <- atomically $ answer st method params - respond $ responseLBS ok200 [(hContentType, "application/json")] $ J.encode $ J.object $ ["jsonrpc" .= ("2.0" :: Text), "id" .= (1 :: Int)] <> reply + Just (method, params) -> + fault method >>= \case + Just HttpFailure -> respond $ responseLBS badGateway502 [] "bad gateway" + Just Hang -> do + atomically $ readTVar st >>= check . fsClosed + reply $ rpcError (-32000) "node closed" Nothing + Just (RpcError code message revertData) -> reply $ rpcError code message revertData + Just NotJson -> respond $ responseLBS ok200 [] "Sign in to provider-api-key" + Just (Answers v) -> reply ["result" .= v] + Just (Slow delay) -> threadDelay delay >> answered method params + Nothing -> answered method params Nothing -> respond $ responseLBS badRequest400 [] "not a JSON-RPC request" where request = J.withObject "request" $ \o -> (,) <$> o .: "method" <*> o .: "params" + fault method = M.lookup method . fsFaults <$> readTVarIO st + answered method params = reply =<< atomically (answer st method params) + reply r = respond $ responseLBS ok200 [(hContentType, "application/json")] $ J.encode $ J.object $ ["jsonrpc" .= ("2.0" :: Text), "id" .= (1 :: Int)] <> r answer :: TVar FakeState -> Text -> [J.Value] -> STM [JT.Pair] answer st method params = do - s@FakeState {fsRevert, fsSent} <- readTVar st + s@FakeState {fsCalls, fsSent, fsPool, fsReceipts, fsUsed, fsBlock = (number, time), fsFees = (tip, baseFee)} <- readTVar st case (method, params) of - ("eth_estimateGas", _) -> pure $ if fsRevert then reverted else result $ quantity fakeGas - ("eth_getTransactionCount", _) -> pure $ result $ quantity $ toInteger $ length fsSent - ("eth_maxPriorityFeePerGas", _) -> pure $ result $ quantity fakeTip - ("eth_getBlockByNumber", _) -> pure $ result $ J.object ["baseFeePerGas" .= quantity fakeBaseFee] - ("eth_sendRawTransaction", [J.String raw]) | Just tx <- fromHex raw -> do - writeTVar st s {fsSent = tx : fsSent} - pure $ result $ hex $ keccak256 tx - _ -> pure ["error" .= J.object ["code" .= (-32601 :: Int), "message" .= ("method not found" :: Text)]] + ("eth_call", [call, _]) + | Just (to, calldata) <- JT.parseMaybe callTarget call -> + pure $ case M.lookup (unAddress to, calldata) fsCalls of + Just (Returns ret) -> result $ hex ret + Just (Reverts revertData) -> rpcError 3 "execution reverted" (Just revertData) + Nothing -> rpcError (-32000) "no fake answer for this call" Nothing + ("eth_estimateGas", _) -> pure $ result $ quantity fakeGas + ("eth_getTransactionCount", [_, J.String "latest"]) -> pure $ result $ quantity $ toInteger fsUsed + ("eth_getTransactionCount", [_, J.String "pending"]) -> + pure $ result $ quantity $ toInteger $ fsUsed + fromIntegral (length $ takeWhile (`M.member` fsPool) [fsUsed ..]) + ("eth_maxPriorityFeePerGas", _) -> pure $ result $ quantity $ toInteger tip + ("eth_getBlockByNumber", [J.String "latest", _]) -> pure $ result $ blockJson baseFee number time + ("eth_getTransactionReceipt", [J.String h]) | Just hash <- fromHex h -> pure $ result $ case M.lookup hash fsReceipts of + Just (ok, block) -> J.object ["transactionHash" .= h, "status" .= quantity (if ok then 1 else 0), "blockNumber" .= quantity (toInteger block)] + Nothing -> J.Null + ("eth_getTransactionByHash", [J.String h]) | Just hash <- fromHex h -> pure $ result $ case M.lookup hash fsReceipts of + Just (_, block) -> J.object ["hash" .= h, "blockNumber" .= quantity (toInteger block)] + Nothing + | any ((== hash) . keccak256) fsPool -> J.object ["hash" .= h, "blockNumber" .= J.Null] + | otherwise -> J.Null + ("eth_sendRawTransaction", [J.String raw]) + | Just tx <- fromHex raw, + Right TxRequest {trNonce, trMaxFeePerGas, trMaxPriorityFeePerGas} <- decodeSignedTx tx -> do + let accept = (result $ hex $ keccak256 tx) <$ writeTVar st s {fsSent = tx : fsSent, fsPool = M.insert trNonce tx fsPool} + case M.lookup trNonce fsPool of + _ | trNonce < fsUsed -> pure $ rpcError (-32000) "nonce too low" Nothing + Just known + | known == tx -> pure $ rpcError (-32000) "already known" Nothing + -- geth and reth replace a pending transaction only when both its fees are at least 10% higher + | Right TxRequest {trMaxFeePerGas = knownMax, trMaxPriorityFeePerGas = knownTip} <- decodeSignedTx known, + trMaxFeePerGas * 10 < knownMax * 11 || trMaxPriorityFeePerGas * 10 < knownTip * 11 -> + pure $ rpcError (-32000) "replacement transaction underpriced" Nothing + _ -> accept + _ -> pure $ rpcError (-32601) "method not found" Nothing where result v = ["result" .= v] - reverted = ["error" .= J.object ["code" .= (3 :: Int), "message" .= ("execution reverted" :: Text)]] + callTarget = J.withObject "call" $ \o -> (,) <$> o .: "to" <*> (maybe (fail "not hex data") pure . fromHex =<< o .: "data") + +blockJson :: Word64 -> Word64 -> Word64 -> J.Value +blockJson baseFee number time = J.object ["number" .= quantity (toInteger number), "timestamp" .= quantity (toInteger time), "baseFeePerGas" .= quantity (toInteger baseFee)] + +rpcError :: Int -> Text -> Maybe ByteString -> [JT.Pair] +rpcError code message revertData = ["error" .= J.object (["code" .= code, "message" .= message] <> maybe [] (\d -> ["data" .= hex d]) revertData)] quantity :: Integer -> Text quantity n = "0x" <> T.pack (showHex n "") -hex :: ByteString -> Text -hex bs = "0x" <> decodeLatin1 (convertToBase Base16 bs) - fromHex :: Text -> Maybe ByteString fromHex t = T.stripPrefix "0x" t >>= eitherToMaybe . convertFromBase Base16 . encodeUtf8 + +address :: ByteString -> Address +address = either error id . strDecode diff --git a/tests/Bots/StoreService/NameRegistrationTests.hs b/tests/Bots/StoreService/NameRegistrationTests.hs index fa5e096c4d..c98d16c9dc 100644 --- a/tests/Bots/StoreService/NameRegistrationTests.hs +++ b/tests/Bots/StoreService/NameRegistrationTests.hs @@ -5,18 +5,17 @@ module Bots.StoreService.NameRegistrationTests (badgeNameRegistrationTests) wher import StoreService.Names.Chain import StoreService.Names.Registration +import StoreService.Names.Revert (RevertName (..)) import Bots.StoreService.FakeEthNode import Bots.StoreService.WebUIMock import Control.Concurrent.STM (TVar) import Crypto.Random (ChaChaDRG) -import qualified Data.ByteArray as BA -import Data.ByteArray.Encoding (Base (Base16), convertToBase) +import Data.ByteArray.Encoding (Base (Base16), convertFromBase, convertToBase) import Data.ByteString (ByteString) import qualified Data.ByteString as B import Data.Text (Text) import Data.Word (Word64) import qualified Simplex.Messaging.Crypto as C -import qualified Simplex.Messaging.Crypto.Secp256k1 as S import Simplex.Messaging.Encoding.String (strDecode) import Simplex.Messaging.Eth.Address (Address) import Simplex.Messaging.Eth.EIP712 (Eip712Domain) @@ -25,7 +24,7 @@ import Simplex.Messaging.SimplexName (SimplexTLD (..)) import Test.Hspec badgeNameRegistrationTests :: Spec -badgeNameRegistrationTests = describe "store service name registration" $ do +badgeNameRegistrationTests = describe "StoreService names: registration" $ do g <- runIO C.newRandom -- expected encodings and signatures are viem's, against the SimplexController, SimplexSponsor and SimplexResolver ABIs describe "encoding" $ do @@ -36,24 +35,24 @@ badgeNameRegistrationTests = describe "store service name registration" $ do it "rejects an intent signed by another wallet" $ testVerifyOtherSigner g it "rejects an intent past its deadline" $ testVerifyExpired g it "rejects a secret that is not 32 bytes" $ testVerifyShortSecret g - it "sends nothing when the dry run reverts" $ testRevertedDryRun g + it "reads the register's dry run reverting as the sponsor's error" $ testRevertedDryRun g it "registers a name the client committed to without revealing it" $ testCommitThenRegister g testRegisterCalldataWithRecords :: TVar ChaChaDRG -> IO () testRegisterCalldataWithRecords g = do intent <- knownIntent g knownRegistration toHex (registerWithCreditCalldata intent) - `shouldBe` "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" + `shouldBe` "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" testRegisterCalldataWithoutRecords :: TVar ChaChaDRG -> IO () testRegisterCalldataWithoutRecords g = do - intent <- knownIntent g knownRegistration {rContactLinks = [], rChannelLinks = []} + intent <- knownIntent g knownRegistration {rContactLink = Nothing, rChannelLink = Nothing} toHex (registerWithCreditCalldata intent) `shouldBe` "c4bd2ab50000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000f486570000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000001000000000000000000000000009858effd232b4033e47d90003d41ec34ecaeda940000000000000000000000000000000000000000000000000000000003c2670011111111111111111111111111111111111111111111111111111111111111110000000000000000000000002279b7a0a67db372996a5fab50d91eaa73d2ebe6000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000762616b6572793100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000411d0b3a477c99fbcadada2937b71127bf6da202f5cd25856649829653d8cf6a8c0ce0afb8505e398e23b3b01fcb3b17ffcf82d8ba6d24e9b854506894b2864ecf1c00000000000000000000000000000000000000000000000000000000000000" testCommitCalldata :: IO () testCommitCalldata = - toHex (commitCalldata $ makeCommitment knownRegistration) `shouldBe` "f14fcbc843aeb4617085160f4dc7ad495d1119f39bca441276b1990123fd3ecb8a40a360" + toHex (commitCalldata $ makeCommitment knownRegistration) `shouldBe` "f14fcbc8810f0645b8d9839e3744bb956f9da4fa12bb51ec97459e08739c576a36cba0df" testVerifyOtherSigner :: TVar ChaChaDRG -> IO () testVerifyOtherSigner g = do @@ -73,23 +72,41 @@ testVerifyShortSecret g = do testRevertedDryRun :: TVar ChaChaDRG -> IO () testRevertedDryRun g = withFakeEthNode $ \node -> do - revertCalls node + -- viem's encodeErrorResult of InsufficientAllowance(10000, 2500) + setFault node "eth_estimateGas" $ revertFault $ fromHex "2a1b2dd8000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000009c4" intent <- knownIntent g knownRegistration - sendRegister g (chainClient node) intent `shouldReturn` Left (ChainError "execution reverted") - sentTransactions node `shouldReturn` [] + c <- newChainClient g $ fakeChainConfig node + estimateGas c fakeSponsor (registerWithCreditCalldata intent) `shouldReturn` Left (ChainReverted $ Just RNInsufficientAllowance) testCommitThenRegister :: TVar ChaChaDRG -> IO () testCommitThenRegister g = withFakeEthNode $ \node -> do + c <- newChainClient g $ fakeChainConfig node w <- newEphemeralWallet g ewAddress <$> walletFromCode g (redemptionCode w) `shouldReturn` ewAddress w let registration = knownRegistration {rOwner = ewAddress w} - commitment = makeCommitment registration - commitTx <- expectedTransaction g 0 controller $ commitCalldata commitment - sendCommit g (chainClient node) commitment `shouldReturn` Right (TxHash $ C.keccak256 commitTx) + commitCall = commitCalldata $ makeCommitment registration + commitTx <- expectedTransaction g 0 fakeController commitCall + send g c fakeController commitCall `shouldReturn` SignedTx commitTx (TxHash $ C.keccak256 commitTx) intent <- signRegisterIntent g domain w registration deadline verifyRegisterIntent domain deadline intent `shouldReturn` Right () - registerTx <- expectedTransaction g 1 sponsor $ registerWithCreditCalldata intent - sendRegister g (chainClient node) intent `shouldReturn` Right (TxHash $ C.keccak256 registerTx) + let registerCall = registerWithCreditCalldata intent + registerTx <- expectedTransaction g 1 fakeSponsor registerCall + send g c fakeSponsor registerCall `shouldReturn` SignedTx registerTx (TxHash $ C.keccak256 registerTx) + sentTransactions node `shouldReturn` [commitTx, registerTx] + +-- | The dry run, the registrar's next nonce and the fees, then the signed transaction sent and its hash checked. +send :: TVar ChaChaDRG -> ChainClient -> Address -> ByteString -> IO SignedTx +send g c@ChainClient {ccRegistrar} to calldata = do + gas <- right' =<< estimateGas c to calldata + nonce <- right' =<< transactionCount c ccRegistrar Pending + tip <- right' =<< maxPriorityFee c + Block {blockBaseFee} <- right' =<< latestBlock c + tx@SignedTx {stRaw, stHash} <- + right <$> signTransaction g c TxRequest {trTo = to, trData = calldata, trNonce = nonce, trGasLimit = gas, trMaxFeePerGas = 2 * blockBaseFee + tip, trMaxPriorityFeePerGas = tip} + sendRawTransaction c stRaw `shouldReturn` Right stHash + pure tx + where + right' = either (fail . show) pure -- fixtures @@ -102,8 +119,8 @@ knownRegistration = rDuration = 63072000, rSecret = B.replicate 32 0x11, rResolver = address "0x2279b7a0a67db372996a5fab50d91eaa73d2ebe6", - rContactLinks = ["https://smp.simplex.im/a#contact"], - rChannelLinks = ["https://smp1.simplex.im/c#one", "https://smp2.simplex.im/c#two"] + rContactLink = Just "https://smp.simplex.im/a#contact", + rChannelLink = Just "https://smp1.simplex.im/c#one" } knownIntent :: TVar ChaChaDRG -> Registration -> IO RegisterIntent @@ -114,34 +131,20 @@ knownIntent g r = do knownCode :: Text knownCode = "SN-00000-00000-00000-00000-00000-0VME2" -controller, sponsor :: Address -controller = address "0x0165878a594ca255338adfa4d48449f69242eb8f" -sponsor = address "0x9a676e781a523b5d0c0e43731313a708cb607508" - domain :: Eip712Domain -domain = sponsorDomain chainId sponsor - -chainId :: Word64 -chainId = 31337 +domain = sponsorDomain fakeChainId fakeSponsor deadline :: Word64 deadline = 4102444800 -registrarKey :: S.Secp256k1PrivateKey -registrarKey = right $ S.mkPrivateKey $ BA.replicate 32 0x46 - -chainClient :: FakeEthNode -> ChainClient -chainClient FakeEthNode {fnUrl, fnManager} = - ChainClient {ccManager = fnManager, ccRpcUrl = fnUrl, ccChainId = chainId, ccController = controller, ccSponsor = sponsor, ccRegistrarKey = registrarKey} - expectedTransaction :: TVar ChaChaDRG -> Word64 -> Address -> ByteString -> IO ByteString expectedTransaction g nonce to calldata = right <$> signEip1559Tx g - registrarKey + fakeRegistrarKey Eip1559Tx - { txChainId = chainId, + { txChainId = fakeChainId, txNonce = nonce, txMaxPriorityFeePerGas = fakeTip, txMaxFeePerGas = 2 * fakeBaseFee + fakeTip, @@ -157,5 +160,8 @@ address = right . strDecode toHex :: ByteString -> ByteString toHex = convertToBase Base16 +fromHex :: ByteString -> ByteString +fromHex = right . convertFromBase Base16 + right :: Either String a -> a right = either (error . ("unexpected Left: " <>)) id diff --git a/tests/Bots/StoreService/NamesChainTests.hs b/tests/Bots/StoreService/NamesChainTests.hs new file mode 100644 index 0000000000..874460ccbe --- /dev/null +++ b/tests/Bots/StoreService/NamesChainTests.hs @@ -0,0 +1,292 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} + +module Bots.StoreService.NamesChainTests (namesChainTests) where + +import Bots.StoreService.FakeEthNode +import Control.Concurrent.STM (TVar) +import Control.Exception (toException, try) +import Crypto.Random (ChaChaDRG) +import qualified Data.Aeson as J +import Data.ByteArray.Encoding (Base (Base16), convertFromBase) +import Data.ByteString (ByteString) +import qualified Data.ByteString as B +import qualified Data.Text as T +import Data.Time.Clock (diffUTCTime, getCurrentTime) +import Data.Word (Word64) +import qualified Network.HTTP.Client as HTTP +import qualified Simplex.Messaging.Crypto as C +import StoreService.Config (ChainConfig (..)) +import StoreService.Names.Abi (selector, uint256) +import StoreService.Names.Chain +import StoreService.Names.Revert +import Test.Hspec + +namesChainTests :: Spec +namesChainTests = describe "StoreService names: chain" $ do + g <- runIO C.newRandom + describe "reverts" $ do + it "names every contract error by the selector viem encodes it with" testRevertSelectors + it "reads a dry run's revert with data by its name" $ testDryRunRevertNamed g + it "reads an eth_call revert with data by its name" $ testCallRevertNamed g + it "reads ownerOf of a name nobody holds as a revert" $ testOwnerOfRevert g + it "reads a bare revert message without data as a revert without data, and one with a reason as unknown" $ testRevertWithoutData g + it "reads a revert of an unknown error as an unnamed revert" $ testUnknownRevert g + describe "failures" $ do + it "reads an RPC error as unavailable, without the URL" $ testRpcError g + it "gives up on a node that does not answer within the call's timeout" $ testTimeout g + it "reads an HTTP failure as unavailable" $ testHttpFailure g + it "reads a refused connection as unavailable, without the URL" $ testRefused g + it "refuses an answer over the size bound" $ testOversized g + it "reads a 2xx answer that is not JSON as unavailable, without quoting it" $ testNotJson g + it "cuts a node's long error message" $ testLongNodeMessage g + it "refuses a quantity over 256 bits, and a long one within the call's timeout" $ testLongQuantity g + it "keeps an HTTP failure's detail for the log, with the URL's host, path and query redacted" testFailureDetail + describe "reads" $ do + it "answers eth_call from the node by contract and calldata" $ testEthCall g + it "reads the latest block's number, time and base fee" $ testLatestBlock g + it "follows a transaction from sent to mined with its receipt and the nonces" $ testFollowTransaction g + describe "transactions" $ do + it "signs a transaction whose hash is the node's keccak256 of the raw bytes" $ testSignedHash g + it "refuses a gas estimate above the cap" $ testGasCap g + +-- | The custom errors of the four contracts' compiled ABIs, with viem's encodeErrorResult selectors. +viemSelectors :: [(ByteString, RevertName)] +viemSelectors = + [ ("5289653e", RNAlreadyFrozen), + ("836588c9", RNCommitmentNotFound), + ("74480cc9", RNCommitmentTooNew), + ("256e2216", RNCommitmentTooOld), + ("9a71997b", RNDurationTooShort), + ("a8cab3d1", RNFrozen), + ("2a1b2dd8", RNInsufficientAllowance), + ("11011294", RNInsufficientValue), + ("8d666f60", RNInvalidEVMAddress), + ("756688fe", RNInvalidNonce), + ("8baa579f", RNInvalidSignature), + ("21134988", RNLabelTooLong), + ("2d0c6794", RNMaxCommitmentAgeTooHigh), + ("3e5aa838", RNMaxCommitmentAgeTooLow), + ("ace8f2ce", RNMinCharLengthCanOnlyDecrease), + ("ce47b48d", RNMinCharLengthZero), + ("6357b884", RNMinCommitmentAgeZero), + ("477707e8", RNNameNotAvailable), + ("d17ee357", RNNameNotReserved), + ("e1bf11bf", RNNameReserved), + ("c4295eb6", RNNameTooShort), + ("70f8a4c9", RNNftGateCanOnlyBeDisabled), + ("6b1578c1", RNNftRequired), + ("c30734cc", RNNodeNotOwnedByRegistrar), + ("644d871f", RNNotBeneficiary), + ("42f058b4", RNNotNameOwner), + ("ff43b88f", RNNotOffered), + ("4632a8bf", RNNotOwnerOrBeneficiary), + ("df4795c7", RNNotSponsor), + ("9a0aeacd", RNNotSubnameRegistrar), + ("8a3c1cfb", RNOffsetOutOfBoundsError), + ("a9efcc18", RNOwnerMustBeCaller), + ("40866499", RNPublicSalesClosed), + ("bc7fd331", RNReasonRequired), + ("2bea818f", RNRecipientMustBeCaller), + ("37ed32e8", RNReentrantCall), + ("d3f605c4", RNResolverRequiredWhenDataSupplied), + ("27af646c", RNReverseRecordNotSupported), + ("0819bdcd", RNSignatureExpired), + ("90b8ec18", RNTransferFailed), + ("bf2f44f5", RNTransferToSelf), + ("0a059d71", RNUnexpiredCommitmentExists), + ("d92e233d", RNZeroAddress) + ] + +testRevertSelectors :: IO () +testRevertSelectors = do + map snd viemSelectors `shouldBe` filter (/= RNWithoutData) [minBound .. maxBound] + [(n, decodeRevert $ unhex sel <> uint256 (0 :: Int)) | (sel, n) <- viemSelectors] `shouldBe` [(n, Just n) | (_, n) <- viemSelectors] + decodeRevert (B.take 3 $ unhex "74480cc9") `shouldBe` Nothing + decodeRevert "" `shouldBe` Just RNWithoutData + +testDryRunRevertNamed :: TVar ChaChaDRG -> IO () +testDryRunRevertNamed g = withChain g $ \node c -> do + setFault node "eth_estimateGas" $ revertFault insufficientAllowance + estimateGas c fakeSponsor "\x01\x02\x03\x04" `shouldReturn` Left (ChainReverted $ Just RNInsufficientAllowance) + sentTransactions node `shouldReturn` [] + +testCallRevertNamed :: TVar ChaChaDRG -> IO () +testCallRevertNamed g = withChain g $ \node c -> do + answerCall node fakeController availableCall $ Reverts nameNotAvailable + ethCall c fakeController availableCall `shouldReturn` Left (ChainReverted $ Just RNNameNotAvailable) + +testOwnerOfRevert :: TVar ChaChaDRG -> IO () +testOwnerOfRevert g = withChain g $ \node c@ChainClient {ccConfig = ChainConfig {cBaseRegistrar}} -> do + let ownerOf = selector "ownerOf(uint256)" <> C.keccak256 "bakery1" + answerCall node cBaseRegistrar ownerOf $ Reverts "" + ethCall c cBaseRegistrar ownerOf `shouldReturn` Left (ChainReverted $ Just RNWithoutData) + +testRevertWithoutData :: TVar ChaChaDRG -> IO () +testRevertWithoutData g = withChain g $ \node c -> do + setFault node "eth_call" $ RpcError (-32000) "execution reverted" Nothing + ethCall c fakeController availableCall `shouldReturn` Left (ChainReverted $ Just RNWithoutData) + -- a reason kept in the message names a revert that had data, so it is not read as one without + setFault node "eth_call" $ RpcError 3 "execution reverted: ERC721: invalid token ID" Nothing + ethCall c fakeController availableCall `shouldReturn` Left (ChainReverted Nothing) + +testUnknownRevert :: TVar ChaChaDRG -> IO () +testUnknownRevert g = withChain g $ \node c -> do + -- viem's encodeErrorResult of Error("ERC721: invalid token ID"), not one of the contracts' own errors + setFault node "eth_call" $ revertFault $ unhex "08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000184552433732313a20696e76616c696420746f6b656e2049440000000000000000" + ethCall c fakeController availableCall `shouldReturn` Left (ChainReverted Nothing) + +testRpcError :: TVar ChaChaDRG -> IO () +testRpcError g = withChain g $ \node c -> do + setFault node "eth_call" $ RpcError (-32000) "header not found" Nothing + r <- ethCall c fakeController availableCall + r `shouldBe` Left (ChainUnavailable "eth_call: error -32000: header not found") + r `shouldNotSatisfy` mentionsUrl c + +testTimeout :: TVar ChaChaDRG -> IO () +testTimeout g = withChain g $ \node c -> do + ccTimeout c `shouldBe` 10000000 + setFault node "eth_getBlockByNumber" Hang + let short = c {ccTimeout = 300000} + start <- getCurrentTime + r <- latestBlock short + elapsed <- (`diffUTCTime` start) <$> getCurrentTime + r `shouldBe` Left (ChainUnavailable "eth_getBlockByNumber: timed out") + elapsed `shouldSatisfy` (< 2) + +testHttpFailure :: TVar ChaChaDRG -> IO () +testHttpFailure g = withChain g $ \node c -> do + setFault node "eth_maxPriorityFeePerGas" HttpFailure + maxPriorityFee c `shouldReturn` Left (ChainUnavailable "eth_maxPriorityFeePerGas: HTTP 502") + +testRefused :: TVar ChaChaDRG -> IO () +testRefused g = withFakeEthNode $ \node -> do + -- port 1 is privileged and nothing listens on it in the test container + c <- newChainClient g (fakeChainConfig node) {cRpcUrl = "http://127.0.0.1:1" <> secretPath} + r <- latestBlock c + r `shouldBe` Left (ChainUnavailable "eth_getBlockByNumber: connection failed") + r `shouldNotSatisfy` mentionsUrl c + +testOversized :: TVar ChaChaDRG -> IO () +testOversized g = withChain g $ \node c -> do + answerCall node fakeController availableCall $ Returns $ B.replicate (512 * 1024) 0 + ethCall c fakeController availableCall `shouldReturn` Left (ChainUnavailable "eth_call: response over 1048576 bytes") + +testNotJson :: TVar ChaChaDRG -> IO () +testNotJson g = withChain g $ \node c -> do + setFault node "eth_call" NotJson + ethCall c fakeController availableCall `shouldReturn` Left (ChainUnavailable "eth_call: not a JSON-RPC response") + +testLongNodeMessage :: TVar ChaChaDRG -> IO () +testLongNodeMessage g = withChain g $ \node c -> do + setFault node "eth_call" $ RpcError (-32000) (T.replicate 1000 "x") Nothing + ethCall c fakeController availableCall `shouldReturn` Left (ChainUnavailable $ "eth_call: error -32000: " <> T.replicate 200 "x") + +testLongQuantity :: TVar ChaChaDRG -> IO () +testLongQuantity g = withChain g $ \node c -> do + let fee digits = setFault node "eth_maxPriorityFeePerGas" (Answers $ J.String $ "0x" <> digits) >> maxPriorityFee c {ccTimeout = 300000} + notQuantity = Left (ChainUnavailable "eth_maxPriorityFeePerGas: not a JSON-RPC response: Error in $: not a quantity") + fee (T.replicate 63 "0" <> "7") `shouldReturn` Right 7 + fee (T.replicate 64 "0" <> "7") `shouldReturn` notQuantity + start <- getCurrentTime + fee (T.replicate 1000000 "f") `shouldReturn` notQuantity + elapsed <- (`diffUTCTime` start) <$> getCurrentTime + elapsed `shouldSatisfy` (< 1) + +testFailureDetail :: IO () +testFailureDetail = do + let url = "https://provider.example/v2/provider-api-key?key=abc" + req <- HTTP.parseRequest url + let detail = httpFailureDetail url . HTTP.HttpExceptionRequest req + redacted t = (t, filter (`T.isInfixOf` t) ["provider.example", "provider-api-key", "key=abc"]) `shouldBe` (t, []) + redacted $ detail $ HTTP.InvalidDestinationHost "provider.example" + redacted $ detail $ HTTP.ConnectionFailure $ toException $ userError $ "connect to " <> url + redacted $ httpFailureDetail url $ HTTP.InvalidUrlException url "Invalid URL" + manager <- HTTP.newManager HTTP.defaultManagerSettings + -- port 1 is privileged and nothing listens on it in the test container + let refusedUrl = "http://127.0.0.1:1" <> secretPath + refused <- try $ HTTP.parseRequest refusedUrl >>= (`HTTP.httpLbs` manager) + case refused of + Left e -> httpFailureDetail refusedUrl e `shouldSatisfy` ("ConnectionFailure" `T.isPrefixOf`) + Right _ -> expectationFailure "connected to port 1" + +testEthCall :: TVar ChaChaDRG -> IO () +testEthCall g = withChain g $ \node c -> do + answerCall node fakeController availableCall $ Returns $ uint256 (1 :: Int) + answerCall node fakeSponsor availableCall $ Returns $ uint256 (0 :: Int) + ethCall c fakeController availableCall `shouldReturn` Right (uint256 (1 :: Int)) + ethCall c fakeSponsor availableCall `shouldReturn` Right (uint256 (0 :: Int)) + ethCall c fakeController (selector "available(string)") `shouldReturn` Left (ChainUnavailable "eth_call: error -32000: no fake answer for this call") + +testLatestBlock :: TVar ChaChaDRG -> IO () +testLatestBlock g = withChain g $ \node c -> do + setBlock node 21000000 1798761600 + latestBlock c `shouldReturn` Right Block {blockNumber = 21000000, blockTimestamp = 1798761600, blockBaseFee = fakeBaseFee} + +testFollowTransaction :: TVar ChaChaDRG -> IO () +testFollowTransaction g = withChain g $ \node c@ChainClient {ccRegistrar} -> do + let unknown = TxHash $ B.replicate 32 0xee + transactionByHash c unknown `shouldReturn` Right Nothing + transactionReceipt c unknown `shouldReturn` Right Nothing + SignedTx {stRaw, stHash = hash@(TxHash h)} <- signed g c 0 + sendRawTransaction c stRaw `shouldReturn` Right hash + transactionByHash c hash `shouldReturn` Right (Just TxPending) + transactionReceipt c hash `shouldReturn` Right Nothing + transactionCount c ccRegistrar Latest `shouldReturn` Right 0 + transactionCount c ccRegistrar Pending `shouldReturn` Right 1 + block <- mine node [(h, False)] + transactionByHash c hash `shouldReturn` Right (Just $ TxMined block) + transactionReceipt c hash `shouldReturn` Right (Just Receipt {receiptSuccess = False, receiptBlock = block}) + transactionCount c ccRegistrar Latest `shouldReturn` Right 1 + +testSignedHash :: TVar ChaChaDRG -> IO () +testSignedHash g = withChain g $ \node c -> do + SignedTx {stRaw, stHash} <- signed g c 7 + stHash `shouldBe` TxHash (C.keccak256 stRaw) + sendRawTransaction c stRaw `shouldReturn` Right stHash + sentTransactions node `shouldReturn` [stRaw] + +testGasCap :: TVar ChaChaDRG -> IO () +testGasCap g = withFakeEthNode $ \node -> do + let config = fakeChainConfig node + atCap <- newChainClient g config {cGasLimitCap = fakeGas} + estimateGas atCap fakeController availableCall `shouldReturn` Right fakeGas + belowCap <- newChainClient g config {cGasLimitCap = fakeGas - 1} + estimateGas belowCap fakeController availableCall `shouldReturn` Left (ChainGasAboveCap fakeGas) + +-- fixtures + +withChain :: TVar ChaChaDRG -> (FakeEthNode -> ChainClient -> IO a) -> IO a +withChain g action = withFakeEthNode $ \node -> do + c <- newChainClient g (fakeChainConfig node) {cRpcUrl = fnUrl node <> secretPath} + action node c + +-- | Where a provider puts its API key. +secretPath :: String +secretPath = "/v2/provider-api-key" + +mentionsUrl :: ChainClient -> Either ChainError a -> Bool +mentionsUrl ChainClient {ccConfig = ChainConfig {cRpcUrl}} = \case + Left (ChainUnavailable t) -> any (`T.isInfixOf` t) [T.pack cRpcUrl, T.pack secretPath, "127.0.0.1"] + _ -> False + +signed :: TVar ChaChaDRG -> ChainClient -> Word64 -> IO SignedTx +signed g c nonce = + either error id + <$> signTransaction g c TxRequest {trTo = fakeController, trData = availableCall, trNonce = nonce, trGasLimit = fakeGas, trMaxFeePerGas = 2 * fakeBaseFee + fakeTip, trMaxPriorityFeePerGas = fakeTip} + +-- | controller.available("bakery1"), viem's encodeFunctionData +availableCall :: ByteString +availableCall = unhex "aeb8ce9b0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000762616b6572793100000000000000000000000000000000000000000000000000" + +-- | viem's encodeErrorResult of InsufficientAllowance(10000, 2500) +insufficientAllowance :: ByteString +insufficientAllowance = unhex "2a1b2dd8000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000009c4" + +-- | viem's encodeErrorResult of NameNotAvailable("bakery1") +nameNotAvailable :: ByteString +nameNotAvailable = unhex "477707e80000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000762616b6572793100000000000000000000000000000000000000000000000000" + +unhex :: ByteString -> ByteString +unhex = either error id . convertFromBase Base16 diff --git a/tests/Bots/StoreService/NamesContractsTests.hs b/tests/Bots/StoreService/NamesContractsTests.hs new file mode 100644 index 0000000000..03c6da0816 --- /dev/null +++ b/tests/Bots/StoreService/NamesContractsTests.hs @@ -0,0 +1,376 @@ +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} + +module Bots.StoreService.NamesContractsTests + ( namesContractsTests, + withContracts, + answerRegistrar, + answerRegistered, + registrarOf, + resolverOf, + rentPriceCall, + rentPriceAnswer, + now, + year, + gracePeriod, + otherResolver, + nameExpiresCall, + reservedNamesCall, + contactTextCall, + channelTextCall, + noncesCall, + alice, + availableCall, + minCommitmentAgeCall, + maxCommitmentAgeCall, + unhex, + ) +where + +import Bots.StoreService.FakeEthNode +import Control.Concurrent.STM (TVar) +import Control.Monad (forM_) +import Crypto.Random (ChaChaDRG) +import Data.ByteArray.Encoding (Base (Base16), convertFromBase) +import Data.ByteString (ByteString) +import qualified Data.ByteString as B +import Data.Time.Clock (NominalDiffTime, diffUTCTime, getCurrentTime) +import Data.Word (Word64) +import qualified Simplex.Messaging.Crypto as C +import Simplex.Messaging.Encoding.String (strDecode) +import Simplex.Messaging.Eth.Address (Address) +import Simplex.Messaging.SimplexName (LabelHash, SimplexTLD (..), labelHash) +import StoreService.Config (ChainConfig (..)) +import StoreService.Names.Abi +import StoreService.Names.Chain +import StoreService.Names.Contracts +import StoreService.Names.Registration (labelNode, namehash, nodeBytes) +import StoreService.Names.Revert (RevertName (..)) +import Test.Hspec + +namesContractsTests :: Spec +namesContractsTests = describe "StoreService names: contracts" $ do + -- the calldata and answers marked viem are viem 2.33.3's encodeFunctionData and encodeFunctionResult + -- with the ABIs of ens-contracts PR #36, so a read the fake node answers sends viem's calldata + g <- runIO C.newRandom + it "builds a name's node from its label hash as viem's namehash" testNode + describe "status" $ do + it "reads a name nobody holds or reserved as available" $ testAvailable g + it "reads a reserved name" $ testReserved g + it "reads a registered name with the registry's owner and resolver" $ testRegistered g + it "keeps a name registered to the last second of its grace period" $ testGracePeriod g + it "reads the registry and the grace period once, and again after a failed read" $ testRegistrarOnce g + describe "records" $ do + it "reads the default resolver's records and the owner's nonce" $ testRecords g + it "reads no records from another resolver" $ testOtherResolver g + describe "prices" $ do + it "quotes 6, 7 and 12 letters at the launch list for 2 years" $ testLaunchPrices g + describe "other reads" $ do + it "reads the sponsor's and the resolver's nonces from their own contracts" $ testNonces g + it "reads ownerOf's revert without data as nobody" $ testOwnerOfNobody g + it "reads any other ownerOf revert or failure as a failed read" $ testOwnerOfFailed g + it "reads a commitment's time, none as Nothing" $ testCommitmentTime g + it "reads the controller's availability and the name's expiry" $ testAvailability g + it "reads the commitment ages once" $ testCommitmentAges g + describe "failures" $ do + it "fails a status on a failed read, never reading it as available" $ testFailedRead g + it "fails a read whose answer does not decode or does not fit" $ testMalformed g + it "fails a status within its deadline when one method hangs" $ testStatusDeadline g + it "fails records within their deadline when the calls hang" $ testRecordsDeadline g + it "reads a status and records within a deadline only concurrent reads meet" $ testConcurrentReads g + +testNode :: IO () +testNode = do + nodeBytes (labelNode TLDSimplex $ labelHash "alicebakery") `shouldBe` aliceNode + nodeBytes (namehash TLDSimplex "alicebakery") `shouldBe` aliceNode + +testAvailable :: TVar ChaChaDRG -> IO () +testAvailable g = withContracts g $ \node ct -> do + answerRegistrar node + setBlock node 100 now + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (0 :: Int) + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + nameStatus ct alice `shouldReturn` Right NSAvailable + +testReserved :: TVar ChaChaDRG -> IO () +testReserved g = withContracts g $ \node ct -> do + answerRegistrar node + setBlock node 100 now + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (0 :: Int) + -- viem: reservedNames answering Reason 1 + answerCall node fakeController reservedNamesCall $ Returns $ unhex "0000000000000000000000000000000000000000000000000000000000000001" + nameStatus ct alice `shouldReturn` Right NSReserved + +testRegistered :: TVar ChaChaDRG -> IO () +testRegistered g = withContracts g $ \node ct -> do + answerRegistrar node + answerRegistered node (resolverOf node) + setBlock node 100 now + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (now + year) + nameStatus ct alice `shouldReturn` Right (NSRegistered $ registeredAlice (resolverOf node) (now + year)) + +testGracePeriod :: TVar ChaChaDRG -> IO () +testGracePeriod g = withContracts g $ \node ct -> do + answerRegistrar node + answerRegistered node (resolverOf node) + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + let expired = now - year + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 expired + setBlock node 100 $ expired + gracePeriod + nameStatus ct alice `shouldReturn` Right (NSRegistered $ registeredAlice (resolverOf node) expired) + setBlock node 101 $ expired + gracePeriod + 1 + nameStatus ct alice `shouldReturn` Right NSAvailable + +testRegistrarOnce :: TVar ChaChaDRG -> IO () +testRegistrarOnce g = withContracts g $ \node ct -> do + setBlock node 100 now + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (0 :: Int) + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + nameStatus ct alice `shouldReturn` Left (ChainUnavailable "eth_call: error -32000: no fake answer for this call") + answerRegistrar node + nameStatus ct alice `shouldReturn` Right NSAvailable + answerCall node (registrarOf node) ensCall $ Reverts "" + answerCall node (registrarOf node) gracePeriodCall $ Reverts "" + nameStatus ct alice `shouldReturn` Right NSAvailable + +testRecords :: TVar ChaChaDRG -> IO () +testRecords g = withContracts g $ \node ct -> do + let resolver = resolverOf node + answerCall node resolver contactTextCall $ Returns contactTextAnswer + -- an unset record is the empty string + answerCall node resolver channelTextCall $ Returns $ abiTuple [Dynamic $ abiBytes ""] + answerCall node resolver noncesCall $ Returns $ uint256 (3 :: Int) + nameRecords ct alice (registeredAlice resolver $ now + year) + `shouldReturn` Right (Just NameRecords {rdContact = "https://smp8.simplex.im/a#Y8m3", rdChannel = "", rdNonce = 3}) + textRecord ct alice "simplex.contact" `shouldReturn` Right "https://smp8.simplex.im/a#Y8m3" + +testOtherResolver :: TVar ChaChaDRG -> IO () +testOtherResolver g = withContracts g $ \_ ct -> do + nameRecords ct alice (registeredAlice otherResolver $ now + year) `shouldReturn` Right Nothing + +testLaunchPrices :: TVar ChaChaDRG -> IO () +testLaunchPrices g = withContracts g $ \node ct -> do + -- viem: rentPriceUSD answering {base: 40000 * 10^16, premium: 0} + answerCall node fakeController (rentPriceCall 6) $ Returns $ unhex "000000000000000000000000000000000000000000000015af1d78b58c4000000000000000000000000000000000000000000000000000000000000000000000" + answerCall node fakeController (rentPriceCall 7) $ Returns $ rentPriceAnswer 20000 + answerCall node fakeController (rentPriceCall 12) $ Returns $ rentPriceAnswer 10000 + mapM (\len -> chainPriceCents ct len 2) [6, 7, 12] `shouldReturn` [Right 40000, Right 20000, Right 10000] + +testNonces :: TVar ChaChaDRG -> IO () +testNonces g = withContracts g $ \node ct -> do + answerCall node fakeSponsor noncesCall $ Returns $ uint256 (5 :: Int) + answerCall node (resolverOf node) noncesCall $ Returns $ uint256 (3 :: Int) + sponsorNonce ct owner `shouldReturn` Right 5 + resolverNonce ct owner `shouldReturn` Right 3 + +testOwnerOfNobody :: TVar ChaChaDRG -> IO () +testOwnerOfNobody g = withContracts g $ \node ct -> do + answerCall node (registrarOf node) ownerOfCall $ Returns $ addressWord owner + ownerOfToken ct Latest alice `shouldReturn` Right (Just owner) + -- the registrar's require(expiries[tokenId] > block.timestamp), as anvil answers it with "0x" and reth without data + answerCall node (registrarOf node) ownerOfCall $ Reverts "" + ownerOfToken ct Latest alice `shouldReturn` Right Nothing + setFault node "eth_call" $ RpcError 3 "execution reverted" Nothing + ownerOfToken ct Latest alice `shouldReturn` Right Nothing + +testOwnerOfFailed :: TVar ChaChaDRG -> IO () +testOwnerOfFailed g = withContracts g $ \node ct -> do + -- viem's encodeErrorResult of Error("ERC721: invalid token ID") + answerCall node (registrarOf node) ownerOfCall $ Reverts $ unhex "08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000184552433732313a20696e76616c696420746f6b656e2049440000000000000000" + ownerOfToken ct Latest alice `shouldReturn` Left (ChainReverted Nothing) + -- viem's encodeErrorResult of ReentrantCall() + answerCall node (registrarOf node) ownerOfCall $ Reverts $ unhex "37ed32e8" + ownerOfToken ct Latest alice `shouldReturn` Left (ChainReverted $ Just RNReentrantCall) + -- a node or proxy that keeps the reason in the message but drops the data + setFault node "eth_call" $ RpcError (-32000) "execution reverted: ERC721: invalid token ID" Nothing + ownerOfToken ct Latest alice `shouldReturn` Left (ChainReverted Nothing) + setFault node "eth_call" HttpFailure + ownerOfToken ct Latest alice `shouldReturn` Left (ChainUnavailable "eth_call: HTTP 502") + +testCommitmentTime :: TVar ChaChaDRG -> IO () +testCommitmentTime g = withContracts g $ \node ct -> do + answerCall node fakeController commitmentsCall $ Returns $ uint256 (0 :: Int) + commitmentTime ct commitment `shouldReturn` Right Nothing + answerCall node fakeController commitmentsCall $ Returns $ uint256 now + commitmentTime ct commitment `shouldReturn` Right (Just now) + +testAvailability :: TVar ChaChaDRG -> IO () +testAvailability g = withContracts g $ \node ct -> do + answerCall node fakeController availableCall $ Returns $ uint256 (1 :: Int) + controllerAvailable ct "alicebakery" `shouldReturn` Right True + answerCall node fakeController availableCall $ Returns $ uint256 (0 :: Int) + controllerAvailable ct "alicebakery" `shouldReturn` Right False + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (now + year) + nameExpires ct Latest alice `shouldReturn` Right (now + year) + +testCommitmentAges :: TVar ChaChaDRG -> IO () +testCommitmentAges g = withContracts g $ \node ct -> do + answerCall node fakeController minCommitmentAgeCall $ Returns $ uint256 (60 :: Int) + answerCall node fakeController maxCommitmentAgeCall $ Returns $ uint256 (86400 :: Int) + commitmentAges ct `shouldReturn` Right CommitmentAges {caMin = 60, caMax = 86400} + answerCall node fakeController maxCommitmentAgeCall $ Returns $ uint256 (3600 :: Int) + commitmentAges ct `shouldReturn` Right CommitmentAges {caMin = 60, caMax = 86400} + +testFailedRead :: TVar ChaChaDRG -> IO () +testFailedRead g = withContracts g $ \node ct -> do + answerRegistrar node + setBlock node 100 now + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + answerCall node (registrarOf node) nameExpiresCall $ Reverts "" + nameStatus ct alice `shouldReturn` Left (ChainReverted $ Just RNWithoutData) + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (0 :: Int) + setFault node "eth_getBlockByNumber" HttpFailure + nameStatus ct alice `shouldReturn` Left (ChainUnavailable "eth_getBlockByNumber: HTTP 502") + clearFault node "eth_getBlockByNumber" + answerCall node fakeController reservedNamesCall $ Reverts "" + nameStatus ct alice `shouldReturn` Left (ChainReverted $ Just RNWithoutData) + +testMalformed :: TVar ChaChaDRG -> IO () +testMalformed g = withContracts g $ \node ct -> do + answerCall node (registrarOf node) nameExpiresCall $ Returns $ B.replicate 31 0 + nameExpires ct Latest alice `shouldReturn` Left (ChainUnavailable "eth_call: nameExpires(uint256) answered AEShort") + answerCall node fakeSponsor noncesCall $ Returns $ uint256 (toInteger (maxBound :: Word64) + 1) + sponsorNonce ct owner `shouldReturn` Left (ChainUnavailable "eth_call: nonces(address) answered AERange") + +testStatusDeadline :: TVar ChaChaDRG -> IO () +testStatusDeadline g = withContracts g $ \node ct -> do + answerRegistrar node + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (0 :: Int) + answerCall node fakeController reservedNamesCall $ Returns $ uint256 (0 :: Int) + setFault node "eth_getBlockByNumber" Hang + elapsed <- timed $ nameStatus ct {ctDeadline = testDeadline} alice `shouldReturn` Left (ChainUnavailable "name status: timed out") + elapsed `shouldSatisfy` (< 2) + clearFault node "eth_getBlockByNumber" + nameStatus ct {ctDeadline = testDeadline} alice `shouldReturn` Right NSAvailable + +testRecordsDeadline :: TVar ChaChaDRG -> IO () +testRecordsDeadline g = withContracts g $ \node ct -> do + setFault node "eth_call" Hang + elapsed <- timed $ nameRecords ct {ctDeadline = testDeadline} alice (registeredAlice (resolverOf node) $ now + year) `shouldReturn` Left (ChainUnavailable "name records: timed out") + elapsed `shouldSatisfy` (< 2) + +-- | Each slow read takes a third of the deadline or more, so the status's reads in sequence (four) or the records' (three) +-- pass it, while their concurrent rounds (two and one) meet it. +testConcurrentReads :: TVar ChaChaDRG -> IO () +testConcurrentReads g = withContracts g $ \node ct -> do + let resolver = resolverOf node + ct' = ct {ctDeadline = concurrentDeadline} + registered = registeredAlice resolver (now + year) + answerRegistrar node + answerRegistered node resolver + setBlock node 100 now + answerCall node (registrarOf node) nameExpiresCall $ Returns $ uint256 (now + year) + answerCall node resolver contactTextCall $ Returns contactTextAnswer + answerCall node resolver channelTextCall $ Returns $ abiTuple [Dynamic $ abiBytes ""] + answerCall node resolver noncesCall $ Returns $ uint256 (3 :: Int) + -- the registrar's constants are read once, so this read takes them out of the timed ones + nameStatus ct alice `shouldReturn` Right (NSRegistered registered) + forM_ ["eth_call", "eth_getBlockByNumber"] $ \m -> setFault node m $ Slow $ concurrentDeadline * 2 `div` 5 + nameStatus ct' alice `shouldReturn` Right (NSRegistered registered) + forM_ ["eth_call", "eth_getBlockByNumber"] $ \m -> setFault node m $ Slow $ concurrentDeadline * 3 `div` 5 + nameRecords ct' alice registered `shouldReturn` Right (Just NameRecords {rdContact = "https://smp8.simplex.im/a#Y8m3", rdChannel = "", rdNonce = 3}) + +-- fixtures + +concurrentDeadline :: Int +concurrentDeadline = 1500000 + +-- | Far below a call's 10-second timeout, so only the deadline can end a hung read in time. +testDeadline :: Int +testDeadline = 300000 + +timed :: IO () -> IO NominalDiffTime +timed action = do + start <- getCurrentTime + action + (`diffUTCTime` start) <$> getCurrentTime + +withContracts :: TVar ChaChaDRG -> (FakeEthNode -> Contracts -> IO a) -> IO a +withContracts g action = withFakeEthNode $ \node -> do + ct <- newContracts TLDSimplex =<< newChainClient g (fakeChainConfig node) + action node ct + +answerRegistrar :: FakeEthNode -> IO () +answerRegistrar node = do + answerCall node (registrarOf node) ensCall $ Returns $ addressWord registry + answerCall node (registrarOf node) gracePeriodCall $ Returns $ uint256 gracePeriod + +answerRegistered :: FakeEthNode -> Address -> IO () +answerRegistered node resolver = do + answerCall node registry registryOwnerCall $ Returns $ addressWord owner + answerCall node registry registryResolverCall $ Returns $ addressWord resolver + +registeredAlice :: Address -> Word64 -> RegisteredName +registeredAlice rnResolver rnExpiresAt = RegisteredName {rnOwner = owner, rnResolver, rnExpiresAt, rnGracePeriod = toInteger gracePeriod} + +registrarOf, resolverOf :: FakeEthNode -> Address +registrarOf = cBaseRegistrar . fakeChainConfig +resolverOf = cResolver . fakeChainConfig + +rentPriceAnswer :: Integer -> ByteString +rentPriceAnswer cents = uint256 (cents * 10 ^ (16 :: Int)) <> uint256 (0 :: Int) + +-- viem: text answering "https://smp8.simplex.im/a#Y8m3" +contactTextAnswer :: ByteString +contactTextAnswer = unhex "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001e68747470733a2f2f736d70382e73696d706c65782e696d2f612359386d330000" + +-- 2027-01-01, the term start +now :: Word64 +now = 1798761600 + +year, gracePeriod :: Word64 +year = 31536000 +gracePeriod = 7776000 + +alice :: LabelHash +alice = labelHash "alicebakery" + +-- viem: namehash("alicebakery.simplex") +aliceNode :: ByteString +aliceNode = unhex "0f4104919a21c22f566d9c7947c7c7d8addbf546c973851a7e449276ea54ec1a" + +commitment :: ByteString +commitment = unhex "f8096c3f3cfbadc9f3a108d2c586ccc816c0510711c8d6228aa4fa507324d30c" + +owner, registry, otherResolver :: Address +owner = address "0x014f9c09cceedef1b713110d04d3a07d5b5d9b73" +registry = address "0x5fbdb2315678afecb367f032d93f642f64180aa3" +otherResolver = address "0x4826533b4897376654bb4d4ad88b7fafd0c98528" + +-- viem's calldata for the reads + +ensCall, gracePeriodCall, nameExpiresCall, ownerOfCall, reservedNamesCall, registryOwnerCall, registryResolverCall :: ByteString +ensCall = unhex "3f15457f" +gracePeriodCall = unhex "c1a287e2" +nameExpiresCall = unhex "d6e4fa86bcc46b7948ff6be55bc3ff4db5bc4be16638f29e818a89244dae11caaed7c9c6" +ownerOfCall = unhex "6352211ebcc46b7948ff6be55bc3ff4db5bc4be16638f29e818a89244dae11caaed7c9c6" +reservedNamesCall = unhex "389c0748bcc46b7948ff6be55bc3ff4db5bc4be16638f29e818a89244dae11caaed7c9c6" +registryOwnerCall = unhex "02571be30f4104919a21c22f566d9c7947c7c7d8addbf546c973851a7e449276ea54ec1a" +registryResolverCall = unhex "0178b8bf0f4104919a21c22f566d9c7947c7c7d8addbf546c973851a7e449276ea54ec1a" + +contactTextCall, channelTextCall, noncesCall :: ByteString +contactTextCall = unhex "59d1d43c0f4104919a21c22f566d9c7947c7c7d8addbf546c973851a7e449276ea54ec1a0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000f73696d706c65782e636f6e746163740000000000000000000000000000000000" +channelTextCall = unhex "59d1d43c0f4104919a21c22f566d9c7947c7c7d8addbf546c973851a7e449276ea54ec1a0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000f73696d706c65782e6368616e6e656c0000000000000000000000000000000000" +noncesCall = unhex "7ecebe00000000000000000000000000014f9c09cceedef1b713110d04d3a07d5b5d9b73" + +-- | rentPriceUSD("a" × length, 2 years) +rentPriceCall :: Int -> ByteString +rentPriceCall = \case + 6 -> unhex "9ff7ec0900000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000003c2670000000000000000000000000000000000000000000000000000000000000000066161616161610000000000000000000000000000000000000000000000000000" + 7 -> unhex "9ff7ec0900000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000003c2670000000000000000000000000000000000000000000000000000000000000000076161616161616100000000000000000000000000000000000000000000000000" + 11 -> unhex "9ff7ec0900000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000003c26700000000000000000000000000000000000000000000000000000000000000000b6161616161616161616161000000000000000000000000000000000000000000" + 12 -> unhex "9ff7ec0900000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000003c26700000000000000000000000000000000000000000000000000000000000000000c6161616161616161616161610000000000000000000000000000000000000000" + len -> error $ "no viem vector for length " <> show len + +commitmentsCall, availableCall, minCommitmentAgeCall, maxCommitmentAgeCall :: ByteString +commitmentsCall = unhex "839df945f8096c3f3cfbadc9f3a108d2c586ccc816c0510711c8d6228aa4fa507324d30c" +availableCall = unhex "aeb8ce9b0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000b616c69636562616b657279000000000000000000000000000000000000000000" +minCommitmentAgeCall = unhex "8d839ffe" +maxCommitmentAgeCall = unhex "ce1e09c0" + +unhex :: ByteString -> ByteString +unhex = either error id . convertFromBase Base16 + +address :: ByteString -> Address +address = either error id . strDecode diff --git a/tests/Test.hs b/tests/Test.hs index c3ba84cdf1..3d2fe17bab 100644 --- a/tests/Test.hs +++ b/tests/Test.hs @@ -10,7 +10,9 @@ import Bots.StoreService.ConfigTests import Bots.StoreService.GroupIntegrationTests import Bots.StoreService.GroupTests import Bots.StoreService.NameRegistrationTests +import Bots.StoreService.NamesChainTests import Bots.StoreService.NamesCodesTests +import Bots.StoreService.NamesContractsTests import Bots.StoreService.NamesLabelTests import Bots.StoreService.StoreVerifierTests import Bots.StoreService.StripeTests @@ -90,7 +92,10 @@ main = do badgeStripeTests badgeNameRegistrationTests badgeStoreVerifierTests + namesConfigTests + namesChainTests namesCodesTests + namesContractsTests namesLabelTests describe "SimpleX chat markdown" markdownTests describe "JSON Tests" jsonTests