Refactor contract read route to use thirdweb v5

Author: joaquim-verges

src/server/routes/contract/read/read.ts

@@ -1,7 +1,12 @@
 import { Type } from "@sinclair/typebox";
 import type { FastifyInstance } from "fastify";
 import { StatusCodes } from "http-status-codes";
-import { getContract } from "../../../../shared/utils/cache/get-contract";
+import type { AbiParameters } from "ox";
+import { readContract as readContractV5 } from "thirdweb";
+import { resolveMethod } from "thirdweb/dist/types/transaction/resolve-method";
+import { parseAbiParams } from "thirdweb/utils";
+import type { AbiFunction } from "thirdweb/utils";
+import { getContractV5 } from "../../../../shared/utils/cache/get-contractv5";
 import { prettifyError } from "../../../../shared/utils/error";
 import { createCustomError } from "../../../middleware/error";
 import {
@@ -12,6 +17,8 @@ import {
   partialRouteSchema,
   standardResponseSchema,
 } from "../../../schemas/shared-api-schemas";
+import { sanitizeFunctionName } from "../../../utils/abi";
+import { sanitizeAbi } from "../../../utils/abi";
 import { getChainIdFromChain } from "../../../utils/chain";
 import { bigNumberReplacer } from "../../../utils/convertor";
 
@@ -37,12 +44,13 @@ export async function readContract(fastify: FastifyInstance) {
     },
     handler: async (request, reply) => {
       const { chain, contractAddress } = request.params;
-      const { functionName, args } = request.query;
+      const { functionName, args, abi } = request.query;
 
       const chainId = await getChainIdFromChain(chain);
-      const contract = await getContract({
+      const contract = await getContractV5({
         chainId,
         contractAddress,
+        abi: sanitizeAbi(abi),
       });
 
       let parsedArgs: unknown[] | undefined;
@@ -54,19 +62,33 @@ export async function readContract(fastify: FastifyInstance) {
         // fallback to string split
       }
 
-      parsedArgs ??= args?.split(",").map((arg) => {
-        if (arg === "true") {
-          return true;
-        }
-        if (arg === "false") {
-          return false;
-        }
-        return arg;
-      });
+      parsedArgs ??= args?.split(",");
+
+      // 3 possible ways to get function from abi:
+      // 1. functionName passed as solidity signature
+      // 2. functionName passed as function name + passed in ABI
+      // 3. functionName passed as function name + inferred ABI (fetched at encode time)
+      // this is all handled inside the `resolveMethod` function
+      let method: AbiFunction;
+      let params: Array<string | bigint | boolean | object>;
+      try {
+        const functionNameOrSignature = sanitizeFunctionName(functionName);
+        method = await resolveMethod(functionNameOrSignature)(contract);
+        params = parseAbiParams(
+          method.inputs.map((i: AbiParameters.Parameter) => i.type),
+          parsedArgs ?? [],
+        );
+      } catch (e) {
+        throw createCustomError(
+          prettifyError(e),
+          StatusCodes.BAD_REQUEST,
+          "BAD_REQUEST",
+        );
+      }
 
       let returnData: unknown;
       try {
-        returnData = await contract.call(functionName, parsedArgs ?? []);
+        returnData = await readContractV5({ contract, method, params });
       } catch (e) {
         throw createCustomError(
           prettifyError(e),

src/server/schemas/contract/index.ts

@@ -1,27 +1,7 @@
-import { Type, type Static } from "@sinclair/typebox";
+import { type Static, Type } from "@sinclair/typebox";
 import { AddressSchema } from "../address";
 import type { contractSchemaTypes } from "../shared-api-schemas";
 
-/**
- * Basic schema for all Request Query String
- */
-export const readRequestQuerySchema = Type.Object({
-  functionName: Type.String({
-    description: "Name of the function to call on Contract",
-    examples: ["balanceOf"],
-  }),
-  args: Type.Optional(
-    Type.String({
-      description: "Arguments for the function. Comma Separated",
-      examples: [""],
-    }),
-  ),
-});
-
-export interface readSchema extends contractSchemaTypes {
-  Querystring: Static<typeof readRequestQuerySchema>;
-}
-
 const abiTypeSchema = Type.Object({
   type: Type.Optional(Type.String()),
   name: Type.Optional(Type.String()),
@@ -65,6 +45,31 @@ export const abiSchema = Type.Object({
 export const abiArraySchema = Type.Array(abiSchema);
 export type AbiSchemaType = Static<typeof abiArraySchema>;
 
+/**
+ * Basic schema for all Request Query String
+ */
+export const readRequestQuerySchema = Type.Object({
+  functionName: Type.String({
+    description:
+      "The function to call on the contract. It is highly recommended to provide a full function signature, such as 'function balanceOf(address owner) view returns (uint256)', to avoid ambiguity and to skip ABI resolution",
+    examples: [
+      "function balanceOf(address owner) view returns (uint256)",
+      "balanceOf",
+    ],
+  }),
+  args: Type.Optional(
+    Type.String({
+      description: "Arguments for the function. Comma Separated",
+      examples: [""],
+    }),
+  ),
+  abi: Type.Optional(abiArraySchema),
+});
+
+export interface readSchema extends contractSchemaTypes {
+  Querystring: Static<typeof readRequestQuerySchema>;
+}
+
 export const contractEventSchema = Type.Record(Type.String(), Type.Any());
 
 export const rolesResponseSchema = Type.Object({

tests/e2e/tests/routes/read.test.ts

@@ -0,0 +1,70 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import assert from "node:assert";
+import { ZERO_ADDRESS } from "thirdweb";
+import type { Address } from "thirdweb/utils";
+import { CONFIG } from "../../config";
+import type { setupEngine } from "../../utils/engine";
+import { pollTransactionStatus } from "../../utils/transactions";
+import { setup } from "../setup";
+
+describe("readContractRoute", () => {
+  let engine: ReturnType<typeof setupEngine>;
+  let backendWallet: Address;
+  let tokenContractAddress: string;
+
+  beforeAll(async () => {
+    const { engine: _engine, backendWallet: _backendWallet } = await setup();
+    engine = _engine;
+    backendWallet = _backendWallet as Address;
+
+    const res = await engine.deploy.deployToken(
+      CONFIG.CHAIN.id.toString(),
+      backendWallet,
+      {
+        contractMetadata: {
+          name: "test token",
+          platform_fee_basis_points: 0,
+          platform_fee_recipient: ZERO_ADDRESS,
+          symbol: "TT",
+          trusted_forwarders: [],
+        },
+      },
+    );
+
+    expect(res.result.queueId).toBeDefined();
+    assert(res.result.queueId, "queueId must be defined");
+    expect(res.result.deployedAddress).toBeDefined();
+
+    const transactionStatus = await pollTransactionStatus(
+      engine,
+      res.result.queueId,
+      true,
+    );
+
+    expect(transactionStatus.minedAt).toBeDefined();
+    assert(res.result.deployedAddress, "deployedAddress must be defined");
+    tokenContractAddress = res.result.deployedAddress;
+  });
+
+  test("readContract with function name", async () => {
+    const res = await engine.contract.read(
+      "name",
+      CONFIG.CHAIN.id.toString(),
+      tokenContractAddress,
+      backendWallet,
+    );
+
+    expect(res.result).toEqual("test token");
+  });
+
+  test("readContract with function signature", async () => {
+    const res = await engine.contract.read(
+      "function symbol() public view returns (string memory)",
+      CONFIG.CHAIN.id.toString(),
+      tokenContractAddress,
+      backendWallet,
+    );
+
+    expect(res.result).toEqual("TT");
+  });
+});