Generic Request Handler

package.json

@@ -28,6 +28,6 @@
     "prettier": "^3.4.2",
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.3",
-    "viem": "^2.22.11"
+    "viem": "^2.22.12"
   }
 }

packages/agent-sdk/src/error.ts

@@ -0,0 +1,13 @@
+export function errorString(error: unknown): string {
+  // intentional == to check for null or undefined
+  if (error == null) {
+    return `unknown error: ${error}`;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}

packages/agent-sdk/src/index.ts

@@ -1,2 +1,5 @@
 export * from "./validate";
 export * from "./evm";
+export * from "./request";
+export * from "./error";
+export * from "./misc";

packages/agent-sdk/src/misc.ts

@@ -0,0 +1,7 @@
+import { MetaTransaction } from "near-safe";
+
+export const NULL_TRANSACTION: MetaTransaction = {
+  to: "0x0000000000000000000000000000000000000000",
+  value: "0x00",
+  data: "0x",
+};

packages/agent-sdk/src/request.ts

@@ -0,0 +1,23 @@
+import { SignRequestData } from "near-safe";
+import { errorString } from "./error";
+
+export interface TxData {
+  transaction?: SignRequestData;
+  meta?: unknown;
+}
+
+export async function handleRequest<X, T, R>(
+  input: X,
+  logic: (input: X) => Promise<T>,
+  responseTransformer: (result: T | { meta: { message: string } }) => R,
+): Promise<R> {
+  try {
+    const result = await logic(input);
+    console.log("Responding with", JSON.stringify(result, null, 2));
+    return responseTransformer(result);
+  } catch (err: unknown) {
+    const message = errorString(err);
+    console.error(message);
+    return responseTransformer({ meta: { message } });
+  }
+}

packages/agent-sdk/tests/error.spec.ts

@@ -0,0 +1,24 @@
+import { errorString } from "../src/error";
+
+describe("errorString(unknown)", () => {
+  it("returns generic message on nullish error", async () => {
+    expect(errorString(null)).toBe("unknown error: null");
+    expect(errorString(undefined)).toBe("unknown error: undefined");
+  });
+
+  it("returns exact string on string error", async () => {
+    const message = "error message";
+    expect(errorString(message)).toBe(message);
+  });
+
+  it("returns stringified json on object", async () => {
+    const obj = { field: "value" };
+    expect(errorString(obj)).toBe(JSON.stringify(obj));
+  });
+
+  it("returns Error.message Error instance", async () => {
+    const message = "error message";
+    const err = new Error(message);
+    expect(errorString(err)).toBe(message);
+  });
+});