safehands-pharos 1.4.0 → 1.5.0

package/dist/tools/sendPayment.js

@@ -1,118 +1,118 @@
-// ─── Tool: send_payment ────────────────────────────────────────────────
-import { z } from "zod";
-import { publicClient, createPharosWalletClientFromAccount, getExplorerUrl } from "../lib/pharosClient.js";
-import { isAddress, parseEther, formatEther } from "viem";
-import { assessRisk } from "../lib/riskEngine.js";
-import { fail, ok, classifyExternalError } from "../lib/toolResponse.js";
-import { MAX_BALANCE_USAGE_PCT, RISK_BLOCK_THRESHOLD, MAX_TX_AMOUNT_PHRS, CHAIN_ID, PHAROS_ENVIRONMENT } from "../lib/constants.js";
-import { getSigner, isSignerFailure } from "../lib/signer/index.js";
-import { evaluateActionPolicy } from "../lib/policy/actionPolicyEngine.js";
-import { checkDailyLimit, recordSpend, estimateUsd } from "../lib/spendAccumulator.js";
-export const sendPaymentSchema = z.object({
-    toAddress: z.string(),
-    amount: z.string(),
-    memo: z.string().optional(),
-    agentId: z.string().optional().describe("Managed testnet wallet agentId when WALLET_MODE=managed-testnet"),
-});
-export const sendPaymentTool = {
-    name: "send_payment",
-    description: "Send native PHRS with pre-flight validation. Checks address validity, balance sufficiency, and warns on high exposure.",
-    inputSchema: sendPaymentSchema,
-};
-export async function handleSendPayment(raw) {
-    if (process.env.WRITE_TOOLS_ENABLED !== "true") {
-        return fail("WRITE_TOOLS_DISABLED", "send_payment is disabled by default. Set WRITE_TOOLS_ENABLED=true only for trusted testnet execution.", false, "send_payment");
-    }
-    const input = sendPaymentSchema.parse(raw);
-    const signer = await getSigner(input.agentId);
-    if (isSignerFailure(signer)) {
-        return fail(signer.error.code, signer.error.message, false, "send_payment");
-    }
-    const walletAddress = signer.address;
-    const policy = evaluateActionPolicy({
-        actionType: "send_payment",
-        amount: input.amount,
-        amountUnit: "PHRS",
-        recipient: input.toAddress,
-        recipientVerified: false,
-        chainId: CHAIN_ID,
-        environment: PHAROS_ENVIRONMENT,
-        isMainnet: false,
-        signerAvailable: true,
-        requiresSigner: true,
-    });
-    if (policy.decision === "BLOCK") {
-        return fail("POLICY_BLOCKED", policy.reasons.join(" ") || "Payment blocked by SafeHands policy.", false, "send_payment");
-    }
-    if (Number(input.amount) > Number(MAX_TX_AMOUNT_PHRS)) {
-        return fail("TX_LIMIT_EXCEEDED", `Payment amount exceeds configured testnet limit (${MAX_TX_AMOUNT_PHRS} PHRS).`, false, "send_payment");
-    }
-    const amountUsd = estimateUsd(input.amount, "PHRS");
-    const dailyCheck = checkDailyLimit(walletAddress, amountUsd);
-    if (!dailyCheck.allowed) {
-        return fail("DAILY_SPEND_LIMIT_EXCEEDED", `Daily spend limit reached. Spent $${dailyCheck.currentUsd.toFixed(2)} of $${dailyCheck.limitUsd.toFixed(2)} USD today. Remaining: $${dailyCheck.remainingUsd.toFixed(2)}. Resets at UTC midnight.`, false, "send_payment");
-    }
-    const warnings = [];
-    const validation = { addressValid: false, balanceSufficient: false, warnings };
-    if (!isAddress(input.toAddress)) {
-        return fail("INVALID_WALLET_ADDRESS", "Invalid recipient address", false, "send_payment");
-    }
-    validation.addressValid = true;
-    if (input.toAddress === "0x0000000000000000000000000000000000000000") {
-        return fail("ZERO_ADDRESS_BLOCKED", "Cannot send to zero address", false, "send_payment");
-    }
-    if (input.toAddress.toLowerCase() === walletAddress.toLowerCase()) {
-        warnings.push("Sending to own address");
-    }
-    const amountWei = parseEther(input.amount);
-    const balance = await publicClient.getBalance({ address: walletAddress });
-    const gasEstimate = parseEther("0.01");
-    if (balance < amountWei + gasEstimate) {
-        return fail("INSUFFICIENT_TESTNET_BALANCE", `Insufficient balance: have ${formatEther(balance)} PHRS, need ${input.amount} + gas`, false, "send_payment");
-    }
-    validation.balanceSufficient = true;
-    const usagePct = Number((amountWei * 100n) / balance);
-    if (usagePct > MAX_BALANCE_USAGE_PCT) {
-        warnings.push(`Using ${usagePct}% of wallet balance — high exposure`);
-    }
-    const risk = await assessRisk({
-        action: "transfer",
-        amount: input.amount,
-        toAddress: input.toAddress,
-        walletAddress,
-    });
-    if (risk.riskScore > RISK_BLOCK_THRESHOLD) {
-        return fail("POLICY_BLOCKED", `Payment blocked — risk score ${risk.riskScore}/100: ${risk.suggestion}`, false, "send_payment");
-    }
-    try {
-        const wallet = createPharosWalletClientFromAccount(signer.account);
-        const txHash = await wallet.sendTransaction({
-            to: input.toAddress,
-            value: amountWei,
-        });
-        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
-        if (receipt.status !== "success") {
-            return fail("TX_REVERTED", "send_payment transaction was mined but reverted on-chain.", false, "send_payment");
-        }
-        recordSpend(walletAddress, amountUsd);
-        return ok({
-            txHash,
-            explorerUrl: getExplorerUrl(txHash),
-            amountSent: input.amount,
-            signerMode: signer.mode,
-            walletAddress,
-            gasUsed: receipt.gasUsed.toString(),
-            validation,
-            policy,
-            riskAssessment: {
-                riskScore: risk.riskScore,
-                wasBlocked: false,
-            },
-            source: "send_payment",
-        });
-    }
-    catch (err) {
-        return classifyExternalError("pharos_rpc", err);
-    }
-}
+// ─── Tool: send_payment ────────────────────────────────────────────────
+import { z } from "zod";
+import { publicClient, createPharosWalletClientFromAccount, getExplorerUrl } from "../lib/pharosClient.js";
+import { isAddress, parseEther, formatEther } from "viem";
+import { assessRisk } from "../lib/riskEngine.js";
+import { fail, ok, classifyExternalError } from "../lib/toolResponse.js";
+import { MAX_BALANCE_USAGE_PCT, RISK_BLOCK_THRESHOLD, MAX_TX_AMOUNT_PHRS, CHAIN_ID, PHAROS_ENVIRONMENT } from "../lib/constants.js";
+import { getSigner, isSignerFailure } from "../lib/signer/index.js";
+import { evaluateActionPolicy } from "../lib/policy/actionPolicyEngine.js";
+import { checkDailyLimit, recordSpend, estimateUsd } from "../lib/spendAccumulator.js";
+export const sendPaymentSchema = z.object({
+    toAddress: z.string(),
+    amount: z.string(),
+    memo: z.string().optional(),
+    agentId: z.string().optional().describe("Managed testnet wallet agentId when WALLET_MODE=managed-testnet"),
+});
+export const sendPaymentTool = {
+    name: "send_payment",
+    description: "Send native PHRS with pre-flight validation. Checks address validity, balance sufficiency, and warns on high exposure.",
+    inputSchema: sendPaymentSchema,
+};
+export async function handleSendPayment(raw) {
+    if (process.env.WRITE_TOOLS_ENABLED !== "true") {
+        return fail("WRITE_TOOLS_DISABLED", "send_payment is disabled by default. Set WRITE_TOOLS_ENABLED=true only for trusted testnet execution.", false, "send_payment");
+    }
+    const input = sendPaymentSchema.parse(raw);
+    const signer = await getSigner(input.agentId);
+    if (isSignerFailure(signer)) {
+        return fail(signer.error.code, signer.error.message, false, "send_payment");
+    }
+    const walletAddress = signer.address;
+    const policy = evaluateActionPolicy({
+        actionType: "send_payment",
+        amount: input.amount,
+        amountUnit: "PHRS",
+        recipient: input.toAddress,
+        recipientVerified: false,
+        chainId: CHAIN_ID,
+        environment: PHAROS_ENVIRONMENT,
+        isMainnet: false,
+        signerAvailable: true,
+        requiresSigner: true,
+    });
+    if (policy.decision === "BLOCK") {
+        return fail("POLICY_BLOCKED", policy.reasons.join(" ") || "Payment blocked by SafeHands policy.", false, "send_payment");
+    }
+    if (Number(input.amount) > Number(MAX_TX_AMOUNT_PHRS)) {
+        return fail("TX_LIMIT_EXCEEDED", `Payment amount exceeds configured testnet limit (${MAX_TX_AMOUNT_PHRS} PHRS).`, false, "send_payment");
+    }
+    const amountUsd = estimateUsd(input.amount, "PHRS");
+    const dailyCheck = checkDailyLimit(walletAddress, amountUsd);
+    if (!dailyCheck.allowed) {
+        return fail("DAILY_SPEND_LIMIT_EXCEEDED", `Daily spend limit reached. Spent $${dailyCheck.currentUsd.toFixed(2)} of $${dailyCheck.limitUsd.toFixed(2)} USD today. Remaining: $${dailyCheck.remainingUsd.toFixed(2)}. Resets at UTC midnight.`, false, "send_payment");
+    }
+    const warnings = [];
+    const validation = { addressValid: false, balanceSufficient: false, warnings };
+    if (!isAddress(input.toAddress)) {
+        return fail("INVALID_WALLET_ADDRESS", "Invalid recipient address", false, "send_payment");
+    }
+    validation.addressValid = true;
+    if (input.toAddress === "0x0000000000000000000000000000000000000000") {
+        return fail("ZERO_ADDRESS_BLOCKED", "Cannot send to zero address", false, "send_payment");
+    }
+    if (input.toAddress.toLowerCase() === walletAddress.toLowerCase()) {
+        warnings.push("Sending to own address");
+    }
+    const amountWei = parseEther(input.amount);
+    const balance = await publicClient.getBalance({ address: walletAddress });
+    const gasEstimate = parseEther("0.01");
+    if (balance < amountWei + gasEstimate) {
+        return fail("INSUFFICIENT_TESTNET_BALANCE", `Insufficient balance: have ${formatEther(balance)} PHRS, need ${input.amount} + gas`, false, "send_payment");
+    }
+    validation.balanceSufficient = true;
+    const usagePct = Number((amountWei * 100n) / balance);
+    if (usagePct > MAX_BALANCE_USAGE_PCT) {
+        warnings.push(`Using ${usagePct}% of wallet balance — high exposure`);
+    }
+    const risk = await assessRisk({
+        action: "transfer",
+        amount: input.amount,
+        toAddress: input.toAddress,
+        walletAddress,
+    });
+    if (risk.riskScore > RISK_BLOCK_THRESHOLD) {
+        return fail("POLICY_BLOCKED", `Payment blocked — risk score ${risk.riskScore}/100: ${risk.suggestion}`, false, "send_payment");
+    }
+    try {
+        const wallet = createPharosWalletClientFromAccount(signer.account);
+        const txHash = await wallet.sendTransaction({
+            to: input.toAddress,
+            value: amountWei,
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+        if (receipt.status !== "success") {
+            return fail("TX_REVERTED", "send_payment transaction was mined but reverted on-chain.", false, "send_payment");
+        }
+        recordSpend(walletAddress, amountUsd);
+        return ok({
+            txHash,
+            explorerUrl: getExplorerUrl(txHash),
+            amountSent: input.amount,
+            signerMode: signer.mode,
+            walletAddress,
+            gasUsed: receipt.gasUsed.toString(),
+            validation,
+            policy,
+            riskAssessment: {
+                riskScore: risk.riskScore,
+                wasBlocked: false,
+            },
+            source: "send_payment",
+        });
+    }
+    catch (err) {
+        return classifyExternalError("pharos_rpc", err);
+    }
+}
 //# sourceMappingURL=sendPayment.js.map

package/dist/tools/simulateTransaction.d.ts

@@ -1,61 +1,61 @@
-import { z } from "zod";
-export declare const simulateTransactionSchema: z.ZodObject<{
-    action: z.ZodEnum<["swap", "transfer"]>;
-    tokenIn: z.ZodOptional<z.ZodString>;
-    tokenOut: z.ZodOptional<z.ZodString>;
-    amount: z.ZodString;
-    toAddress: z.ZodOptional<z.ZodString>;
-    walletAddress: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    amount: string;
-    walletAddress: string;
-    action: "transfer" | "swap";
-    tokenIn?: string | undefined;
-    tokenOut?: string | undefined;
-    toAddress?: string | undefined;
-}, {
-    amount: string;
-    walletAddress: string;
-    action: "transfer" | "swap";
-    tokenIn?: string | undefined;
-    tokenOut?: string | undefined;
-    toAddress?: string | undefined;
-}>;
-export type SimulateTransactionInput = z.infer<typeof simulateTransactionSchema>;
-export declare const simulateTransactionTool: {
-    name: string;
-    description: string;
-    inputSchema: z.ZodObject<{
-        action: z.ZodEnum<["swap", "transfer"]>;
-        tokenIn: z.ZodOptional<z.ZodString>;
-        tokenOut: z.ZodOptional<z.ZodString>;
-        amount: z.ZodString;
-        toAddress: z.ZodOptional<z.ZodString>;
-        walletAddress: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        amount: string;
-        walletAddress: string;
-        action: "transfer" | "swap";
-        tokenIn?: string | undefined;
-        tokenOut?: string | undefined;
-        toAddress?: string | undefined;
-    }, {
-        amount: string;
-        walletAddress: string;
-        action: "transfer" | "swap";
-        tokenIn?: string | undefined;
-        tokenOut?: string | undefined;
-        toAddress?: string | undefined;
-    }>;
-};
-export declare function handleSimulateTransaction(input: SimulateTransactionInput): Promise<import("../lib/toolResponse.js").ToolFailure | import("../lib/toolResponse.js").ToolSuccess<{
-    wouldSucceed: boolean;
-    expectedOutput: string;
-    gasEstimate: string;
-    balanceChanges: {
-        token: string;
-        delta: string;
-    }[];
-    warnings: string[];
-}>>;
+import { z } from "zod";
+export declare const simulateTransactionSchema: z.ZodObject<{
+    action: z.ZodEnum<["swap", "transfer"]>;
+    tokenIn: z.ZodOptional<z.ZodString>;
+    tokenOut: z.ZodOptional<z.ZodString>;
+    amount: z.ZodString;
+    toAddress: z.ZodOptional<z.ZodString>;
+    walletAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    walletAddress: string;
+    action: "transfer" | "swap";
+    tokenIn?: string | undefined;
+    tokenOut?: string | undefined;
+    toAddress?: string | undefined;
+}, {
+    amount: string;
+    walletAddress: string;
+    action: "transfer" | "swap";
+    tokenIn?: string | undefined;
+    tokenOut?: string | undefined;
+    toAddress?: string | undefined;
+}>;
+export type SimulateTransactionInput = z.infer<typeof simulateTransactionSchema>;
+export declare const simulateTransactionTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        action: z.ZodEnum<["swap", "transfer"]>;
+        tokenIn: z.ZodOptional<z.ZodString>;
+        tokenOut: z.ZodOptional<z.ZodString>;
+        amount: z.ZodString;
+        toAddress: z.ZodOptional<z.ZodString>;
+        walletAddress: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        amount: string;
+        walletAddress: string;
+        action: "transfer" | "swap";
+        tokenIn?: string | undefined;
+        tokenOut?: string | undefined;
+        toAddress?: string | undefined;
+    }, {
+        amount: string;
+        walletAddress: string;
+        action: "transfer" | "swap";
+        tokenIn?: string | undefined;
+        tokenOut?: string | undefined;
+        toAddress?: string | undefined;
+    }>;
+};
+export declare function handleSimulateTransaction(input: SimulateTransactionInput): Promise<import("../lib/toolResponse.js").ToolFailure | import("../lib/toolResponse.js").ToolSuccess<{
+    wouldSucceed: boolean;
+    expectedOutput: string;
+    gasEstimate: string;
+    balanceChanges: {
+        token: string;
+        delta: string;
+    }[];
+    warnings: string[];
+}>>;
 //# sourceMappingURL=simulateTransaction.d.ts.map

