@rickydata/agent0-mcp 0.1.0

package/tests/payments.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock agent0-sdk
+const mockRequest = vi.fn();
+const mockIsX402Required = vi.fn();
+
+vi.mock("agent0-sdk", () => {
+  return {
+    SDK: vi.fn().mockImplementation(() => ({
+      request: mockRequest,
+    })),
+    isX402Required: (...args: unknown[]) => mockIsX402Required(...args),
+  };
+});
+
+import { paymentsTools, handlePaymentsTool } from "../src/tools/payments.js";
+import { setDerivedKey, setChainId } from "../src/auth/sdk-client.js";
+
+describe("payments tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setChainId(11155111);
+    setDerivedKey("0x" + "bb".repeat(32));
+    mockIsX402Required.mockReturnValue(false);
+  });
+
+  // ===========================================================================
+  // Tool registration
+  // ===========================================================================
+  describe("tool registration", () => {
+    it("registers 1 payment tool", () => {
+      expect(paymentsTools).toHaveLength(1);
+    });
+
+    it("registers x402_request", () => {
+      expect(paymentsTools.find((t) => t.name === "x402_request")).toBeDefined();
+    });
+  });
+
+  // ===========================================================================
+  // x402_request
+  // ===========================================================================
+  describe("x402_request", () => {
+    it("returns ok for non-402 response", async () => {
+      mockRequest.mockResolvedValue({ status: 200, data: "hello" });
+
+      const result = (await handlePaymentsTool("x402_request", {
+        url: "https://api.test/data",
+      })) as { status: string; x402: boolean };
+
+      expect(result.status).toBe("ok");
+      expect(result.x402).toBe(false);
+    });
+
+    it("returns payment_required when 402 and autoPay is false", async () => {
+      mockIsX402Required.mockReturnValue(true);
+      mockRequest.mockResolvedValue({
+        x402Payment: { pay: vi.fn() },
+      });
+
+      const result = (await handlePaymentsTool("x402_request", {
+        url: "https://paid.test/resource",
+        autoPay: false,
+      })) as { status: string; x402: boolean };
+
+      expect(result.status).toBe("payment_required");
+      expect(result.x402).toBe(true);
+    });
+
+    it("auto-pays and returns paid result when autoPay is true", async () => {
+      const mockPay = vi.fn().mockResolvedValue({ receipt: "paid_data" });
+      mockIsX402Required.mockReturnValue(true);
+      mockRequest.mockResolvedValue({
+        x402Payment: { pay: mockPay },
+      });
+
+      const result = (await handlePaymentsTool("x402_request", {
+        url: "https://paid.test/resource",
+        autoPay: true,
+      })) as { status: string; x402: boolean; result: unknown };
+
+      expect(result.status).toBe("paid");
+      expect(result.x402).toBe(true);
+      expect(result.result).toEqual({ receipt: "paid_data" });
+      expect(mockPay).toHaveBeenCalledOnce();
+    });
+
+    it("returns payment_failed when auto-pay throws", async () => {
+      const mockPay = vi.fn().mockRejectedValue(new Error("Insufficient funds"));
+      mockIsX402Required.mockReturnValue(true);
+      mockRequest.mockResolvedValue({
+        x402Payment: { pay: mockPay },
+      });
+
+      const result = (await handlePaymentsTool("x402_request", {
+        url: "https://paid.test/resource",
+        autoPay: true,
+      })) as { status: string; error: string };
+
+      expect(result.status).toBe("payment_failed");
+      expect(result.error).toContain("Insufficient funds");
+    });
+
+    it("passes method and headers to SDK request", async () => {
+      mockRequest.mockResolvedValue({ data: "ok" });
+
+      await handlePaymentsTool("x402_request", {
+        url: "https://api.test/data",
+        method: "POST",
+        headers: { "X-Custom": "value" },
+        body: '{"key":"val"}',
+      });
+
+      expect(mockRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          url: "https://api.test/data",
+          method: "POST",
+          headers: { "X-Custom": "value" },
+          body: { key: "val" },
+        }),
+      );
+    });
+
+    it("defaults method to GET", async () => {
+      mockRequest.mockResolvedValue({ data: "ok" });
+
+      await handlePaymentsTool("x402_request", {
+        url: "https://api.test/data",
+      });
+
+      expect(mockRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "GET",
+        }),
+      );
+    });
+  });
+
+  // ===========================================================================
+  // Unknown tool
+  // ===========================================================================
+  it("returns error for unknown tool", async () => {
+    const result = (await handlePaymentsTool("nonexistent", {})) as {
+      error: string;
+    };
+    expect(result.error).toContain("Unknown payments tool");
+  });
+});

