Add meta-transaction relayer endpoint (#289)

* Init relayer

* Add meta-transaction relayer endpoint

* Update to engine native flow

* Add support for relayer

* Update order

* Add description

* Skip auth check for relayer

* Relayer is actually working with SDK

Author: adam-maj

src/db/relayer/getRelayerById.ts

@@ -0,0 +1,27 @@
+import { prisma } from "../client";
+
+interface GetRelayerByIdParams {
+  id: string;
+}
+
+export const getRelayerById = async ({ id }: GetRelayerByIdParams) => {
+  const relayer = await prisma.relayers.findUnique({
+    where: {
+      id,
+    },
+  });
+
+  if (!relayer) {
+    return null;
+  }
+
+  return {
+    ...relayer,
+    chainId: parseInt(relayer.chainId),
+    allowedContracts: relayer.allowedContracts
+      ? (JSON.parse(relayer.allowedContracts).map((contractAddress: string) =>
+          contractAddress.toLowerCase(),
+        ) as string[])
+      : null,
+  };
+};

src/db/transactions/queueTx.ts

@@ -45,7 +45,7 @@ export const queueTx = async ({
   const txTableData = {
     chainId: chainId.toString(),
     functionName: tx.getMethod(),
-    functionArgs: tx.getArgs().toString(),
+    functionArgs: JSON.stringify(tx.getArgs()),
     extension,
     deployedContractAddress: deployedContractAddress,
     deployedContractType: deployedContractType,

src/prisma/migrations/20231105235957_relayers/migration.sql

@@ -0,0 +1,10 @@
+-- CreateTable
+CREATE TABLE "relayers" (
+    "id" TEXT NOT NULL,
+    "name" TEXT,
+    "chainId" TEXT NOT NULL,
+    "backendWalletAddress" TEXT NOT NULL,
+    "allowedContracts" TEXT,
+
+    CONSTRAINT "relayers_pkey" PRIMARY KEY ("id")
+);

src/prisma/schema.prisma

@@ -161,3 +161,13 @@ model Webhooks {
 
   @@map("webhooks")
 }
+
+model Relayers {
+  id                   String  @id @default(uuid()) @map("id")
+  name                 String? @map("name")
+  chainId              String  @map("chainId")
+  backendWalletAddress String  @map("backendWalletAddress")
+  allowedContracts     String? @map("allowedContracts")
+
+  @@map("relayers")
+}

src/schema/extension.ts

@@ -10,4 +10,5 @@ export type ContractExtension =
   | "deploy-prebuilt"
   | "deploy-published"
   | "account-factory"
-  | "account";
+  | "account"
+  | "forwarder";

src/server/middleware/auth.ts

@@ -168,12 +168,22 @@ export const withAuth = async (server: FastifyInstance) => {
       req.url.includes("/auth/login") ||
       req.url.includes("/auth/user") ||
       req.url.includes("/auth/switch-account") ||
-      req.url.includes("/auth/logout")
+      req.url.includes("/auth/logout") ||
+      req.url.includes("/transaction/status")
     ) {
       // We skip auth check for static endpoints and auth routes
       return;
     }
 
+    if (
+      req.url.includes("/relayer") &&
+      !req.url.includes("/create") &&
+      !req.url.includes("/revoke")
+    ) {
+      // Relayer endpoints can handle their own authentication
+      return;
+    }
+
     // TODO: Enable authentication check for websocket requests
     if (
       req.headers.upgrade &&

src/server/routes/index.ts

@@ -77,6 +77,10 @@ import { getAuthConfiguration } from "./configuration/auth/get";
 import { updateAuthConfiguration } from "./configuration/auth/update";
 import { accountRoutes } from "./contract/extensions/account";
 import { accountFactoryRoutes } from "./contract/extensions/accountFactory";
+import { relayTransaction } from "./relayer";
+import { createRelayer } from "./relayer/create";
+import { getAllRelayers } from "./relayer/getAll";
+import { revokeRelayer } from "./relayer/revoke";
 
 export const withRoutes = async (fastify: FastifyInstance) => {
   // Wallet
@@ -119,6 +123,12 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(getChainData);
   await fastify.register(getAllChainData);
 
+  // Relayer
+  await fastify.register(getAllRelayers);
+  await fastify.register(createRelayer);
+  await fastify.register(revokeRelayer);
+  await fastify.register(relayTransaction);
+
   // Generic
   await fastify.register(readContract);
   await fastify.register(writeToContract);

src/server/routes/relayer/create.ts

@@ -0,0 +1,59 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { prisma } from "../../../db/client";
+import { getChainIdFromChain } from "../../utils/chain";
+
+const BodySchema = Type.Object({
+  chain: Type.String(),
+  backendWalletAddress: Type.String({
+    description:
+      "The address of the backend wallet to use for relaying transactions.",
+  }),
+  allowedContracts: Type.Optional(Type.Array(Type.String())),
+});
+
+const ReplySchema = Type.Object({
+  result: Type.Object({
+    relayerId: Type.String(),
+  }),
+});
+
+export async function createRelayer(fastify: FastifyInstance) {
+  fastify.route<{
+    Reply: Static<typeof ReplySchema>;
+    Body: Static<typeof BodySchema>;
+  }>({
+    method: "POST",
+    url: "/relayer/create",
+    schema: {
+      summary: "Create a new meta-transaction relayer",
+      description: "Create a new meta-transaction relayer",
+      tags: ["Relayer"],
+      operationId: "create",
+      body: BodySchema,
+      response: {
+        [StatusCodes.OK]: ReplySchema,
+      },
+    },
+    handler: async (req, res) => {
+      const { chain, backendWalletAddress, allowedContracts } = req.body;
+
+      const relayer = await prisma.relayers.create({
+        data: {
+          chainId: getChainIdFromChain(chain).toString(),
+          backendWalletAddress,
+          allowedContracts: allowedContracts
+            ? JSON.stringify(allowedContracts)
+            : null,
+        },
+      });
+
+      return res.status(200).send({
+        result: {
+          relayerId: relayer.id,
+        },
+      });
+    },
+  });
+}

src/server/routes/relayer/getAll.ts

@@ -0,0 +1,44 @@
+import { Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { prisma } from "../../../db/client";
+
+const ReplySchema = Type.Object({
+  result: Type.Array(
+    Type.Object({
+      id: Type.String(),
+      name: Type.Union([Type.String(), Type.Null()]),
+      chainId: Type.String(),
+      backendWalletAddress: Type.String(),
+      allowedContracts: Type.Union([Type.Array(Type.String()), Type.Null()]),
+    }),
+  ),
+});
+
+export async function getAllRelayers(fastify: FastifyInstance) {
+  fastify.route({
+    method: "GET",
+    url: "/relayer/get-all",
+    schema: {
+      summary: "Get all meta-transaction relayers",
+      description: "Get all meta-transaction relayers",
+      tags: ["Relayer"],
+      operationId: "getAll",
+      response: {
+        [StatusCodes.OK]: ReplySchema,
+      },
+    },
+    handler: async (req, res) => {
+      const relayers = await prisma.relayers.findMany();
+
+      return res.status(200).send({
+        result: relayers.map((relayer) => ({
+          ...relayer,
+          allowedContracts: relayer.allowedContracts
+            ? JSON.parse(relayer.allowedContracts)
+            : null,
+        })),
+      });
+    },
+  });
+}