safehands-pharos 1.5.0 → 2.6.0

package/dist/tools/tokenRegistryStatus.js

@@ -1,38 +1,53 @@
 // ─── Tool: token_registry_status ───────────────────────────────────────
-// Classify exact token addresses without silently replacing user input.
-// The official Pharos Skill Engine (pharos-skill-engine-0.1.0)
-// assets/tokens.json lists 0xE0BE... as USDC for atlantic-testnet.
+// Classify exact token inputs against the active network token registry.
+// Pacific Mainnet uses PACIFIC_MAINNET_TOKEN_REGISTRY; Atlantic Testnet keeps
+// the legacy testnet registry for compatibility.
 // ───────────────────────────────────────────────────────────────────────
 import { z } from "zod";
 import { getAddress, isAddress } from "viem";
 import { ok } from "../lib/toolResponse.js";
-import { TOKEN_REGISTRY, CIRCLE_USDC_ADDRESS, CHAIN_ID, PHAROS_ENVIRONMENT } from "../lib/constants.js";
+import { TOKEN_REGISTRY, CIRCLE_USDC_ADDRESS, CHAIN_ID, PHAROS_ENVIRONMENT, IS_MAINNET, PACIFIC_MAINNET_TOKEN_REGISTRY, } from "../lib/constants.js";
+import { getActiveNetwork } from "../lib/networks.js";
+import { fetchGoplusTokenIdentity } from "./checkTokenSecurity.js";
 export const tokenRegistryStatusSchema = z.object({
     token: z.string().optional().describe("Token symbol or exact contract address to classify"),
     tokenAddress: z.string().optional().describe("Exact token contract address to classify"),
 });
