Add support for smart wallets

core/schema/index.ts

@@ -41,4 +41,9 @@ export const walletAuthSchema = Type.Object({
   "x-wallet-address": Type.String({
     description: "Wallet address",
   }),
+  "x-account-address": Type.Optional(
+    Type.String({
+      description: "Smart account address",
+    }),
+  ),
 });

package.json

@@ -42,7 +42,7 @@
     "@sinclair/typebox": "^0.28",
     "@t3-oss/env-core": "^0.6.0",
     "@thirdweb-dev/chains": "^0.1.46",
-    "@thirdweb-dev/sdk": "^3.10.60",
+    "@thirdweb-dev/sdk": "0.0.0-dev-b1d4b3b-20230922050105",
     "@thirdweb-dev/service-utils": "^0.4.2",
     "@thirdweb-dev/wallets": "^1.1.23",
     "body-parser": "^1.20.2",

server/api/contract/extensions/account/index.ts

@@ -0,0 +1,21 @@
+import { FastifyInstance } from "fastify";
+import { getAllAdmins } from "./read/getAllAdmins";
+import { getAllSessions } from "./read/getAllSessions";
+import { grantAdmin } from "./write/grantAdmin";
+import { grantSession } from "./write/grantSession";
+import { revokeAdmin } from "./write/revokeAdmin";
+import { revokeSession } from "./write/revokeSession";
+import { updateSession } from "./write/updateSession";
+
+export const accountRoutes = async (fastify: FastifyInstance) => {
+  // GET
+  await fastify.register(getAllAdmins);
+  await fastify.register(getAllSessions);
+
+  // POST
+  await fastify.register(grantAdmin);
+  await fastify.register(revokeAdmin);
+  await fastify.register(grantSession);
+  await fastify.register(revokeSession);
+  await fastify.register(updateSession);
+};

server/api/contract/extensions/account/read/getAllAdmins.ts

@@ -0,0 +1,49 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+} from "../../../../../helpers";
+import { getChainIdFromChain } from "../../../../../utilities/chain";
+import { getContract } from "../../../../../utils/cache/getContract";
+
+const ReplySchema = Type.Object({
+  result: Type.Array(Type.String(), {
+    description: "The address of the admins on this account",
+  }),
+});
+
+export const getAllAdmins = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof contractParamSchema>;
+    Reply: Static<typeof ReplySchema>;
+  }>({
+    method: "GET",
+    url: "/contract/:chain/:contract_address/account/admins/get-all",
+    schema: {
+      description: "Get all admins on an account",
+      tags: ["Account"],
+      operationId: "account:get-all-admins",
+      params: contractParamSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: ReplySchema,
+      },
+    },
+    handler: async (req, rep) => {
+      const { chain, contract_address } = req.params;
+      const chainId = getChainIdFromChain(chain);
+
+      const contract = await getContract({
+        chainId,
+        contractAddress: contract_address,
+      });
+      const accountAddresses = await contract.account.getAllAdmins();
+
+      rep.status(StatusCodes.OK).send({
+        result: accountAddresses,
+      });
+    },
+  });
+};

server/api/contract/extensions/account/read/getAllSessions.ts

@@ -0,0 +1,55 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+} from "../../../../../helpers";
+import { SessionSchema } from "../../../../../schemas/account";
+import { getChainIdFromChain } from "../../../../../utilities/chain";
+import { getContract } from "../../../../../utils/cache/getContract";
+
+const ReplySchema = Type.Object({
+  result: Type.Array(SessionSchema),
+});
+
+export const getAllSessions = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof contractParamSchema>;
+    Reply: Static<typeof ReplySchema>;
+  }>({
+    method: "GET",
+    url: "/contract/:chain/:contract_address/account/sessions/get-all",
+    schema: {
+      description: "Get all sessions on an account",
+      tags: ["Account"],
+      operationId: "account:get-all-sessions",
+      params: contractParamSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: ReplySchema,
+      },
+    },
+    handler: async (req, rep) => {
+      const { chain, contract_address } = req.params;
+      const chainId = getChainIdFromChain(chain);
+
+      const contract = await getContract({
+        chainId,
+        contractAddress: contract_address,
+      });
+      const sessions = await contract.account.getAllSigners();
+
+      rep.status(StatusCodes.OK).send({
+        result: sessions.map((session) => ({
+          signerAddress: session.signer,
+          startDate: session.permissions.startDate.toISOString(),
+          expirationDate: session.permissions.expirationDate.toISOString(),
+          nativeTokenLimitPerTransaction:
+            session.permissions.nativeTokenLimitPerTransaction.toString(),
+          approvedCallTargets: session.permissions.approvedCallTargets,
+        })),
+      });
+    },
+  });
+};

server/api/contract/extensions/account/write/grantAdmin.ts