package/dist/tools/simulateTransaction.js

@@ -1,84 +1,84 @@
-// ─── Tool: simulate_transaction ────────────────────────────────────────
-import { z } from "zod";
-import { publicClient } from "../lib/pharosClient.js";
-import { getDodoRoute } from "../lib/dodoApi.js";
-import { parseEther, formatEther } from "viem";
-import { ok, fail } from "../lib/toolResponse.js";
-export const simulateTransactionSchema = z.object({
-    action: z.enum(["swap", "transfer"]),
-    tokenIn: z.string().optional(),
-    tokenOut: z.string().optional(),
-    amount: z.string(),
-    toAddress: z.string().optional(),
-    walletAddress: z.string(),
-});
-export const simulateTransactionTool = {
-    name: "simulate_transaction",
-    description: "Dry run a swap or transfer via eth_call — no gas spent. Returns expected output, gas estimate, and revert reasons.",
-    inputSchema: simulateTransactionSchema,
-};
-export async function handleSimulateTransaction(input) {
-    const warnings = [];
-    const balanceChanges = [];
-    try {
-        if (input.action === "swap") {
-            if (!input.tokenIn || !input.tokenOut) {
-                return fail("INVALID_INPUT", "tokenIn and tokenOut required for swap simulation", false, "simulate_transaction");
-            }
-            const quote = await getDodoRoute({
-                fromToken: input.tokenIn,
-                toToken: input.tokenOut,
-                amountHuman: input.amount,
-                walletAddress: input.walletAddress,
-            });
-            if (!quote.routeAvailable) {
-                return fail("NO_ROUTE_AVAILABLE", "No swap route available", true, "simulate_transaction");
-            }
-            // Simulate via eth_call
-            try {
-                await publicClient.call({
-                    to: quote.to,
-                    data: quote.calldata,
-                    value: BigInt(quote.value),
-                    account: input.walletAddress,
-                });
-            }
-            catch (err) {
-                const msg = err.message;
-                if (msg.includes("revert")) {
-                    return fail("SIMULATION_REVERTED", msg, false, "simulate_transaction");
-                }
-                warnings.push(`Simulation warning: ${msg}`);
-            }
-            balanceChanges.push({ token: input.tokenIn, delta: `-${input.amount}` });
-            balanceChanges.push({ token: input.tokenOut, delta: `+${quote.amountOut}` });
-            return ok({ wouldSucceed: true, expectedOutput: quote.amountOut, gasEstimate: quote.gasLimit, balanceChanges, warnings });
-        }
-        // Transfer simulation
-        if (!input.toAddress) {
-            return fail("INVALID_INPUT", "toAddress required for transfer simulation", false, "simulate_transaction");
-        }
-        const amountWei = parseEther(input.amount);
-        const balance = await publicClient.getBalance({ address: input.walletAddress });
-        if (balance < amountWei) {
-            return fail("INSUFFICIENT_TESTNET_BALANCE", `Insufficient balance: have ${formatEther(balance)}, need ${input.amount}`, false, "simulate_transaction");
-        }
-        const gasEstimate = await publicClient.estimateGas({
-            to: input.toAddress,
-            value: amountWei,
-            account: input.walletAddress,
-        });
-        balanceChanges.push({ token: "PHRS", delta: `-${input.amount}` });
-        return ok({
-            wouldSucceed: true,
-            expectedOutput: input.amount,
-            gasEstimate: gasEstimate.toString(),
-            balanceChanges,
-            warnings,
-        });
-    }
-    catch (err) {
-        return fail("SIMULATION_FAILED", err.message, true, "simulate_transaction");
-    }
-}
+// ─── Tool: simulate_transaction ────────────────────────────────────────
+import { z } from "zod";
+import { publicClient } from "../lib/pharosClient.js";
+import { getDodoRoute } from "../lib/dodoApi.js";
+import { parseEther, formatEther } from "viem";
+import { ok, fail } from "../lib/toolResponse.js";
+export const simulateTransactionSchema = z.object({
+    action: z.enum(["swap", "transfer"]),
+    tokenIn: z.string().optional(),
+    tokenOut: z.string().optional(),
+    amount: z.string(),
+    toAddress: z.string().optional(),
+    walletAddress: z.string(),
+});
+export const simulateTransactionTool = {
+    name: "simulate_transaction",
+    description: "Dry run a swap or transfer via eth_call — no gas spent. Returns expected output, gas estimate, and revert reasons.",
+    inputSchema: simulateTransactionSchema,
+};
+export async function handleSimulateTransaction(input) {
+    const warnings = [];
+    const balanceChanges = [];
+    try {
+        if (input.action === "swap") {
+            if (!input.tokenIn || !input.tokenOut) {
+                return fail("INVALID_INPUT", "tokenIn and tokenOut required for swap simulation", false, "simulate_transaction");
+            }
+            const quote = await getDodoRoute({
+                fromToken: input.tokenIn,
+                toToken: input.tokenOut,
+                amountHuman: input.amount,
+                walletAddress: input.walletAddress,
+            });
+            if (!quote.routeAvailable) {
+                return fail("NO_ROUTE_AVAILABLE", "No swap route available", true, "simulate_transaction");
+            }
+            // Simulate via eth_call
+            try {
+                await publicClient.call({
+                    to: quote.to,
+                    data: quote.calldata,
+                    value: BigInt(quote.value),
+                    account: input.walletAddress,
+                });
+            }
+            catch (err) {
+                const msg = err.message;
+                if (msg.includes("revert")) {
+                    return fail("SIMULATION_REVERTED", msg, false, "simulate_transaction");
+                }
+                warnings.push(`Simulation warning: ${msg}`);
+            }
+            balanceChanges.push({ token: input.tokenIn, delta: `-${input.amount}` });
+            balanceChanges.push({ token: input.tokenOut, delta: `+${quote.amountOut}` });
+            return ok({ wouldSucceed: true, expectedOutput: quote.amountOut, gasEstimate: quote.gasLimit, balanceChanges, warnings });
+        }
+        // Transfer simulation
+        if (!input.toAddress) {
+            return fail("INVALID_INPUT", "toAddress required for transfer simulation", false, "simulate_transaction");
+        }
+        const amountWei = parseEther(input.amount);
+        const balance = await publicClient.getBalance({ address: input.walletAddress });
+        if (balance < amountWei) {
+            return fail("INSUFFICIENT_TESTNET_BALANCE", `Insufficient balance: have ${formatEther(balance)}, need ${input.amount}`, false, "simulate_transaction");
+        }
+        const gasEstimate = await publicClient.estimateGas({
+            to: input.toAddress,
+            value: amountWei,
+            account: input.walletAddress,
+        });
+        balanceChanges.push({ token: "PHRS", delta: `-${input.amount}` });
+        return ok({
+            wouldSucceed: true,
+            expectedOutput: input.amount,
+            gasEstimate: gasEstimate.toString(),
+            balanceChanges,
+            warnings,
+        });
+    }
+    catch (err) {
+        return fail("SIMULATION_FAILED", err.message, true, "simulate_transaction");
+    }
+}
 //# sourceMappingURL=simulateTransaction.js.map

