Release v0.28.4

Origin-SHA: 53bac65c7774e3b75a547bdf348186d4f2d11857

Co-authored-by: Benjamin C. LeFevre <35812202+BCLeFevre@users.noreply.github.com>

Author: CodySearsOS

CHANGELOG.md

@@ -1,5 +1,14 @@
 # @opensea/tool-sdk
 
+## 0.28.4
+
+### Patch Changes
+
+- a541527: Reject negative and malformed x402 payment amounts. A negative `maxAmountRequired` previously slipped under the signed-BigInt `maxAmount` cap check and, when signed, wrapped into a huge positive `uint256` EIP-3009 authorization — bypassing the caller's spending limit. Amounts are now validated as canonical non-negative integers in `validatePaymentRequirements` (unconditionally, even without a cap) and again in the EIP-3009 signer as defense-in-depth for direct `signX402Payment` callers.
+- Updated dependencies [569fd4f]
+- Updated dependencies [a541527]
+  - @opensea/wallet-adapters@0.3.3
+
 ## 0.28.3
 
 ### Patch Changes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opensea/tool-sdk",
-  "version": "0.28.3",
+  "version": "0.28.4",
   "type": "module",
   "description": "SDK and CLI for building ERC-8257 compliant AI agent tools",
   "repository": {
@@ -40,7 +40,7 @@
   },
   "dependencies": {
     "@clack/prompts": "0.10.1",
-    "@opensea/wallet-adapters": "^0.3.2",
+    "@opensea/wallet-adapters": "^0.3.3",
     "@x402/core": "2.15.0",
     "@x402/fetch": "2.15.0",
     "canonicalize": "2.1.0",

src/__tests__/describe-tool-access.test.ts

@@ -171,6 +171,70 @@ describe("describeToolAccess bounds enforcement", () => {
     ])
   })
 
+  it("reports open access when the tool has no predicate (zero address)", async () => {
+    mockGetToolConfig.mockResolvedValueOnce({
+      creator: getAddress("0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"),
+      metadataURI: "https://example.com/manifest.json",
+      manifestHash:
+        "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" as const,
+      accessPredicate:
+        "0x0000000000000000000000000000000000000000" as `0x${string}`,
+    })
+    const { describeToolAccess } = await import("../lib/onchain/access.js")
+
+    const result = await describeToolAccess({ toolId: TEST_TOOL_ID })
+
+    expect(result).toEqual({
+      openAccess: true,
+      predicateAddress: null,
+      predicateName: null,
+      requirements: [],
+      logic: "AND",
+    })
+    // Open-access tools must not staticcall the (nonexistent) predicate.
+    expect(mockReadContract).not.toHaveBeenCalled()
+  })
+
+  it("degrades predicateName to null when name() reverts", async () => {
+    mockReadContract.mockImplementation((args: { functionName: string }) => {
+      if (args.functionName === "name") {
+        return Promise.reject(new Error("execution reverted"))
+      }
+      return Promise.resolve([[goodRequirement], 0])
+    })
+    const { describeToolAccess } = await import("../lib/onchain/access.js")
+
+    const result = await describeToolAccess({ toolId: TEST_TOOL_ID })
+
+    expect(result.predicateName).toBeNull()
+    expect(result.requirements).toEqual([goodRequirement])
+  })
+
+  it("degrades to empty requirements when getRequirements() reverts", async () => {
+    mockReadContract.mockImplementation((args: { functionName: string }) => {
+      if (args.functionName === "name") {
+        return Promise.resolve("MyPredicate")
+      }
+      return Promise.reject(new Error("execution reverted"))
+    })
+    const { describeToolAccess } = await import("../lib/onchain/access.js")
+
+    const result = await describeToolAccess({ toolId: TEST_TOOL_ID })
+
+    expect(result.predicateName).toBe("MyPredicate")
+    expect(result.requirements).toEqual([])
+    expect(result.logic).toBe("AND")
+  })
+
+  it("maps a logic value of 1 to OR", async () => {
+    routeReadContract({ requirements: [goodRequirement], logic: 1 })
+    const { describeToolAccess } = await import("../lib/onchain/access.js")
+
+    const result = await describeToolAccess({ toolId: TEST_TOOL_ID })
+
+    expect(result.logic).toBe("OR")
+  })
+
   it("accepts entries exactly at the data and label caps", async () => {
     const dataAtCap = `0x${"00".repeat(4096)}` as `0x${string}`
     const labelAtCap = "x".repeat(256)

src/__tests__/handler.test.ts

@@ -408,6 +408,59 @@ describe("createToolHandler", () => {
     expect(reportSettled).toHaveBeenCalledOnce()
   })
 
+  it("auto-detects the Vercel request-context waitUntil when none is configured", async () => {
+    let releaseReport: () => void = () => {}
+    const reportSettled = vi.fn()
+    const pendingReport = new Promise<void>(resolve => {
+      releaseReport = () => {
+        reportSettled()
+        resolve()
+      }
+    })
+    vi.mocked(createEip3009UsageReporter).mockReturnValueOnce(
+      vi.fn().mockReturnValue(pendingReport),
+    )
+
+    // Simulate the Vercel runtime by populating the request-context global the
+    // handler reads (the same one `@vercel/functions` uses). No `waitUntil`
+    // config is passed, so the handler must discover this one on its own.
+    const registered: Promise<unknown>[] = []
+    const vercelWaitUntil = vi.fn((p: Promise<unknown>) => {
+      registered.push(p)
+    })
+    const contextSymbol = Symbol.for("@vercel/request-context")
+    ;(globalThis as Record<symbol, unknown>)[contextSymbol] = {
+      get: () => ({ waitUntil: vercelWaitUntil }),
+    }
+
+    try {
+      const handler = createToolHandler({
+        manifest: testManifest,
+        inputSchema: InputSchema,
+        outputSchema: OutputSchema,
+        usageReporting: {} as Eip3009UsageReporterConfig,
+        handler: async input => ({ result: `Echo: ${input.query}` }),
+      })
+      const request = new Request("https://test.example.com/api", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query: "test" }),
+      })
+
+      const response = await handler(request)
+
+      expect(response.status).toBe(200)
+      expect(vercelWaitUntil).toHaveBeenCalledOnce()
+      expect(reportSettled).not.toHaveBeenCalled()
+
+      releaseReport()
+      await registered[0]
+      expect(reportSettled).toHaveBeenCalledOnce()
+    } finally {
+      ;(globalThis as Record<symbol, unknown>)[contextSymbol] = undefined
+    }
+  })
+
   it("does not call settle() when a gate short-circuits with a response", async () => {
     const settle = vi.fn()
     const gate: GateMiddleware = {