+function activeRegistry() {
+    return getActiveNetwork().isMainnet
+        ? PACIFIC_MAINNET_TOKEN_REGISTRY
+        : TOKEN_REGISTRY;
+}
 function deriveStatus(match) {
+    if (getActiveNetwork().isMainnet || match.isMainnet)
+        return "CANONICAL_MAINNET_TOKEN";
     if (match.verificationStatus === "DOCS_VERIFIED_FROM_PHAROS_SKILL_ENGINE")
         return "SKILL_ENGINE_CANONICAL_TOKEN";
     if (match.verificationStatus === "CIRCLE_REFERENCED_USDC")
         return "ALTERNATE_SOURCE_TOKEN";
-    return "CANONICAL_TESTNET_TOKEN";
+    return "CANONICAL_MAINNET_TOKEN";
+}
+function responseBase() {
+    return {
+        chainId: CHAIN_ID,
+        environment: PHAROS_ENVIRONMENT,
+        isMainnet: IS_MAINNET,
+    };
 }
 export function classifyTokenRegistryStatus(token) {
     const raw = token.trim();
     const upper = raw.toUpperCase();
-    const bySymbol = TOKEN_REGISTRY[upper];
+    const registry = activeRegistry();
+    const bySymbol = registry[upper];
     if (bySymbol) {
         return {
             input: token,
             normalizedAddress: bySymbol.address,
             symbol: bySymbol.symbol,
             status: deriveStatus(bySymbol),
-            verificationStatus: bySymbol.verificationStatus || (bySymbol.isCanonical ? "PROJECT_CONFIGURED" : "UNVERIFIED_CONFIG_VALUE"),
-            docsSource: bySymbol.docsSource || "project constants",
-            chainId: CHAIN_ID,
-            environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            verificationStatus: bySymbol.verificationStatus || (bySymbol.isCanonical ? "DOCS_VERIFIED" : "UNVERIFIED_CONFIG_VALUE"),
+            docsSource: bySymbol.docsSource || "active network token registry",
+            ...responseBase(),
         };
     }
     if (!isAddress(raw)) {
@@ -40,16 +55,14 @@ export function classifyTokenRegistryStatus(token) {
             input: token,
             normalizedAddress: null,
             symbol: null,
-            status: "INVALID_ADDRESS",
-            verificationStatus: "INVALID_ADDRESS",
+            status: (raw ? "UNKNOWN" : "INVALID_ADDRESS"),
+            verificationStatus: raw ? "UNKNOWN_SYMBOL" : "INVALID_ADDRESS",
             docsSource: null,
-            chainId: CHAIN_ID,
-            environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            ...responseBase(),
         };
     }
     const checksum = getAddress(raw);
-    const entries = Object.values(TOKEN_REGISTRY);
+    const entries = Object.values(registry);
     const match = entries.find((t) => t.address.toLowerCase() === checksum.toLowerCase());
     if (match) {
         return {
@@ -57,15 +70,14 @@ export function classifyTokenRegistryStatus(token) {
             normalizedAddress: checksum,
             symbol: match.symbol,
             status: deriveStatus(match),
-            verificationStatus: match.verificationStatus || "PROJECT_CONFIGURED",
-            docsSource: match.docsSource || "project constants",
-            chainId: CHAIN_ID,
-            environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            verificationStatus: match.verificationStatus || (getActiveNetwork().isMainnet ? "DOCS_VERIFIED" : "PROJECT_CONFIGURED"),
+            docsSource: match.docsSource || "active network token registry",
+            ...responseBase(),
         };
     }
-    // Check if it's the Circle USDC address directly (even if not primary)
-    if (checksum.toLowerCase() === CIRCLE_USDC_ADDRESS.toLowerCase()) {
+    // Atlantic-only alternate USDC recognition. On Pacific Mainnet this old
+    // address is intentionally treated as custom/non-registry.
+    if (!getActiveNetwork().isMainnet && checksum.toLowerCase() === CIRCLE_USDC_ADDRESS.toLowerCase()) {
         return {
             input: token,
             normalizedAddress: checksum,
@@ -73,9 +85,7 @@ export function classifyTokenRegistryStatus(token) {
             status: "ALTERNATE_SOURCE_TOKEN",
             verificationStatus: "CIRCLE_REFERENCED_USDC",
             docsSource: "https://developers.circle.com/stablecoins/usdc-contract-addresses",
-            chainId: CHAIN_ID,
-            environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            ...responseBase(),
         };
     }
     return {
@@ -85,13 +95,33 @@ export function classifyTokenRegistryStatus(token) {
         status: "CUSTOM_NON_REGISTRY",
         verificationStatus: "UNVERIFIED_CUSTOM_TOKEN",
         docsSource: null,
-        chainId: CHAIN_ID,
-        environment: PHAROS_ENVIRONMENT,
-        isMainnet: false,
+        ...responseBase(),
     };
 }
 export async function handleTokenRegistryStatus(raw) {
     const input = tokenRegistryStatusSchema.parse(raw);
-    return ok(classifyTokenRegistryStatus(input.tokenAddress || input.token || ""));
+    const classification = classifyTokenRegistryStatus(input.tokenAddress || input.token || "");
+    // For custom/non-registry tokens, best-effort DISPLAY-ONLY identity enrichment.
+    // Purely additive: status/verificationStatus/symbol are never altered, metadata
+    // is never fed into policy or gates (those consume classifyTokenRegistryStatus
+    // directly), and a fetch failure leaves the response identical to before.
+    if (classification.status !== "CUSTOM_NON_REGISTRY" || !classification.normalizedAddress) {
+        return ok(classification);
+    }
+    const identity = await fetchGoplusTokenIdentity(classification.normalizedAddress);
+    if (!identity.tokenName && !identity.tokenSymbol) {
+        return ok(classification);
+    }
+    return ok({
+        ...classification,
+        tokenMetadata: {
+            tokenName: identity.tokenName,
+            tokenSymbol: identity.tokenSymbol,
+            source: "goplus_metadata",
+            verified: false,
+            displayOnly: true,
+            warning: "Untrusted display-only metadata reported by a third-party API. It does NOT verify this token's identity and does NOT imply the token is safe. The token remains UNVERIFIED_CUSTOM_TOKEN; anyone can deploy a token with any name/symbol.",
+        },
+    });
 }
 //# sourceMappingURL=tokenRegistryStatus.js.map

package/dist/tools/tokenRegistryStatus.js.map

@@ -1 +1 @@
-{"version":3,"file":"tokenRegistryStatus.js","sourceRoot":"","sources":["../../src/tools/tokenRegistryStatus.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tokenRegistryStatus.js","sourceRoot":"","sources":["../../src/tools/tokenRegistryStatus.ts"],"names":[],"mappings":"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"}

package/dist/tools/verifyRiskInclusion.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export declare const verifyRiskInclusionSchema: z.ZodObject<{
+    target: z.ZodString;
+    actionHash: z.ZodOptional<z.ZodString>;
+    verifyOnchain: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    verifyOnchain: boolean;
+    actionHash?: string | undefined;
+}, {
+    target: string;
+    actionHash?: string | undefined;
+    verifyOnchain?: boolean | undefined;
+}>;
+export type VerifyRiskInclusionInput = z.input<typeof verifyRiskInclusionSchema>;
+export declare const verifyRiskInclusionTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        target: z.ZodString;
+        actionHash: z.ZodOptional<z.ZodString>;
+        verifyOnchain: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        target: string;
+        verifyOnchain: boolean;
+        actionHash?: string | undefined;
+    }, {
+        target: string;
+        actionHash?: string | undefined;
+        verifyOnchain?: boolean | undefined;
+    }>;
+};
+export declare function handleVerifyRiskInclusion(raw: VerifyRiskInclusionInput): Promise<import("../sdk.js").ToolFailure | import("../sdk.js").ToolSuccess<{
+    registryContract: string | null;
+    included: boolean;
+    configured: boolean;
+    committed: boolean;
+    onchainMerkleRoot: string | null;
+    dataURI: string | null;
+    found: boolean;
+    rootMatches: boolean;
+    verifiedLocal: boolean;
+    verifiedOnchain: boolean | null;
+    expired: boolean;
+    proof: string[] | null;
+    record: {
+        target: string;
+        actionHash: string;
+        score: number;
+        level: number;
+        recommendation: number;
+        policyVersionHash: string;
+        evidenceHash: string;
+        expiresAt: string;
+    } | null;
+    source: "onchain-view" | "local-only" | "unconfigured" | "not-committed" | "not-found" | "root-mismatch" | "error";
+    error?: string;
+}>>;
+//# sourceMappingURL=verifyRiskInclusion.d.ts.map

package/dist/tools/verifyRiskInclusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyRiskInclusion.d.ts","sourceRoot":"","sources":["../../src/tools/verifyRiskInclusion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEjF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;CAOnC,CAAC;AAEF,wBAAsB,yBAAyB,CAAC,GAAG,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;IA4B5E"}

package/dist/tools/verifyRiskInclusion.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { isAddress } from "viem";
+import { ok, fail } from "../lib/toolResponse.js";
+import { SAFEHANDS_REGISTRY_ADDRESS } from "../lib/constants.js";
+import { verifyRiskInclusion } from "../lib/riskInclusion.js";
+export const verifyRiskInclusionSchema = z.object({
+    target: z.string().describe("The address whose risk record you want to prove is included in the committed on-chain Merkle root."),
+    actionHash: z.string().optional().describe("Optional 32-byte action hash to disambiguate when a target has multiple records in the batch."),
+    verifyOnchain: z.boolean().optional().default(true).describe("If true (default), also verify the Merkle proof through the contract's verifyRiskRecord view for a trustless result."),
+});
+export const verifyRiskInclusionTool = {
+    name: "verify_risk_inclusion",
+    description: "Prove a target's SafeHands risk record is included in the currently committed on-chain Merkle root. " +
+        "Fetches the committed root + data-availability batch, rebuilds the Merkle proof, and verifies it both " +
+        "locally and (by default) through the SafeHandsRegistry.verifyRiskRecord view. Read-only, keyless, composable.",
+    inputSchema: verifyRiskInclusionSchema,
+};
+export async function handleVerifyRiskInclusion(raw) {
+    const input = verifyRiskInclusionSchema.parse(raw);
+    if (!isAddress(input.target)) {
+        return fail("VALIDATION_ERROR", "target is not a valid EVM address.", false, "verify_risk_inclusion");
+    }
+    try {
+        const result = await verifyRiskInclusion({ target: input.target, actionHash: input.actionHash }, { verifyOnchain: input.verifyOnchain });
+        return ok({
+            ...result,
+            registryContract: SAFEHANDS_REGISTRY_ADDRESS || null,
+            // A single, unambiguous verdict for callers that don't want to interpret the flags themselves.
+            included: Boolean(result.found &&
+                result.rootMatches &&
+                result.verifiedLocal &&
+                (result.verifiedOnchain === null || result.verifiedOnchain === true) &&
+                !result.expired),
+        });
+    }
+    catch (err) {
+        return fail("RISK_INCLUSION_FAILED", `Failed to verify risk inclusion: ${err.message}`, true, "verify_risk_inclusion");
+    }
+}
+//# sourceMappingURL=verifyRiskInclusion.js.map

package/dist/tools/verifyRiskInclusion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyRiskInclusion.js","sourceRoot":"","sources":["../../src/tools/verifyRiskInclusion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,oGAAoG,CAAC;IACjI,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,+FAA+F,CAAC;IAC3I,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,sHAAsH,CAAC;CACrL,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EACT,sGAAsG;QACtG,wGAAwG;QACxG,+GAA+G;IACjH,WAAW,EAAE,yBAAyB;CACvC,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,GAA6B;IAC3E,MAAM,KAAK,GAAG,yBAAyB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAEnD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,kBAAkB,EAAE,oCAAoC,EAAE,KAAK,EAAE,uBAAuB,CAAC,CAAC;IACxG,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,mBAAmB,CACtC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EACtD,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CACvC,CAAC;QAEF,OAAO,EAAE,CAAC;YACR,GAAG,MAAM;YACT,gBAAgB,EAAE,0BAA0B,IAAI,IAAI;YACpD,+FAA+F;YAC/F,QAAQ,EAAE,OAAO,CACf,MAAM,CAAC,KAAK;gBACV,MAAM,CAAC,WAAW;gBAClB,MAAM,CAAC,aAAa;gBACpB,CAAC,MAAM,CAAC,eAAe,KAAK,IAAI,IAAI,MAAM,CAAC,eAAe,KAAK,IAAI,CAAC;gBACpE,CAAC,MAAM,CAAC,OAAO,CAClB;SACF,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,IAAI,CAAC,uBAAuB,EAAE,oCAAqC,GAAa,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,uBAAuB,CAAC,CAAC;IACpI,CAAC;AACH,CAAC"}

package/dist/tools/x402PayAndFetch.d.ts

@@ -6,9 +6,11 @@ export declare const x402PayAndFetchSchema: z.ZodObject<{
     rpcUrl: z.ZodOptional<z.ZodString>;
     agentId: z.ZodOptional<z.ZodString>;
     maxPaymentUsdc: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    url: string;
+    confirm: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
     method: "GET" | "POST" | "PUT" | "DELETE";
+    url: string;
+    confirm: boolean;
     maxPaymentUsdc: string;
     body?: string | undefined;
     agentId?: string | undefined;
@@ -18,6 +20,7 @@ export declare const x402PayAndFetchSchema: z.ZodObject<{
     body?: string | undefined;
     method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
     agentId?: string | undefined;
+    confirm?: boolean | undefined;
     rpcUrl?: string | undefined;
     maxPaymentUsdc?: string | undefined;
 }>;
@@ -32,9 +35,11 @@ export declare const x402PayAndFetchTool: {
         rpcUrl: z.ZodOptional<z.ZodString>;
         agentId: z.ZodOptional<z.ZodString>;
         maxPaymentUsdc: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        url: string;
+        confirm: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strict", z.ZodTypeAny, {
         method: "GET" | "POST" | "PUT" | "DELETE";
+        url: string;
+        confirm: boolean;
         maxPaymentUsdc: string;
         body?: string | undefined;
         agentId?: string | undefined;
@@ -44,11 +49,12 @@ export declare const x402PayAndFetchTool: {
         body?: string | undefined;
         method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
         agentId?: string | undefined;
+        confirm?: boolean | undefined;
         rpcUrl?: string | undefined;
         maxPaymentUsdc?: string | undefined;
     }>;
 };
-export declare function handleX402PayAndFetch(raw: X402PayAndFetchInput): Promise<import("../lib/toolResponse.js").ToolFailure | import("../lib/toolResponse.js").ToolSuccess<{
+export declare function handleX402PayAndFetch(raw: X402PayAndFetchInput): Promise<import("../sdk.js").ToolFailure | import("../sdk.js").ToolSuccess<{
     status: number;
     statusText: string;
     data: unknown;
@@ -57,9 +63,9 @@ export declare function handleX402PayAndFetch(raw: X402PayAndFetchInput): Promis
     chainId: number;
     environment: string;
     isMainnet: boolean;
-    policy: import("../lib/policy/actionPolicyEngine.js").ActionPolicyResult;
+    policy: import("../sdk.js").ActionPolicyResult;
     source: string;
-}> | import("../lib/toolResponse.js").ToolSuccess<{
+}> | import("../sdk.js").ToolSuccess<{
     status: number;
     statusText: string;
     data: unknown;
@@ -75,8 +81,8 @@ export declare function handleX402PayAndFetch(raw: X402PayAndFetchInput): Promis
     chainId: number;
     environment: string;
     isMainnet: boolean;
-    policy: import("../lib/policy/actionPolicyEngine.js").ActionPolicyResult;
-    testnetPayment: boolean;
+    policy: import("../sdk.js").ActionPolicyResult;
+    mainnetPayment: boolean;
     source: string;
 }>>;
 //# sourceMappingURL=x402PayAndFetch.d.ts.map

package/dist/tools/x402PayAndFetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x402PayAndFetch.d.ts","sourceRoot":"","sources":["../../src/tools/x402PayAndFetch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEzE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;CAM/B,CAAC;AA0BF,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6HpE"}
+{"version":3,"file":"x402PayAndFetch.d.ts","sourceRoot":"","sources":["../../src/tools/x402PayAndFetch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAQvB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEzE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM/B,CAAC;AA+DF,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkPpE"}

package/dist/tools/x402PayAndFetch.js

@@ -5,23 +5,29 @@
 import { z } from "zod";
 import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
 import { registerExactEvmScheme } from "@x402/evm/exact/client";
-import { CHAIN_ID, PHAROS_ENVIRONMENT, RPC_URL, MAX_X402_PAYMENT_USDC, X402_PAYMENT_TOKEN_ADDRESS } from "../lib/constants.js";
+import { CHAIN_ID, PHAROS_ENVIRONMENT, RPC_URL, MAX_X402_PAYMENT_USDC, X402_PAYMENT_TOKEN_ADDRESS, IS_MAINNET, activeX402AllowedTokenAddresses } from "../lib/constants.js";
 import { assertSafeFetchUrl, fetchWithTimeoutAndRetry } from "../lib/http.js";
 import { fail, ok, requireWriteToolsEnabled } from "../lib/toolResponse.js";
 import { getSigner, isSignerFailure } from "../lib/signer/index.js";
+import { checkManagedWalletAuthorization } from "../lib/safeHandsRegistry.js";
+import { REQUIRE_AUTHORIZED_AGENT_FOR_X402 } from "../lib/constants.js";
 import { evaluateActionPolicy } from "../lib/policy/actionPolicyEngine.js";
+import { enforceWriteDecision } from "../lib/policy/writeExecutionGate.js";
+import { validatePositiveAmount } from "../lib/validation.js";
+import { reserveDailyLimit, releaseReservation, estimateUsd } from "../lib/spendAccumulator.js";
 export const x402PayAndFetchSchema = z.object({
     url: z.string().describe("Target URL of the protected resource requiring x402 payment"),
     method: z.enum(["GET", "POST", "PUT", "DELETE"]).optional().default("GET").describe("HTTP method to use"),
     body: z.string().optional().describe("Optional stringified JSON request body"),
-    rpcUrl: z.string().optional().describe("Custom RPC URL for payment verification (defaults to Atlantic Testnet RPC)"),
-    agentId: z.string().optional().describe("Managed testnet wallet agentId when WALLET_MODE=managed-testnet"),
+    rpcUrl: z.string().optional().describe("Custom RPC URL for payment verification"),
+    agentId: z.string().optional().describe("Managed wallet agentId when WALLET_MODE=managed-mainnet"),
     maxPaymentUsdc: z.string().optional().default(MAX_X402_PAYMENT_USDC),
-});
+    confirm: z.boolean().optional().default(false).describe("Explicit acknowledgement to proceed when SafeHands returns REQUIRE_CONFIRMATION for the payment. Hard BLOCK / SSRF / over-limit / unsupported-token are never overridable."),
+}).strict();
 export const x402PayAndFetchTool = {
     name: "x402_pay_and_fetch",
     description: "Fetch resources from an HTTP x402 payment-gated server. " +
-        "If the server challenges with HTTP 402, this tool signs the required testnet payment payload and completes the fetch.",
+        "If the server challenges with HTTP 402, this tool signs the required mainnet payment payload and completes the fetch.",
     inputSchema: x402PayAndFetchSchema,
 };
 async function readResponseBody(res) {
@@ -47,8 +53,56 @@ function buildFetchOptions(input) {
         fetchOptions.body = input.body;
     return fetchOptions;
 }
+function x402AllowedTokenSet() {
+    return new Set(activeX402AllowedTokenAddresses().map((a) => a.toLowerCase()));
+}
+function validateX402Challenge(challengeHeader, maxPaymentUsdc) {
+    if (!challengeHeader)
+        return null;
+    try {
+        const decoded = JSON.parse(Buffer.from(challengeHeader, "base64").toString("utf-8"));
+        if (decoded.maxAmountRequired) {
+            const challengeAmount = Number(decoded.maxAmountRequired) / 1e6;
+            if (challengeAmount > Number(maxPaymentUsdc)) {
+                return `x402 challenge amount (${challengeAmount} USDC) exceeds maxPaymentUsdc (${maxPaymentUsdc}).`;
+            }
+        }
+        if (decoded.network) {
+            const parts = String(decoded.network).split(":");
+            const challengeChainId = parts.length === 2 ? Number(parts[1]) : Number(decoded.network);
+            if (Number.isFinite(challengeChainId) && challengeChainId !== CHAIN_ID) {
+                return `x402 challenge targets chain ${challengeChainId}, expected ${PHAROS_ENVIRONMENT} (${CHAIN_ID}).`;
+            }
+        }
+        if (decoded.asset) {
+            const asset = String(decoded.asset).toLowerCase();
+            if (!x402AllowedTokenSet().has(asset)) {
+                const allowed = activeX402AllowedTokenAddresses().join(", ");
+                return `x402 challenge requests payment in unsupported token ${decoded.asset}. Supported for ${PHAROS_ENVIRONMENT}: ${allowed}.`;
+            }
+        }
+    }
+    catch {
+        // Challenge header not parseable — proceed with caution but don't block
+    }
+    return null;
+}
 export async function handleX402PayAndFetch(raw) {
-    const input = x402PayAndFetchSchema.parse(raw);
+    let input;
+    try {
+        input = x402PayAndFetchSchema.parse(raw);
+    }
+    catch (err) {
+        const msg = err instanceof z.ZodError
+            ? err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+            : String(err);
+        return fail("VALIDATION_ERROR", `x402_pay_and_fetch input validation failed: ${msg}`, false, "x402_pay_and_fetch");
+    }
+    if (input.maxPaymentUsdc) {
+        const amtErr = validatePositiveAmount(input.maxPaymentUsdc, "maxPaymentUsdc");
+        if (amtErr)
+            return fail("VALIDATION_ERROR", amtErr, false, "x402_pay_and_fetch");
+    }
     try {
         await assertSafeFetchUrl(input.url);
     }
@@ -57,24 +111,43 @@ export async function handleX402PayAndFetch(raw) {
     }
     const staticPolicy = evaluateActionPolicy({
         actionType: "x402_pay_and_fetch",
+        agentId: input.agentId,
         url: input.url,
         paymentAmountUsdc: input.maxPaymentUsdc,
         paymentTokenAddress: X402_PAYMENT_TOKEN_ADDRESS,
         chainId: CHAIN_ID,
         environment: PHAROS_ENVIRONMENT,
-        isMainnet: false,
+        isMainnet: IS_MAINNET,
     });
     if (staticPolicy.decision === "BLOCK") {
         return fail("POLICY_BLOCKED", staticPolicy.reasons.join(" ") || "x402 request blocked by SafeHands policy.", false, "x402_pay_and_fetch");
     }
     const fetchOptions = buildFetchOptions(input);
+    // Daily-cap reservation state, hoisted above the try so the catch block can
+    // return the budget if the paying fetch throws after the reserve.
+    let reservedUsd = 0;
+    let reservedWallet = null;
     try {
-        const initial = await fetchWithTimeoutAndRetry(input.url, {
-            ...fetchOptions,
-            timeoutMs: 10_000,
-            retries: 1,
-            retryDelayMs: 250,
-        });
+        let initial;
+        try {
+            initial = await fetchWithTimeoutAndRetry(input.url, {
+                ...fetchOptions,
+                timeoutMs: 10_000,
+                retries: 1,
+                retryDelayMs: 250,
+            });
+        }
+        catch (err) {
+            // fetchWithTimeoutAndRetry follows redirects internally and re-validates
+            // SSRF on every hop (initial URL and every redirect target). Surface
+            // that as the same clean SSRF_BLOCKED error code used for the upfront
+            // check, instead of falling through to the generic X402_PAYMENT_FAILED.
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("SSRF_BLOCKED")) {
+                return fail("SSRF_BLOCKED", msg.replace(/^SSRF_BLOCKED:\s*/, ""), false, "x402_pay_and_fetch");
+            }
+            throw err;
+        }
         if (initial.status !== 402) {
             const data = await readResponseBody(initial);
             return ok({
@@ -85,11 +158,16 @@ export async function handleX402PayAndFetch(raw) {
                 paymentDetails: null,
                 chainId: CHAIN_ID,
                 environment: PHAROS_ENVIRONMENT,
-                isMainnet: false,
+                isMainnet: IS_MAINNET,
                 policy: staticPolicy,
                 source: "x402_fetch",
             });
         }
+        const challengeHeader = initial.headers.get("PAYMENT-REQUIRED");
+        const challengeError = validateX402Challenge(challengeHeader, input.maxPaymentUsdc);
+        if (challengeError) {
+            return fail("X402_CHALLENGE_INVALID", challengeError, false, "x402_pay_and_fetch");
+        }
         const writeGuard = requireWriteToolsEnabled("x402_pay_and_fetch");
         if (writeGuard)
             return writeGuard;
@@ -97,20 +175,42 @@ export async function handleX402PayAndFetch(raw) {
         if (isSignerFailure(signer)) {
             return fail("X402_PAYMENT_REQUIRED", `The resource returned HTTP 402, but no safe x402 signer is available: ${signer.error.message}`, false, "x402_pay_and_fetch");
         }
+        // x402 is permissionless-first: self-signed x402 (mode "x402-env") never needs
+        // registry authorization. A managed/custodial x402 payment is allowlist-gated
+        // ONLY when explicitly opted in via REQUIRE_AUTHORIZED_AGENT_FOR_X402=true.
+        if (signer.mode === "managed-mainnet" && REQUIRE_AUTHORIZED_AGENT_FOR_X402) {
+            const authCheck = await checkManagedWalletAuthorization(signer.address);
+            if (!authCheck.authorized) {
+                return fail("REQUIRE_AUTHORIZATION", authCheck.errorMessage || "Managed wallet is not authorized in SafeHandsRegistry.", false, "x402_pay_and_fetch");
+            }
+        }
         const paymentPolicy = evaluateActionPolicy({
             actionType: "x402_pay_and_fetch",
+            agentId: input.agentId,
             url: input.url,
             paymentAmountUsdc: input.maxPaymentUsdc,
             paymentTokenAddress: X402_PAYMENT_TOKEN_ADDRESS,
             chainId: CHAIN_ID,
             environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            isMainnet: IS_MAINNET,
             signerAvailable: true,
             requiresSigner: true,
         });
-        if (paymentPolicy.decision === "BLOCK") {
-            return fail("POLICY_BLOCKED", paymentPolicy.reasons.join(" ") || "x402 payment blocked by SafeHands policy.", false, "x402_pay_and_fetch");
+        const paymentGate = enforceWriteDecision(paymentPolicy, { confirmed: input.confirm === true, toolName: "x402_pay_and_fetch" });
+        if (paymentGate)
+            return paymentGate;
+        // x402 payments count toward the same per-wallet daily USD cap as
+        // send_payment / execute_swap — otherwise a looping agent could drain the
+        // wallet in per-call-cap increments. Reserve the payment BOUND
+        // (maxPaymentUsdc; the 402 challenge amount is validated to be ≤ this)
+        // atomically before the paying fetch, and release it if no payment settles.
+        const reserveUsd = estimateUsd(input.maxPaymentUsdc, "USDC");
+        const reservation = reserveDailyLimit(signer.address, reserveUsd);
+        if (!reservation.allowed) {
+            return fail("DAILY_SPEND_LIMIT_EXCEEDED", `Daily spend limit reached. Spent $${reservation.currentUsd.toFixed(2)} of $${reservation.limitUsd.toFixed(2)} USD today. Remaining: $${reservation.remainingUsd.toFixed(2)}. Resets at UTC midnight.`, false, "x402_pay_and_fetch");
         }
+        reservedUsd = reserveUsd;
+        reservedWallet = signer.address;
         const rpc = input.rpcUrl || process.env.PHAROS_RPC_URL || RPC_URL;
         const client = new x402Client();
         registerExactEvmScheme(client, {
@@ -119,10 +219,46 @@ export async function handleX402PayAndFetch(raw) {
                 [CHAIN_ID]: { rpcUrl: rpc },
             },
         });
-        const fetchWithPayment = wrapFetchWithPayment(fetch, client);
+        // wrapFetchWithPayment always invokes the supplied fetch with a single
+        // Request object (it builds one internally via `new Request(input, init)`
+        // and clones it for retries/hooks). This guard re-derives the URL/method/
+        // headers/body from that Request and routes the actual network call
+        // through fetchWithTimeoutAndRetry, so the payment-carrying request — the
+        // most sensitive call in this flow — gets the same DNS-pinned SSRF
+        // protection as the initial request instead of bypassing it via the raw
+        // global fetch.
+        const guardedFetch = async (requestInput, requestInit) => {
+            const req = requestInput instanceof Request ? requestInput : new Request(requestInput, requestInit);
+            const method = req.method || "GET";
+            const headersInit = {};
+            req.headers.forEach((value, key) => {
+                headersInit[key] = value;
+            });
+            let body;
+            if (method !== "GET" && method !== "HEAD") {
+                const buf = await req.arrayBuffer();
+                if (buf.byteLength > 0)
+                    body = new Uint8Array(buf);
+            }
+            return fetchWithTimeoutAndRetry(req.url, {
+                method,
+                headers: headersInit,
+                body,
+                timeoutMs: 10_000,
+                retries: 0, // avoid duplicate payment submission on a transient error
+            });
+        };
+        const fetchWithPayment = wrapFetchWithPayment(guardedFetch, client);
         const paidResponse = await fetchWithPayment(input.url, fetchOptions);
         const data = await readResponseBody(paidResponse);
         const paymentResponseHeader = paidResponse.headers.get("PAYMENT-RESPONSE");
+        if (!paymentResponseHeader) {
+            // No payment actually settled (e.g. the resource stopped charging) —
+            // return the reserved budget so unpaid fetches never consume the cap.
+            releaseReservation(signer.address, reservedUsd);
+            reservedUsd = 0;
+            reservedWallet = null;
+        }
         return ok({
             status: paidResponse.status,
             statusText: paidResponse.statusText,
@@ -140,13 +276,20 @@ export async function handleX402PayAndFetch(raw) {
             maxPaymentUsdc: input.maxPaymentUsdc,
             chainId: CHAIN_ID,
             environment: PHAROS_ENVIRONMENT,
-            isMainnet: false,
+            isMainnet: IS_MAINNET,
             policy: paymentPolicy,
-            testnetPayment: true,
+            mainnetPayment: true,
             source: "x402_fetch",
         });
     }
     catch (err) {
+        // A payment that failed in flight is ambiguous (it MAY have settled), but
+        // the x402 replay store makes a re-submission of the same authorization
+        // safe — release the reservation so a transient fetch error does not
+        // permanently consume the daily budget.
+        if (reservedWallet && reservedUsd > 0) {
+            releaseReservation(reservedWallet, reservedUsd);
+        }
         return fail("X402_PAYMENT_FAILED", err instanceof Error ? err.message : String(err), true, "x402_pay_and_fetch");
     }
 }