fix: sql transaction consistency (#1410)

* feat: savepoint transactions

* refactor: db-controller

* refactor: use transactions in all routes

* test: fix unit tests

* fix: bns test status code

* fix: name redirects

* fix: bns status tests

* fix: rosetta test suite

* ci: security patch

* fix: instead of savepoint, run queries directly

* feat: use async_hooks to check for open transactions

* fix: add usage name to transaction ctx

* feat: pg tx consistency in write store

* feat: store scoped connection in async context

* fix: revert unnecessary changes

* test: transaction consistency

* fix: bns tests

* fix: rosetta status tests

* fix: bns integration tests

Author: rafaelcr

src/api/controllers/db-controller.ts

@@ -11,6 +11,14 @@ import {
   setETagCacheHeaders,
 } from '../../../api/controllers/cache-controller';
 
+class NameRedirectError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.message = message;
+    this.name = this.constructor.name;
+  }
+}
+
 export function createBnsNamesRouter(db: PgStore, chainId: ChainID): express.Router {
   const router = express.Router();
   const cacheHandler = getETagCacheHandler(db);
@@ -85,64 +93,77 @@ export function createBnsNamesRouter(db: PgStore, chainId: ChainID): express.Rou
     asyncHandler(async (req, res, next) => {
       const { name } = req.params;
       const includeUnanchored = isUnanchoredRequest(req, res, next);
-      let nameInfoResponse: BnsGetNameInfoResponse;
-      // Subdomain case
-      if (name.split('.').length == 3) {
-        const subdomainQuery = await db.getSubdomain({ subdomain: name, includeUnanchored });
-        if (!subdomainQuery.found) {
-          const namePart = name.split('.').slice(1).join('.');
-          const resolverResult = await db.getSubdomainResolver({ name: namePart });
-          if (resolverResult.found) {
-            if (resolverResult.result === '') {
-              res.status(404).json({ error: `missing resolver from a malformed zonefile` });
-              return;
+
+      await db
+        .sqlTransaction(async sql => {
+          let nameInfoResponse: BnsGetNameInfoResponse;
+          // Subdomain case
+          if (name.split('.').length == 3) {
+            const subdomainQuery = await db.getSubdomain({
+              subdomain: name,
+              includeUnanchored,
+            });
+            if (!subdomainQuery.found) {
+              const namePart = name.split('.').slice(1).join('.');
+              const resolverResult = await db.getSubdomainResolver({ name: namePart });
+              if (resolverResult.found) {
+                if (resolverResult.result === '') {
+                  throw { error: `missing resolver from a malformed zonefile` };
+                }
+                throw new NameRedirectError(`${resolverResult.result}/v1/names${req.url}`);
+              }
+              throw { error: `cannot find subdomain ${name}` };
+            }
+            const { result } = subdomainQuery;
+
+            nameInfoResponse = {
+              address: result.owner,
+              blockchain: bnsBlockchain,
+              last_txid: result.tx_id,
+              resolver: result.resolver,
+              status: 'registered_subdomain',
+              zonefile: result.zonefile,
+              zonefile_hash: result.zonefile_hash,
+            };
+          } else {
+            const nameQuery = await db.getName({
+              name,
+              includeUnanchored: includeUnanchored,
+              chainId: chainId,
+            });
+            if (!nameQuery.found) {
+              throw { error: `cannot find name ${name}` };
             }
-            res.redirect(`${resolverResult.result}/v1/names${req.url}`);
-            return;
+            const { result } = nameQuery;
+            nameInfoResponse = {
+              address: result.address,
+              blockchain: bnsBlockchain,
+              expire_block: result.expire_block,
+              grace_period: result.grace_period,
+              last_txid: result.tx_id ? result.tx_id : '',
+              resolver: result.resolver,
+              status: result.status ? result.status : '',
+              zonefile: result.zonefile,
+              zonefile_hash: result.zonefile_hash,
+            };
           }
-          res.status(404).json({ error: `cannot find subdomain ${name}` });
-          return;
-        }
-        const { result } = subdomainQuery;
 
-        nameInfoResponse = {
-          address: result.owner,
-          blockchain: bnsBlockchain,
-          last_txid: result.tx_id,
-          resolver: result.resolver,
-          status: 'registered_subdomain',
-          zonefile: result.zonefile,
-          zonefile_hash: result.zonefile_hash,
-        };
-      } else {
-        const nameQuery = await db.getName({
-          name,
-          includeUnanchored: includeUnanchored,
-          chainId: chainId,
+          const response = Object.fromEntries(
+            Object.entries(nameInfoResponse).filter(([_, v]) => v != null)
+          );
+          return response;
+        })
+        .then(response => {
+          setETagCacheHeaders(res);
+          res.json(response);
+        })
+        .catch(error => {
+          if (error instanceof NameRedirectError) {
+            res.redirect(error.message);
+          } else {
+            res.status(400).json(error);
+          }
         });
-        if (!nameQuery.found) {
-          res.status(404).json({ error: `cannot find name ${name}` });
-          return;
-        }
-        const { result } = nameQuery;
-        nameInfoResponse = {
-          address: result.address,
-          blockchain: bnsBlockchain,
-          expire_block: result.expire_block,
-          grace_period: result.grace_period,
-          last_txid: result.tx_id ? result.tx_id : '',
-          resolver: result.resolver,
-          status: result.status ? result.status : '',
-          zonefile: result.zonefile,
-          zonefile_hash: result.zonefile_hash,
-        };
-      }
-
-      const response = Object.fromEntries(
-        Object.entries(nameInfoResponse).filter(([_, v]) => v != null)
-      );
-      setETagCacheHeaders(res);
-      res.json(response);
     })
   );
 

src/api/routes/address.ts

@@ -36,22 +36,31 @@ export function createBnsNamespacesRouter(db: PgStore): express.Router {
       const { tld } = req.params;
       const page = parsePagingQueryInput(req.query.page ?? 0);
       const includeUnanchored = isUnanchoredRequest(req, res, next);
-      const response = await db.getNamespace({ namespace: tld, includeUnanchored });
-      if (!response.found) {
-        res.status(404).json(BnsErrors.NoSuchNamespace);
-      } else {
-        const { results } = await db.getNamespaceNamesList({
-          namespace: tld,
-          page,
-          includeUnanchored,
-        });
-        if (results.length === 0 && req.query.page) {
-          res.status(400).json(BnsErrors.InvalidPageNumber);
-        } else {
+      await db
+        .sqlTransaction(async sql => {
+          const response = await db.getNamespace({ namespace: tld, includeUnanchored });
+          if (!response.found) {
+            throw BnsErrors.NoSuchNamespace;
+          } else {
+            const { results } = await db.getNamespaceNamesList({
+              namespace: tld,
+              page,
+              includeUnanchored,
+            });
+            if (results.length === 0 && req.query.page) {
+              throw BnsErrors.InvalidPageNumber;
+            } else {
+              return results;
+            }
+          }
+        })
+        .then(results => {
           setETagCacheHeaders(res);
           res.json(results);
-        }
-      }
+        })
+        .catch(error => {
+          res.status(400).json(error);
+        });
     })
   );