package/tests/registration.test.ts

@@ -0,0 +1,313 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock agent0-sdk
+const mockChainId = vi.fn().mockResolvedValue(11155111);
+const mockCreateAgent = vi.fn();
+const mockLoadAgent = vi.fn();
+
+vi.mock("agent0-sdk", () => {
+  return {
+    SDK: vi.fn().mockImplementation(() => ({
+      chainId: mockChainId,
+      createAgent: mockCreateAgent,
+      loadAgent: mockLoadAgent,
+    })),
+  };
+});
+
+// Mock wallet-derivation
+vi.mock("../src/auth/wallet-derivation.js", async (importOriginal) => {
+  const orig = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...orig,
+    deriveWalletFromSignature: vi.fn().mockReturnValue({
+      address: "0xDerivedAddress1234",
+      privateKey: "0x" + "ab".repeat(32),
+    }),
+    verifyDerivationSignature: vi.fn().mockReturnValue(true),
+  };
+});
+
+import {
+  registrationTools,
+  handleRegistrationTool,
+} from "../src/tools/registration.js";
+import {
+  setDerivedKey,
+  setChainId,
+} from "../src/auth/sdk-client.js";
+import { verifyDerivationSignature } from "../src/auth/wallet-derivation.js";
+
+function makeAgentBuilder() {
+  const builder = {
+    setMCP: vi.fn(),
+    setA2A: vi.fn(),
+    setTrust: vi.fn(),
+    setActive: vi.fn(),
+    setMetadata: vi.fn(),
+    registerIPFS: vi.fn().mockResolvedValue({
+      waitConfirmed: vi.fn().mockResolvedValue({
+        result: { agentId: "11155111:99", agentURI: "ipfs://Qm..." },
+        receipt: { transactionHash: "0xtxhash123" },
+      }),
+    }),
+    registerOnChain: vi.fn().mockResolvedValue({
+      waitConfirmed: vi.fn().mockResolvedValue({
+        result: { agentId: "11155111:99", agentURI: "data:..." },
+        receipt: { transactionHash: "0xtxhash456" },
+      }),
+    }),
+    updateInfo: vi.fn(),
+  };
+  return builder;
+}
+
+describe("registration tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setChainId(11155111);
+  });
+
+  // ===========================================================================
+  // Tool registration
+  // ===========================================================================
+  describe("tool registration", () => {
+    it("registers 5 registration tools", () => {
+      expect(registrationTools).toHaveLength(5);
+    });
+
+    const expected = [
+      "configure_wallet",
+      "get_derivation_message",
+      "get_auth_status",
+      "register_agent",
+      "update_agent",
+    ];
+    for (const name of expected) {
+      it(`registers ${name}`, () => {
+        expect(registrationTools.find((t) => t.name === name)).toBeDefined();
+      });
+    }
+  });
+
+  // ===========================================================================
+  // get_derivation_message
+  // ===========================================================================
+  describe("get_derivation_message", () => {
+    it("returns message and instructions", async () => {
+      const result = (await handleRegistrationTool(
+        "get_derivation_message",
+        {},
+      )) as { message: string; instructions: string };
+
+      expect(result.message).toBeTypeOf("string");
+      expect(result.message.length).toBeGreaterThan(0);
+      expect(result.instructions).toContain("personal_sign");
+    });
+  });
+
+  // ===========================================================================
+  // get_auth_status
+  // ===========================================================================
+  describe("get_auth_status", () => {
+    it("returns status object", async () => {
+      const result = (await handleRegistrationTool(
+        "get_auth_status",
+        {},
+      )) as { hasKey: boolean; chainId: number; source: string; isReadOnly: boolean };
+
+      expect(result.chainId).toBeTypeOf("number");
+      expect(result.source).toBeTypeOf("string");
+      expect(result.isReadOnly).toBeTypeOf("boolean");
+    });
+  });
+
+  // ===========================================================================
+  // configure_wallet
+  // ===========================================================================
+  describe("configure_wallet", () => {
+    it("configures with direct private key", async () => {
+      const key = "0x" + "ab".repeat(32);
+      const result = (await handleRegistrationTool("configure_wallet", {
+        privateKey: key,
+      })) as { success: boolean; method: string };
+
+      expect(result.success).toBe(true);
+      expect(result.method).toBe("direct_key");
+    });
+
+    it("rejects invalid private key format (no 0x)", async () => {
+      const result = (await handleRegistrationTool("configure_wallet", {
+        privateKey: "ab".repeat(32),
+      })) as { error: string };
+
+      expect(result.error).toContain("Invalid private key");
+    });
+
+    it("rejects private key with wrong length", async () => {
+      const result = (await handleRegistrationTool("configure_wallet", {
+        privateKey: "0x1234",
+      })) as { error: string };
+
+      expect(result.error).toContain("Invalid private key");
+    });
+
+    it("configures with signature derivation", async () => {
+      const sig = "0x" + "cd".repeat(65);
+      const result = (await handleRegistrationTool("configure_wallet", {
+        signature: sig,
+        signerAddress: "0xSomeAddress",
+      })) as { success: boolean; method: string; derivedAddress: string };
+
+      expect(result.success).toBe(true);
+      expect(result.method).toBe("derived_from_signature");
+      expect(result.derivedAddress).toBe("0xDerivedAddress1234");
+    });
+
+    it("rejects signature when verification fails", async () => {
+      (verifyDerivationSignature as ReturnType<typeof vi.fn>).mockReturnValueOnce(false);
+
+      const result = (await handleRegistrationTool("configure_wallet", {
+        signature: "0xbadsig",
+        signerAddress: "0xWrongAddress",
+      })) as { error: string };
+
+      expect(result.error).toContain("Signature verification failed");
+    });
+
+    it("sets chain only when no key or signature", async () => {
+      const result = (await handleRegistrationTool("configure_wallet", {
+        chainId: 8453,
+      })) as { success: boolean; method: string; chainId: number };
+
+      expect(result.success).toBe(true);
+      expect(result.method).toBe("chain_only");
+      expect(result.chainId).toBe(8453);
+    });
+
+    it("returns error when no args provided", async () => {
+      const result = (await handleRegistrationTool("configure_wallet", {})) as {
+        error: string;
+      };
+
+      expect(result.error).toContain("Provide either privateKey or signature");
+    });
+  });
+
+  // ===========================================================================
+  // register_agent
+  // ===========================================================================
+  describe("register_agent", () => {
+    it("registers agent via IPFS when authenticated", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+      const builder = makeAgentBuilder();
+      mockCreateAgent.mockReturnValue(builder);
+
+      const result = (await handleRegistrationTool("register_agent", {
+        name: "My Agent",
+        description: "A cool agent",
+        mcpEndpoint: "https://mcp.test",
+        active: true,
+        trustReputation: true,
+      })) as { success: boolean; agentId: string; txHash: string; method: string };
+
+      expect(result.success).toBe(true);
+      expect(result.agentId).toBe("11155111:99");
+      expect(result.txHash).toBe("0xtxhash123");
+      expect(result.method).toBe("ipfs");
+      expect(builder.setMCP).toHaveBeenCalledWith("https://mcp.test");
+      expect(builder.setTrust).toHaveBeenCalledWith(true, false, false);
+      expect(builder.setActive).toHaveBeenCalledWith(true);
+    });
+
+    it("registers agent on-chain when method is onchain", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+      const builder = makeAgentBuilder();
+      mockCreateAgent.mockReturnValue(builder);
+
+      const result = (await handleRegistrationTool("register_agent", {
+        name: "My Agent",
+        description: "On-chain agent",
+        registrationMethod: "onchain",
+      })) as { success: boolean; method: string; txHash: string };
+
+      expect(result.success).toBe(true);
+      expect(result.method).toBe("onchain");
+      expect(result.txHash).toBe("0xtxhash456");
+      expect(builder.registerOnChain).toHaveBeenCalled();
+    });
+
+    it("sets A2A endpoint when provided", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+      const builder = makeAgentBuilder();
+      mockCreateAgent.mockReturnValue(builder);
+
+      await handleRegistrationTool("register_agent", {
+        name: "A2A Agent",
+        description: "Has A2A",
+        a2aEndpoint: "https://a2a.test/agent.json",
+      });
+
+      expect(builder.setA2A).toHaveBeenCalledWith("https://a2a.test/agent.json");
+    });
+
+    it("sets metadata when provided", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+      const builder = makeAgentBuilder();
+      mockCreateAgent.mockReturnValue(builder);
+
+      await handleRegistrationTool("register_agent", {
+        name: "Meta Agent",
+        description: "Has metadata",
+        metadata: { version: "1.0" },
+      });
+
+      expect(builder.setMetadata).toHaveBeenCalledWith({ version: "1.0" });
+    });
+  });
+
+  // ===========================================================================
+  // update_agent
+  // ===========================================================================
+  describe("update_agent", () => {
+    it("returns error when agentId missing", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+
+      const result = (await handleRegistrationTool("update_agent", {})) as {
+        error: string;
+      };
+
+      expect(result.error).toContain("agentId is required");
+    });
+
+    it("updates agent properties", async () => {
+      setDerivedKey("0x" + "ff".repeat(32));
+      const builder = makeAgentBuilder();
+      mockLoadAgent.mockResolvedValue(builder);
+
+      const result = (await handleRegistrationTool("update_agent", {
+        agentId: "11155111:42",
+        description: "Updated description",
+        mcpEndpoint: "https://new-mcp.test",
+        active: false,
+      })) as { success: boolean; agentId: string; txHash: string };
+
+      expect(result.success).toBe(true);
+      expect(result.agentId).toBe("11155111:42");
+      expect(result.txHash).toBe("0xtxhash123");
+      expect(builder.updateInfo).toHaveBeenCalled();
+      expect(builder.setMCP).toHaveBeenCalledWith("https://new-mcp.test");
+      expect(builder.setActive).toHaveBeenCalledWith(false);
+    });
+  });
+
+  // ===========================================================================
+  // Unknown tool
+  // ===========================================================================
+  it("returns error for unknown tool", async () => {
+    const result = (await handleRegistrationTool("nonexistent", {})) as {
+      error: string;
+    };
+    expect(result.error).toContain("Unknown registration tool");
+  });
+});

