chore: Make sure we can create/read/update labels for wallets/admins/access tokens (#302)

Author: arcoraven

src/db/tokens/updateToken.ts

@@ -0,0 +1,17 @@
+import { prisma } from "../client";
+
+interface UpdateTokenParams {
+  id: string;
+  label?: string;
+}
+
+export const updateToken = async ({ id, label }: UpdateTokenParams) => {
+  await prisma.tokens.update({
+    where: {
+      id,
+    },
+    data: {
+      label,
+    },
+  });
+};

src/db/wallets/updateWalletDetails.ts

@@ -0,0 +1,20 @@
+import { prisma } from "../client";
+
+interface UpdateWalletDetailsParams {
+  address: string;
+  label?: string;
+}
+
+export const updateWalletDetails = async ({
+  address,
+  label,
+}: UpdateWalletDetailsParams) => {
+  await prisma.walletDetails.update({
+    where: {
+      address: address.toLowerCase(),
+    },
+    data: {
+      label,
+    },
+  });
+};

src/server/routes/auth/access-tokens/update.ts

@@ -0,0 +1,45 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { updateToken } from "../../../../db/tokens/updateToken";
+
+const BodySchema = Type.Object({
+  id: Type.String(),
+  label: Type.Optional(Type.String()),
+});
+
+const ReplySchema = Type.Object({
+  result: Type.Object({
+    success: Type.Boolean(),
+  }),
+});
+
+export async function updateAccessToken(fastify: FastifyInstance) {
+  fastify.route<{
+    Body: Static<typeof BodySchema>;
+    Reply: Static<typeof ReplySchema>;
+  }>({
+    method: "POST",
+    url: "/auth/access-tokens/update",
+    schema: {
+      summary: "Update an access token",
+      description: "Update an access token",
+      tags: ["Access Tokens"],
+      operationId: "update",
+      body: BodySchema,
+      response: {
+        [StatusCodes.OK]: ReplySchema,
+      },
+    },
+    handler: async (req, res) => {
+      const { id, label } = req.body;
+      await updateToken({ id, label });
+
+      res.status(200).send({
+        result: {
+          success: true,
+        },
+      });
+    },
+  });
+}

src/server/routes/backend-wallet/create.ts

@@ -26,7 +26,7 @@ responseSchema.example = {
   },
 };
 