package/dist/tools/tokenRegistryStatus.d.ts

@@ -1,27 +1,27 @@
-import { z } from "zod";
-import { type ToolResponse } from "../lib/toolResponse.js";
-export declare const tokenRegistryStatusSchema: z.ZodObject<{
-    token: z.ZodOptional<z.ZodString>;
-    tokenAddress: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    token?: string | undefined;
-    tokenAddress?: string | undefined;
-}, {
-    token?: string | undefined;
-    tokenAddress?: string | undefined;
-}>;
-export type TokenRegistryStatusInput = z.input<typeof tokenRegistryStatusSchema>;
-export type TokenRegistryStatusValue = "CANONICAL_TESTNET_TOKEN" | "SKILL_ENGINE_CANONICAL_TOKEN" | "ALTERNATE_SOURCE_TOKEN" | "CUSTOM_NON_REGISTRY" | "UNKNOWN" | "INVALID_ADDRESS";
-export declare function classifyTokenRegistryStatus(token: string): {
-    input: string;
-    normalizedAddress: any;
-    symbol: any;
-    status: TokenRegistryStatusValue;
-    verificationStatus: any;
-    docsSource: any;
-    chainId: number;
-    environment: string;
-    isMainnet: boolean;
-};
-export declare function handleTokenRegistryStatus(raw: TokenRegistryStatusInput): Promise<ToolResponse<unknown>>;
+import { z } from "zod";
+import { type ToolResponse } from "../lib/toolResponse.js";
+export declare const tokenRegistryStatusSchema: z.ZodObject<{
+    token: z.ZodOptional<z.ZodString>;
+    tokenAddress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    token?: string | undefined;
+    tokenAddress?: string | undefined;
+}, {
+    token?: string | undefined;
+    tokenAddress?: string | undefined;
+}>;
+export type TokenRegistryStatusInput = z.input<typeof tokenRegistryStatusSchema>;
+export type TokenRegistryStatusValue = "CANONICAL_TESTNET_TOKEN" | "SKILL_ENGINE_CANONICAL_TOKEN" | "ALTERNATE_SOURCE_TOKEN" | "CUSTOM_NON_REGISTRY" | "UNKNOWN" | "INVALID_ADDRESS";
+export declare function classifyTokenRegistryStatus(token: string): {
+    input: string;
+    normalizedAddress: any;
+    symbol: any;
+    status: TokenRegistryStatusValue;
+    verificationStatus: any;
+    docsSource: any;
+    chainId: number;
+    environment: string;
+    isMainnet: boolean;
+};
+export declare function handleTokenRegistryStatus(raw: TokenRegistryStatusInput): Promise<ToolResponse<unknown>>;
 //# sourceMappingURL=tokenRegistryStatus.d.ts.map