package/tests/reputation.test.ts

@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock agent0-sdk
+vi.mock("agent0-sdk", () => {
+  const mockGiveFeedback = vi.fn().mockResolvedValue({
+    waitConfirmed: vi.fn().mockResolvedValue({
+      result: {},
+      receipt: { transactionHash: "0xfeedback_tx" },
+    }),
+  });
+  const mockRevokeFeedback = vi.fn().mockResolvedValue({
+    waitConfirmed: vi.fn().mockResolvedValue({
+      result: {},
+      receipt: { transactionHash: "0xrevoke_tx" },
+    }),
+  });
+  const mockPrepareFeedbackFile = vi.fn().mockReturnValue({ uri: "ipfs://feedback" });
+  const mockChainId = vi.fn().mockResolvedValue(11155111);
+
+  return {
+    SDK: vi.fn().mockImplementation(() => ({
+      giveFeedback: mockGiveFeedback,
+      revokeFeedback: mockRevokeFeedback,
+      prepareFeedbackFile: mockPrepareFeedbackFile,
+      chainId: mockChainId,
+    })),
+    __mocks: { mockGiveFeedback, mockRevokeFeedback, mockPrepareFeedbackFile },
+  };
+});
+
+import {
+  reputationTools,
+  handleReputationTool,
+} from "../src/tools/reputation.js";
+import { setDerivedKey, setChainId } from "../src/auth/sdk-client.js";
+
+async function getMocks() {
+  const mod = await import("agent0-sdk");
+  return (mod as unknown as { __mocks: Record<string, ReturnType<typeof vi.fn>> }).__mocks;
+}
+
+describe("reputation tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setChainId(11155111);
+    // Ensure auth is available for write tests
+    setDerivedKey("0x" + "aa".repeat(32));
+  });
+
+  // ===========================================================================
+  // Tool registration
+  // ===========================================================================
+  describe("tool registration", () => {
+    it("registers 2 reputation tools", () => {
+      expect(reputationTools).toHaveLength(2);
+    });
+
+    it("registers give_feedback", () => {
+      expect(reputationTools.find((t) => t.name === "give_feedback")).toBeDefined();
+    });
+
+    it("registers revoke_feedback", () => {
+      expect(reputationTools.find((t) => t.name === "revoke_feedback")).toBeDefined();
+    });
+  });
+
+  // ===========================================================================
+  // give_feedback
+  // ===========================================================================
+  describe("give_feedback", () => {
+    it("submits feedback successfully", async () => {
+      const mocks = await getMocks();
+
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 85,
+        tag1: "quality",
+      })) as { success: boolean; value: number; txHash: string; tags: string[] };
+
+      expect(result.success).toBe(true);
+      expect(result.value).toBe(85);
+      expect(result.txHash).toBe("0xfeedback_tx");
+      expect(result.tags).toContain("quality");
+      expect(mocks.mockGiveFeedback).toHaveBeenCalledWith(
+        "11155111:42",
+        85,
+        "quality",
+        undefined,
+        undefined,
+        undefined,
+      );
+    });
+
+    it("rejects value below 0", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: -1,
+      })) as { error: string };
+
+      expect(result.error).toContain("between 0 and 100");
+    });
+
+    it("rejects value above 100", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 101,
+      })) as { error: string };
+
+      expect(result.error).toContain("between 0 and 100");
+    });
+
+    it("accepts boundary value 0", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 0,
+      })) as { success: boolean; value: number };
+
+      expect(result.success).toBe(true);
+      expect(result.value).toBe(0);
+    });
+
+    it("accepts boundary value 100", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 100,
+      })) as { success: boolean; value: number };
+
+      expect(result.success).toBe(true);
+      expect(result.value).toBe(100);
+    });
+
+    it("prepares feedback file when text is provided", async () => {
+      const mocks = await getMocks();
+
+      await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 75,
+        text: "Great agent!",
+      });
+
+      expect(mocks.mockPrepareFeedbackFile).toHaveBeenCalledWith({
+        text: "Great agent!",
+        mcpTool: undefined,
+        a2aSkills: undefined,
+      });
+    });
+
+    it("prepares feedback file when mcpTool is provided", async () => {
+      const mocks = await getMocks();
+
+      await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 80,
+        mcpTool: "search",
+      });
+
+      expect(mocks.mockPrepareFeedbackFile).toHaveBeenCalled();
+    });
+
+    it("passes both tags", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 90,
+        tag1: "quality",
+        tag2: "reliability",
+      })) as { tags: string[] };
+
+      expect(result.tags).toEqual(["quality", "reliability"]);
+    });
+
+    it("extracts chainId from agentId", async () => {
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "8453:100",
+        value: 70,
+      })) as { chain: string };
+
+      expect(result.chain).toBe("Base");
+    });
+  });
+
+  // ===========================================================================
+  // revoke_feedback
+  // ===========================================================================
+  describe("revoke_feedback", () => {
+    it("revokes feedback successfully", async () => {
+      const mocks = await getMocks();
+
+      const result = (await handleReputationTool("revoke_feedback", {
+        agentId: "11155111:42",
+        feedbackIndex: 0,
+      })) as {
+        success: boolean;
+        feedbackIndex: number;
+        isRevoked: boolean;
+        txHash: string;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.feedbackIndex).toBe(0);
+      expect(result.isRevoked).toBe(true);
+      expect(result.txHash).toBe("0xrevoke_tx");
+      expect(mocks.mockRevokeFeedback).toHaveBeenCalledWith("11155111:42", 0);
+    });
+  });
+
+  // ===========================================================================
+  // requireAuth guard
+  // ===========================================================================
+  describe("requireAuth guard", () => {
+    it("give_feedback includes auth info in response", async () => {
+      // Auth is set in beforeEach, so this should succeed
+      const result = (await handleReputationTool("give_feedback", {
+        agentId: "11155111:42",
+        value: 50,
+      })) as { success?: boolean; error?: string };
+
+      // Should succeed since we set derived key in beforeEach
+      expect(result.success).toBe(true);
+    });
+  });
+
+  // ===========================================================================
+  // Unknown tool
+  // ===========================================================================
+  it("returns error for unknown tool", async () => {
+    const result = (await handleReputationTool("nonexistent", {})) as {
+      error: string;
+    };
+    expect(result.error).toContain("Unknown reputation tool");
+  });
+});