-export const createWallet = async (fastify: FastifyInstance) => {
+export const createBackendWallet = async (fastify: FastifyInstance) => {
   fastify.route<{
     Body: Static<typeof BodySchema>;
     Reply: Static<typeof responseSchema>;

src/server/routes/backend-wallet/import.ts

@@ -91,7 +91,7 @@ ResponseSchema.example = {
   },
 };
 
-export const importWallet = async (fastify: FastifyInstance) => {
+export const importBackendWallet = async (fastify: FastifyInstance) => {
   fastify.route<{
     Reply: Static<typeof ResponseSchema>;
     Body: Static<typeof RequestBodySchema>;

src/server/routes/backend-wallet/update.ts

@@ -0,0 +1,60 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { updateWalletDetails } from "../../../db/wallets/updateWalletDetails";
+import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
+
+const BodySchema = Type.Object({
+  walletAddress: Type.String(),
+  label: Type.Optional(Type.String()),
+});
+
+const responseSchema = Type.Object({
+  result: Type.Object({
+    walletAddress: Type.String(),
+    status: Type.String(),
+  }),
+});
+
+responseSchema.example = {
+  result: {
+    walletAddress: "0x....",
+    status: "success",
+  },
+};
+
+export const updateBackendWallet = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Body: Static<typeof BodySchema>;
+    Reply: Static<typeof responseSchema>;
+  }>({
+    method: "POST",
+    url: "/backend-wallet/update",
+    schema: {
+      summary: "Update backend wallet",
+      description: "Update a backend wallet.",
+      tags: ["Backend Wallet"],
+      operationId: "update",
+      body: BodySchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseSchema,
+      },
+    },
+    handler: async (req, reply) => {
+      const { walletAddress, label } = req.body;
+
+      await updateWalletDetails({
+        address: walletAddress,
+        label,
+      });
+
+      reply.status(StatusCodes.OK).send({
+        result: {
+          walletAddress,
+          status: "success",
+        },
+      });
+    },
+  });
+};

src/server/routes/index.ts

@@ -17,38 +17,39 @@ import { erc721Routes } from "./contract/extensions/erc721";
 import { marketplaceV3Routes } from "./contract/extensions/marketplaceV3/index";
 import { prebuiltsRoutes } from "./deploy";
 
-// Chain
+// Chains
 import { getChainData } from "./chain/get";
 import { getAllChainData } from "./chain/getAll";
 
-// Contract Events
+// Contract events
 import { getAllEvents } from "./contract/events/getAllEvents";
 import { getEvents } from "./contract/events/getEvents";
 
-// Contract Roles
+// Contract roles
 import { getRoles } from "./contract/roles/read/get";
 import { getAllRoles } from "./contract/roles/read/getAll";
 import { grantRole } from "./contract/roles/write/grant";
 import { revokeRole } from "./contract/roles/write/revoke";
 
-// Contract Royalties
+// Contract royalties
 import { getDefaultRoyaltyInfo } from "./contract/royalties/read/getDefaultRoyaltyInfo";
 import { getTokenRoyaltyInfo } from "./contract/royalties/read/getTokenRoyaltyInfo";
 import { setDefaultRoyaltyInfo } from "./contract/royalties/write/setDefaultRoyaltyInfo";
 import { setTokenRoyaltyInfo } from "./contract/royalties/write/setTokenRoyaltyInfo";
 
-// Contract Metadata
+// Contract metadata
 import { getABI } from "./contract/metadata/abi";
 import { extractEvents } from "./contract/metadata/events";
 import { extractFunctions } from "./contract/metadata/functions";
 
 // Wallet
-import { createWallet } from "./backend-wallet/create";
+import { createBackendWallet } from "./backend-wallet/create";
 import { getAll } from "./backend-wallet/getAll";
 import { getBalance } from "./backend-wallet/getBalance";
-import { importWallet } from "./backend-wallet/import";
+import { importBackendWallet } from "./backend-wallet/import";
 import { sendTransaction } from "./backend-wallet/send";
 import { transfer } from "./backend-wallet/transfer";
+import { updateBackendWallet } from "./backend-wallet/update";
 
 // Configuration
 import { getBackendWalletBalanceConfiguration } from "./configuration/backend-wallet-balance/get";
@@ -66,17 +67,24 @@ import { getWebhooksEventTypes } from "./webhooks/events";
 import { getAllWebhooksData } from "./webhooks/getAll";
 import { revokeWebhook } from "./webhooks/revoke";
 
-// Accounts
+// Access tokens
 import { createAccessToken } from "./auth/access-tokens/create";
 import { getAllAccessTokens } from "./auth/access-tokens/getAll";
 import { revokeAccessToken } from "./auth/access-tokens/revoke";
+import { updateAccessToken } from "./auth/access-tokens/update";
+
+// Admins
 import { getAllPermissions } from "./auth/permissions/getAll";
 import { grantPermissions } from "./auth/permissions/grant";
 import { revokePermissions } from "./auth/permissions/revoke";
 import { getAuthConfiguration } from "./configuration/auth/get";
 import { updateAuthConfiguration } from "./configuration/auth/update";
+
+// Smart accounts
 import { accountRoutes } from "./contract/extensions/account";
 import { accountFactoryRoutes } from "./contract/extensions/accountFactory";
+
+// Relayers
 import { relayTransaction } from "./relayer";
 import { createRelayer } from "./relayer/create";
 import { getAllRelayers } from "./relayer/getAll";
@@ -87,9 +95,10 @@ import { healthCheck } from "./health";
 import { home } from "./home";
 
 export const withRoutes = async (fastify: FastifyInstance) => {
-  // Wallet
-  await fastify.register(createWallet);
-  await fastify.register(importWallet);
+  // Backend Wallets
+  await fastify.register(createBackendWallet);
+  await fastify.register(importBackendWallet);
+  await fastify.register(updateBackendWallet);
   await fastify.register(getBalance);
   await fastify.register(getAll);
   await fastify.register(transfer);
@@ -122,6 +131,7 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(getAllAccessTokens);
   await fastify.register(createAccessToken);
   await fastify.register(revokeAccessToken);
+  await fastify.register(updateAccessToken);
 
   // Chains
   await fastify.register(getChainData);