[FEATURE] adds blockaid scan tx service method and route

src/helper/error.ts

@@ -20,4 +20,5 @@ export const ERROR = {
   },
   INVALID_RUN_MODE: "invalid run mode",
   UNABLE_TO_SCAN_SITE: "unable to scan site using blockaid",
+  UNABLE_TO_SCAN_TX: "unable to scan tx using blockaid",
 };

src/route/index.ts

@@ -534,6 +534,42 @@ export async function initApiServer(
         },
       });
 
+      instance.route({
+        method: "GET",
+        url: "/scan-tx",
+        schema: {
+          querystring: {
+            ["tx_xdr"]: {
+              type: "string",
+            },
+            ["network"]: {
+              type: "string",
+              validator: (qStr: string) => isNetwork(qStr),
+            },
+          },
+        },
+        handler: async (
+          request: FastifyRequest<{
+            Querystring: {
+              ["tx_xdr"]: string;
+              ["network"]: NetworkNames;
+            };
+          }>,
+          reply
+        ) => {
+          const { tx_xdr, network } = request.query;
+          try {
+            const { data, error } = await blockAidService.scanTx(
+              tx_xdr,
+              network
+            );
+            return reply.code(error ? 400 : 200).send({ data, error });
+          } catch (error) {
+            return reply.code(500).send(ERROR.SERVER_ERROR);
+          }
+        },
+      });
+
       instance.route({
         method: "POST",
         url: "/subscription/token",

src/service/blockaid/index.ts

@@ -1,8 +1,15 @@
 import Blockaid from "@blockaid/client";
 import Prometheus from "prom-client";
 import { Logger } from "pino";
+import { Networks, TransactionBuilder } from "stellar-sdk";
 
 import { ERROR } from "../../helper/error";
+import { NetworkNames } from "../../helper/validate";
+
+const NetworkNameBlockaid: { [index: string]: "pubnet" | "futurenet" } = {
+  PUBLIC: "pubnet",
+  FUTURENET: "futurenet",
+};
 
 export class BlockAidService {
   blockAidClient: Blockaid;
@@ -38,4 +45,34 @@ export class BlockAidService {
       return { data: null, error: ERROR.UNABLE_TO_SCAN_SITE };
     }
   };
+
+  scanTx = async (txXdr: string, network: NetworkNames) => {
+    try {
+      const networkPassphrase = Networks[network];
+      const tx = TransactionBuilder.fromXDR(txXdr, networkPassphrase);
+      let source = "";
+      if ("innerTransaction" in tx) {
+        source = tx.innerTransaction.source;
+      } else {
+        source = tx.source;
+      }
+      const body = {
+        chain: NetworkNameBlockaid[network],
+        options: ["validation", "simulation"] as Array<
+          "validation" | "simulation"
+        >,
+        metadata: {
+          type: "wallet" as "wallet",
+          url: "", // TODO: can this be optional, we dont always have it
+        },
+        transactions: [txXdr],
+        account_address: source,
+      };
+      const data = await this.blockAidClient.stellar.transaction.scan(body);
+      return { data, error: null };
+    } catch (error) {
+      this.logger.error(error);
+      return { data: null, error: ERROR.UNABLE_TO_SCAN_TX };
+    }
+  };
 }