@@ -0,0 +1,64 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { walletAuthSchema } from "../../../../../../core/schema";
+import { queueTx } from "../../../../../../src/db/transactions/queueTx";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+  transactionWritesResponseSchema,
+} from "../../../../../helpers";
+import { getChainIdFromChain } from "../../../../../utilities/chain";
+import { getContract } from "../../../../../utils/cache/getContract";
+
+const BodySchema = Type.Object({
+  signer_address: Type.String({
+    description: "Address to grant admin permissions to",
+  }),
+});
+
+export const grantAdmin = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof contractParamSchema>;
+    Reply: Static<typeof transactionWritesResponseSchema>;
+    Body: Static<typeof BodySchema>;
+  }>({
+    method: "POST",
+    url: "/contract/:chain/:contract_address/account/admins/grant",
+    schema: {
+      description: "Grant a wallet admin permissions",
+      tags: ["Account"],
+      operationId: "account:grant-admin",
+      headers: walletAuthSchema,
+      params: contractParamSchema,
+      body: BodySchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: transactionWritesResponseSchema,
+      },
+    },
+    handler: async (req, rep) => {
+      const { chain, contract_address } = req.params;
+      const { signer_address } = req.body;
+      const walletAddress = req.headers["x-wallet-address"] as string;
+      const accountAddress = req.headers["x-account-address"] as string;
+      const chainId = getChainIdFromChain(chain);
+
+      const contract = await getContract({
+        chainId,
+        contractAddress: contract_address,
+        walletAddress,
+        accountAddress,
+      });
+
+      const tx = await contract.account.grantAdminPermissions.prepare(
+        signer_address,
+      );
+      const queueId = await queueTx({ tx, chainId, extension: "account" });
+
+      rep.status(StatusCodes.OK).send({
+        result: queueId,
+      });
+    },
+  });
+};

server/api/contract/extensions/account/write/grantSession.ts

@@ -0,0 +1,68 @@
+import { Static } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { walletAuthSchema } from "../../../../../../core/schema";
+import { queueTx } from "../../../../../../src/db/transactions/queueTx";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+  transactionWritesResponseSchema,
+} from "../../../../../helpers";
+import { SessionSchema } from "../../../../../schemas/account";
+import { getChainIdFromChain } from "../../../../../utilities/chain";
+import { getContract } from "../../../../../utils/cache/getContract";
+
+const BodySchema = SessionSchema;
+
+export const grantSession = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof contractParamSchema>;
+    Reply: Static<typeof transactionWritesResponseSchema>;
+    Body: Static<typeof BodySchema>;
+  }>({
+    method: "POST",
+    url: "/contract/:chain/:contract_address/account/sessions/create",
+    schema: {
+      description: "Create a new session",
+      tags: ["Account"],
+      operationId: "account:grant-session",
+      params: contractParamSchema,
+      headers: walletAuthSchema,
+      body: BodySchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: transactionWritesResponseSchema,
+      },
+    },
+    handler: async (req, rep) => {
+      const { chain, contract_address } = req.params;
+      const { signerAddress, ...permissions } = req.body;
+      const walletAddress = req.headers["x-wallet-address"] as string;
+      const accountAddress = req.headers["x-account-address"] as string;
+      const chainId = getChainIdFromChain(chain);
+
+      const contract = await getContract({
+        chainId,
+        contractAddress: contract_address,
+        walletAddress,
+        accountAddress,
+      });
+
+      const tx = await contract.account.grantPermissions.prepare(
+        signerAddress,
+        {
+          startDate: new Date(permissions.startDate),
+          expirationDate: new Date(permissions.expirationDate),
+          approvedCallTargets: permissions.approvedCallTargets,
+          nativeTokenLimitPerTransaction:
+            permissions.nativeTokenLimitPerTransaction,
+        },
+      );
+      const queueId = await queueTx({ tx, chainId, extension: "account" });
+
+      rep.status(StatusCodes.OK).send({
+        result: queueId,
+      });
+    },
+  });
+};

server/api/contract/extensions/account/write/revokeAdmin.ts

@@ -0,0 +1,64 @@
+import { Static, Type } from "@sinclair/typebox";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { walletAuthSchema } from "../../../../../../core/schema";
+import { queueTx } from "../../../../../../src/db/transactions/queueTx";
+import {
+  contractParamSchema,
+  standardResponseSchema,
+  transactionWritesResponseSchema,
+} from "../../../../../helpers";
+import { getChainIdFromChain } from "../../../../../utilities/chain";
+import { getContract } from "../../../../../utils/cache/getContract";
+
+const BodySchema = Type.Object({
+  wallet_address: Type.String({
+    description: "Address to revoke admin permissions from",
+  }),
+});
+
+export const revokeAdmin = async (fastify: FastifyInstance) => {
+  fastify.route<{
+    Params: Static<typeof contractParamSchema>;
+    Reply: Static<typeof transactionWritesResponseSchema>;
+    Body: Static<typeof BodySchema>;
+  }>({
+    method: "POST",
+    url: "/contract/:chain/:contract_address/account/admins/revoke",
+    schema: {
+      description: "Revoke a wallet's admin permissions",
+      tags: ["Account"],
+      operationId: "account:revoke-admin",
+      headers: walletAuthSchema,
+      params: contractParamSchema,
+      body: BodySchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: transactionWritesResponseSchema,
+      },
+    },
+    handler: async (req, rep) => {
+      const { chain, contract_address } = req.params;
+      const { wallet_address } = req.body;
+      const walletAddress = req.headers["x-wallet-address"] as string;
+      const accountAddress = req.headers["x-account-address"] as string;
+      const chainId = getChainIdFromChain(chain);
+
+      const contract = await getContract({
+        chainId,
+        contractAddress: contract_address,
+        walletAddress,
+        accountAddress,
+      });
+
+      const tx = await contract.account.revokeAdminPermissions.prepare(
+        wallet_address,
+      );
+      const queueId = await queueTx({ tx, chainId, extension: "account" });
+
+      rep.status(StatusCodes.OK).send({
+        result: queueId,
+      });
+    },
+  });
+};