@dexterai/opendexter-plugin 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Dexter-DAO/dexter-x402-sdk/main/assets/dexter-wordmark.svg" alt="Dexter" width="360">
+</p>
+
+<h1 align="center">@dexterai/opendexter-plugin</h1>
+
+<p align="center">
+  <strong>OpenDexter plugin for OpenClaw — search, price-check, and pay for x402 APIs with automatic USDC settlement.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@dexterai/opendexter-plugin"><img src="https://img.shields.io/npm/v/@dexterai/opendexter-plugin.svg" alt="npm"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E=18-brightgreen.svg" alt="Node"></a>
+  <a href="https://clawhub.ai/skills/opendexter"><img src="https://img.shields.io/badge/ClawHub-opendexter-blue" alt="ClawHub"></a>
+  <a href="https://dexter.cash/opendexter"><img src="https://img.shields.io/badge/Marketplace-OpenDexter-success" alt="Marketplace"></a>
+</p>
+
+---
+
+## What It Does
+
+Gives any OpenClaw agent access to the x402 API marketplace. The agent can discover paid APIs, preview pricing, and call endpoints with automatic USDC payment — no API keys or subscriptions needed for the endpoints themselves.
+
+| Tool | Purpose |
+|------|---------|
+| `x402_search` | Search the OpenDexter marketplace for paid APIs |
+| `x402_check` | Probe an endpoint for pricing without paying |
+| `x402_fetch` | Call any x402 API with automatic payment |
+| `x402_pay` | Alias for `x402_fetch` |
+| `x402_wallet` | Show wallet configuration and status |
+
+Payments work across **Solana, Base, Polygon, Arbitrum, Optimism, and Avalanche**. The plugin auto-selects the best-funded chain.
+
+---
+
+## Install
+
+### From ClawHub
+
+```bash
+openclaw plugins install @dexterai/opendexter-plugin
+```
+
+### From npm
+
+```bash
+npm install @dexterai/opendexter-plugin
+```
+
+---
+
+## Configuration
+
+Set wallet keys in the OpenClaw plugin config or as environment variables:
+
+| Config Key | Env Var | Description |
+|-----------|---------|-------------|
+| `svmPrivateKey` | `SVM_PRIVATE_KEY` | Solana wallet (base58) |
+| `evmPrivateKey` | `EVM_PRIVATE_KEY` | EVM wallet (hex, 0x...) |
+| `defaultNetwork` | `DEFAULT_NETWORK` | Preferred chain (default: auto) |
+| `maxPaymentUSDC` | `MAX_PAYMENT_USDC` | Per-call spending limit (default: $0.50) |
+| `facilitatorUrl` | `FACILITATOR_URL` | Settlement processor (default: https://x402.dexter.cash) |
+| `marketplaceUrl` | `MARKETPLACE_URL` | Marketplace API endpoint |
+
+At minimum, configure one wallet key (Solana or EVM) and fund it with USDC.
+
+---
+
+## How It Works
+
+```
+User: "Find me a sentiment analysis API"
+  → x402_search("sentiment analysis")
+  → Shows results with prices and quality scores
+
+User: "How much does that one cost?"
+  → x402_check(url)
+  → Shows per-chain pricing
+
+User: "Call it"
+  → x402_fetch(url, params)
+  → Signs USDC payment, calls endpoint, returns data + receipt
+```
+
+Settlement goes through the [Dexter facilitator](https://x402.dexter.cash) — zero fees, zero gas for the caller.
+
+---
+
+## Pinata Agent Template
+
+This plugin powers the [OpenDexter Agent](https://agents.pinata.cloud) template for Pinata. Deploy a fully configured x402 agent in one click.
+
+---
+
+## Built By
+
+[Dexter Intelligence](https://dexter.cash) — the payment, discovery, and monetization layer for the agent economy.

package/index.ts

@@ -0,0 +1,649 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { Type } from "@sinclair/typebox";
+import { wrapFetch, type WrapFetchOptions } from "@dexterai/x402/client";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+type PluginConfig = {
+  svmPrivateKey?: string;
+  evmPrivateKey?: string;
+  defaultNetwork?: string;
+  maxPaymentUSDC?: string;
+  facilitatorUrl?: string;
+  marketplaceUrl?: string;
+};
+
+type MarketplaceResource = {
+  name: string;
+  url: string;
+  method: string;
+  price: string;
+  network: string | null;
+  description: string;
+  category: string;
+  qualityScore: number | null;
+  verified: boolean;
+  totalCalls: number;
+  totalVolume: string | null;
+  seller: string | null;
+  sellerReputation: number | null;
+};
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const DEFAULT_FACILITATOR_URL = "https://x402.dexter.cash";
+const DEFAULT_MARKETPLACE_URL =
+  "https://x402.dexter.cash/api/facilitator/marketplace/resources";
+
+const NETWORK_TO_CAIP2: Record<string, string> = {
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  base: "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  polygon: "eip155:137",
+  arbitrum: "eip155:42161",
+  optimism: "eip155:10",
+  avalanche: "eip155:43114",
+};
+
+// =============================================================================
+// Marketplace Search
+// =============================================================================
+
+async function searchMarketplace(
+  query?: string,
+  options?: {
+    network?: string;
+    verified?: boolean;
+    category?: string;
+    maxPriceUsdc?: number;
+    sort?: string;
+    limit?: number;
+    marketplaceUrl?: string;
+  }
+): Promise<{ resources: MarketplaceResource[]; total: number }> {
+  const baseUrl = options?.marketplaceUrl || DEFAULT_MARKETPLACE_URL;
+  const params = new URLSearchParams();
+
+  if (query) params.set("search", query);
+  if (options?.network) params.set("network", options.network);
+  if (options?.verified) params.set("verified", "true");
+  if (options?.category) params.set("category", options.category);
+  if (options?.maxPriceUsdc != null)
+    params.set("maxPrice", String(options.maxPriceUsdc));
+  params.set("sort", options?.sort || "marketplace");
+  params.set("order", "desc");
+  params.set("limit", String(Math.min(options?.limit || 20, 50)));
+
+  const response = await fetch(`${baseUrl}?${params}`, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(15_000),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Marketplace search failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  const data = (await response.json()) as {
+    ok?: boolean;
+    resources?: Array<Record<string, unknown>>;
+    total?: number;
+  };
+
+  const resources = (data.resources || []).map(
+    (r: Record<string, unknown>) => ({
+      name: (r.displayName as string) || (r.resourceUrl as string),
+      url: r.resourceUrl as string,
+      method: (r.method as string) || "GET",
+      price:
+        (r.priceLabel as string) ||
+        (r.priceUsdc != null ? `$${Number(r.priceUsdc).toFixed(2)}` : "free"),
+      network: (r.priceNetwork as string) || null,
+      description: (r.description as string) || "",
+      category: (r.category as string) || "uncategorized",
+      qualityScore: (r.qualityScore as number) ?? null,
+      verified: r.verificationStatus === "pass",
+      totalCalls: (r.totalSettlements as number) ?? 0,
+      totalVolume:
+        r.totalVolumeUsdc != null
+          ? `$${Number(r.totalVolumeUsdc).toLocaleString()}`
+          : null,
+      seller:
+        ((r.seller as Record<string, unknown>)?.displayName as string) || null,
+      sellerReputation: (r.reputationScore as number) ?? null,
+    })
+  );
+
+  return { resources, total: data.total || resources.length };
+}
+
+// =============================================================================
+// x402 Fetch Client
+// =============================================================================
+
+function buildX402Fetch(config: PluginConfig): typeof fetch | null {
+  if (!config.svmPrivateKey && !config.evmPrivateKey) return null;
+
+  const opts: WrapFetchOptions = { verbose: false };
+
+  if (config.svmPrivateKey) opts.walletPrivateKey = config.svmPrivateKey;
+  if (config.evmPrivateKey) opts.evmPrivateKey = config.evmPrivateKey;
+  if (config.facilitatorUrl) opts.facilitatorUrl = config.facilitatorUrl;
+  if (config.defaultNetwork) {
+    opts.preferredNetwork =
+      NETWORK_TO_CAIP2[config.defaultNetwork] || config.defaultNetwork;
+  }
+  if (config.maxPaymentUSDC) {
+    const [whole, fraction = ""] = config.maxPaymentUSDC.split(".");
+    opts.maxAmountAtomic = `${whole}${(fraction + "000000").slice(0, 6)}`;
+  }
+
+  return wrapFetch(globalThis.fetch, opts);
+}
+
+// =============================================================================
+// Plugin Entry
+// =============================================================================
+
+export default definePluginEntry({
+  id: "opendexter",
+  name: "OpenDexter",
+  description:
+    "x402 marketplace access for OpenClaw agents. Search, price-check, and pay for paid APIs with USDC across Solana, Base, Polygon, Arbitrum, Optimism, and Avalanche.",
+
+  register(api) {
+    const raw = (api.pluginConfig || {}) as PluginConfig;
+
+    // Merge plugin config with environment variable fallbacks.
+    // This lets Pinata secrets (env vars) feed the plugin when the
+    // plugin config UI isn't available.
+    const config: PluginConfig = {
+      svmPrivateKey: raw.svmPrivateKey || process.env.SVM_PRIVATE_KEY,
+      evmPrivateKey: raw.evmPrivateKey || process.env.EVM_PRIVATE_KEY,
+      defaultNetwork: raw.defaultNetwork || process.env.DEFAULT_NETWORK,
+      maxPaymentUSDC: raw.maxPaymentUSDC || process.env.MAX_PAYMENT_USDC || "0.50",
+      facilitatorUrl: raw.facilitatorUrl || process.env.FACILITATOR_URL,
+      marketplaceUrl: raw.marketplaceUrl || process.env.MARKETPLACE_URL,
+    };
+
+    let cachedFetch: typeof fetch | null | undefined;
+
+    const getClient = () => {
+      if (cachedFetch !== undefined) return cachedFetch;
+      cachedFetch = buildX402Fetch(config);
+      return cachedFetch;
+    };
+
+    // ----- x402_search -----
+    api.registerTool({
+      name: "x402_search",
+      description:
+        "Search the OpenDexter marketplace for paid APIs. Returns quality-ranked results with pricing, verification status, and seller reputation.",
+      parameters: Type.Object({
+        query: Type.Optional(
+          Type.String({
+            description:
+              'Search query (e.g. "token analytics", "sentiment", "image generation")',
+          })
+        ),
+        network: Type.Optional(
+          Type.String({
+            description:
+              "Filter by network: solana, base, polygon, arbitrum, optimism, avalanche",
+          })
+        ),
+        verified: Type.Optional(
+          Type.Boolean({ description: "Only return quality-verified endpoints" })
+        ),
+        category: Type.Optional(
+          Type.String({ description: "Filter by category" })
+        ),
+        maxPriceUsdc: Type.Optional(
+          Type.Number({ description: "Maximum price per call in USDC" })
+        ),
+        sort: Type.Optional(
+          Type.String({
+            description:
+              "Sort: marketplace (default), relevance, quality_score, settlements, volume, recent",
+          })
+        ),
+        limit: Type.Optional(
+          Type.Number({ description: "Max results (default 20, max 50)" })
+        ),
+      }),
+
+      async execute(_id, input) {
+        try {
+          const result = await searchMarketplace(input.query, {
+            network: input.network,
+            verified: input.verified,
+            category: input.category,
+            maxPriceUsdc: input.maxPriceUsdc,
+            sort: input.sort,
+            limit: Math.min(input.limit || 20, 50),
+            marketplaceUrl: config.marketplaceUrl,
+          });
+
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify(
+                  {
+                    success: true,
+                    total: result.total,
+                    showing: result.resources.length,
+                    resources: result.resources,
+                    source: "OpenDexter (https://dexter.cash)",
+                  },
+                  null,
+                  2
+                ),
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error:
+                    error instanceof Error ? error.message : String(error),
+                }),
+              },
+            ],
+          };
+        }
+      },
+    });
+
+    // ----- x402_check -----
+    api.registerTool({
+      name: "x402_check",
+      description:
+        "Probe an x402 endpoint to see its pricing per chain without paying. Use before x402_fetch to show the user what a call will cost.",
+      parameters: Type.Object({
+        url: Type.String({ description: "The URL to check" }),
+        method: Type.Optional(
+          Type.String({ description: "HTTP method to probe (default: GET)" })
+        ),
+      }),
+
+      async execute(_id, input) {
+        const url = input.url;
+        const method = (input.method || "GET").toUpperCase();
+
+        try {
+          const hasBody = ["POST", "PUT", "PATCH"].includes(method);
+          const res = await fetch(url, {
+            method,
+            ...(hasBody
+              ? { headers: { "Content-Type": "application/json" }, body: "{}" }
+              : {}),
+            signal: AbortSignal.timeout(15_000),
+          });
+
+          if (res.status === 401 || res.status === 403) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify({
+                    error: true,
+                    statusCode: res.status,
+                    authRequired: true,
+                    message:
+                      "Provider authentication required before x402 payment.",
+                  }),
+                },
+              ],
+            };
+          }
+
+          if (res.status !== 402) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify({
+                    requiresPayment: false,
+                    statusCode: res.status,
+                    free: res.ok,
+                  }),
+                },
+              ],
+            };
+          }
+
+          let body: Record<string, unknown> | null = null;
+          try {
+            body = (await res.json()) as Record<string, unknown>;
+          } catch {
+            // non-JSON 402 body
+          }
+
+          const accepts =
+            (body?.accepts as Array<Record<string, unknown>>) || [];
+          const paymentOptions = accepts.map((a) => {
+            const amount = Number(a.amount || a.maxAmountRequired || 0);
+            const decimals = Number(
+              (a.extra as Record<string, unknown>)?.decimals ?? 6
+            );
+            return {
+              price: amount / Math.pow(10, decimals),
+              priceFormatted: `$${(amount / Math.pow(10, decimals)).toFixed(2)}`,
+              network: a.network,
+              scheme: a.scheme,
+              asset: a.asset,
+              payTo: a.payTo,
+            };
+          });
+
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify(
+                  {
+                    requiresPayment: true,
+                    statusCode: 402,
+                    x402Version: body?.x402Version ?? 2,
+                    paymentOptions,
+                    resource: body?.resource ?? null,
+                    schema: accepts[0]?.outputSchema ?? null,
+                  },
+                  null,
+                  2
+                ),
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  error: true,
+                  message:
+                    error instanceof Error ? error.message : String(error),
+                }),
+              },
+            ],
+          };
+        }
+      },
+    });
+
+    // ----- Shared fetch+pay execution -----
+    const executeFetch = async (input: Record<string, unknown>) => {
+      const url = input.url as string;
+      const method = ((input.method as string) || "GET").toUpperCase();
+
+      const fetchClient = getClient();
+      if (!fetchClient) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({
+                success: false,
+                error:
+                  "No wallet configured. Set svmPrivateKey or evmPrivateKey in the OpenDexter plugin config.",
+              }),
+            },
+          ],
+        };
+      }
+
+      try {
+        let requestUrl = url;
+        let body: string | undefined;
+        const requestHeaders: Record<string, string> = {
+          Accept: "application/json",
+          "User-Agent": "opendexter-plugin/1.0",
+          ...((input.headers as Record<string, string>) || {}),
+        };
+
+        if (
+          method === "GET" &&
+          input.params &&
+          typeof input.params === "object"
+        ) {
+          const urlObj = new URL(url);
+          for (const [key, value] of Object.entries(
+            input.params as Record<string, unknown>
+          )) {
+            if (value !== undefined && value !== null) {
+              urlObj.searchParams.set(key, String(value));
+            }
+          }
+          requestUrl = urlObj.toString();
+        } else if (input.params !== undefined && input.params !== null) {
+          body =
+            typeof input.params === "string"
+              ? input.params
+              : JSON.stringify(input.params);
+          if (!requestHeaders["Content-Type"]) {
+            requestHeaders["Content-Type"] = "application/json";
+          }
+        }
+
+        const response = await fetchClient(requestUrl, {
+          method,
+          headers: requestHeaders,
+          body,
+          signal: AbortSignal.timeout(30_000),
+        });
+
+        const contentType = response.headers.get("content-type") || "";
+        let data: unknown;
+        if (contentType.includes("application/json")) {
+          data = await response.json().catch(() => null);
+        } else if (contentType.startsWith("text/")) {
+          data = await response.text();
+        } else {
+          data = `[Binary: ${contentType}, ${response.headers.get("content-length") || "unknown"} bytes]`;
+        }
+
+        let paidUsdc: string | null = null;
+        const paymentHeader =
+          response.headers.get("PAYMENT-RESPONSE") ||
+          response.headers.get("x-payment-response");
+        if (paymentHeader) {
+          try {
+            const payment = JSON.parse(atob(paymentHeader));
+            const rawAmount =
+              payment.amount || payment.paidAmount || payment.value;
+            if (rawAmount) {
+              paidUsdc = (Number(rawAmount) / 1_000_000).toFixed(6);
+            }
+          } catch {
+            // ignore malformed receipt
+          }
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  success: response.ok,
+                  statusCode: response.status,
+                  data,
+                  ...(paidUsdc ? { paidUsdc: `$${paidUsdc}` } : {}),
+                  network: config.defaultNetwork || "auto",
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+
+        if (msg.includes("amount_exceeds_max")) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error: `Payment exceeds configured max of $${config.maxPaymentUSDC || "0.50"} USDC. Adjust maxPaymentUSDC in plugin config.`,
+                  blocked: true,
+                }),
+              },
+            ],
+          };
+        }
+
+        if (msg.includes("insufficient_balance")) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error: "Insufficient USDC balance.",
+                  help: "Fund the wallet with USDC on the appropriate network.",
+                }),
+              },
+            ],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({ success: false, error: msg }),
+            },
+          ],
+        };
+      }
+    };
+
+    const fetchParams = Type.Object({
+      url: Type.String({ description: "The x402 endpoint URL to call" }),
+      method: Type.Optional(
+        Type.String({ description: "HTTP method (default: GET)" })
+      ),
+      params: Type.Optional(
+        Type.Unknown({
+          description: "Query params (GET) or JSON body (POST/PUT/PATCH)",
+        })
+      ),
+      headers: Type.Optional(
+        Type.Unknown({ description: "Custom request headers" })
+      ),
+    });
+
+    // ----- x402_fetch -----
+    api.registerTool({
+      name: "x402_fetch",
+      description:
+        "Call any x402-protected API with automatic USDC payment. Returns the API response and payment receipt.",
+      parameters: fetchParams,
+      async execute(_id, input) {
+        return executeFetch(input);
+      },
+    });
+
+    // ----- x402_pay -----
+    api.registerTool({
+      name: "x402_pay",
+      description:
+        "Alias for x402_fetch. Call any x402 API with automatic payment.",
+      parameters: fetchParams,
+      async execute(_id, input) {
+        return executeFetch(input);
+      },
+    });
+
+    // ----- x402_wallet -----
+    api.registerTool({
+      name: "x402_wallet",
+      description:
+        "Show wallet configuration: active networks, spending limit, facilitator. Use when the user asks about their wallet setup.",
+      parameters: Type.Object({}),
+
+      async execute() {
+        if (!config.svmPrivateKey && !config.evmPrivateKey) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  configured: false,
+                  error: "No wallet configured.",
+                  help: "Set svmPrivateKey or evmPrivateKey in the OpenDexter plugin config.",
+                }),
+              },
+            ],
+          };
+        }
+
+        const wallets: Array<{
+          type: string;
+          networks: string[];
+          configured: boolean;
+        }> = [];
+
+        if (config.svmPrivateKey) {
+          wallets.push({
+            type: "solana",
+            networks: ["solana"],
+            configured: true,
+          });
+        }
+
+        if (config.evmPrivateKey) {
+          wallets.push({
+            type: "evm",
+            networks: ["base", "polygon", "arbitrum", "optimism", "avalanche"],
+            configured: true,
+          });
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify(
+                {
+                  configured: true,
+                  wallets,
+                  defaultNetwork:
+                    config.defaultNetwork || "auto",
+                  maxPaymentPerCall: `$${config.maxPaymentUSDC || "0.50"} USDC`,
+                  facilitator:
+                    config.facilitatorUrl || DEFAULT_FACILITATOR_URL,
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      },
+    });
+
+    api.logger.info("OpenDexter plugin registered");
+    api.logger.info(
+      `  Wallet: ${config.svmPrivateKey || config.evmPrivateKey ? "configured" : "not configured"}`
+    );
+    api.logger.info(
+      `  Marketplace: ${config.marketplaceUrl || DEFAULT_MARKETPLACE_URL}`
+    );
+  },
+});

package/openclaw.d.ts

@@ -0,0 +1,30 @@
+declare module "openclaw/plugin-sdk/plugin-entry" {
+  interface PluginToolDef {
+    name: string;
+    description: string;
+    parameters: unknown;
+    execute: (...args: any[]) => Promise<any>;
+  }
+
+  interface PluginApi {
+    pluginConfig: Record<string, unknown>;
+    logger: {
+      info: (msg: string) => void;
+      warn: (msg: string) => void;
+      error: (msg: string) => void;
+      debug: (msg: string) => void;
+    };
+    registerTool: (tool: PluginToolDef) => void;
+  }
+
+  interface PluginEntryOptions {
+    id: string;
+    name: string;
+    description: string;
+    kind?: string;
+    configSchema?: unknown;
+    register: (api: PluginApi) => void;
+  }
+
+  export function definePluginEntry(options: PluginEntryOptions): unknown;
+}

package/openclaw.plugin.json

@@ -0,0 +1,67 @@
+{
+  "id": "opendexter",
+  "name": "OpenDexter",
+  "description": "x402 marketplace access for OpenClaw agents. Search paid APIs, preview pricing, and auto-pay with USDC across Solana, Base, Polygon, Arbitrum, Optimism, and Avalanche.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": true,
+    "properties": {
+      "svmPrivateKey": {
+        "type": "string",
+        "description": "Solana wallet private key (base58) for USDC payments on Solana"
+      },
+      "evmPrivateKey": {
+        "type": "string",
+        "description": "EVM wallet private key (hex, with or without 0x) for USDC payments on Base, Polygon, Arbitrum, Optimism, Avalanche"
+      },
+      "defaultNetwork": {
+        "type": "string",
+        "enum": ["solana", "base", "polygon", "arbitrum", "optimism", "avalanche"],
+        "default": "solana",
+        "description": "Preferred payment network when an endpoint accepts multiple"
+      },
+      "maxPaymentUSDC": {
+        "type": "string",
+        "default": "0.50",
+        "description": "Maximum USDC to spend per API call (e.g. '0.50' = $0.50)"
+      },
+      "facilitatorUrl": {
+        "type": "string",
+        "default": "https://x402.dexter.cash",
+        "description": "x402 facilitator URL for payment settlement"
+      },
+      "marketplaceUrl": {
+        "type": "string",
+        "default": "https://x402.dexter.cash/api/facilitator/marketplace/resources",
+        "description": "OpenDexter marketplace API endpoint"
+      }
+    }
+  },
+  "uiHints": {
+    "svmPrivateKey": {
+      "label": "Solana Private Key",
+      "sensitive": true,
+      "help": "Base58-encoded Solana private key. Your agent uses this wallet to pay for x402 API calls on Solana."
+    },
+    "evmPrivateKey": {
+      "label": "EVM Private Key",
+      "sensitive": true,
+      "help": "Hex private key (0x...). Same key works on Base, Polygon, Arbitrum, Optimism, and Avalanche."
+    },
+    "maxPaymentUSDC": {
+      "label": "Max Payment Per Call (USDC)",
+      "help": "Safety limit. Rejects any single API call costing more than this amount."
+    },
+    "facilitatorUrl": {
+      "label": "Facilitator URL",
+      "advanced": true,
+      "help": "Override the x402 payment processor. Default: https://x402.dexter.cash"
+    },
+    "marketplaceUrl": {
+      "label": "Marketplace API URL",
+      "advanced": true,
+      "help": "Override the OpenDexter marketplace search endpoint."
+    }
+  },
+  "skills": ["skills"]
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@dexterai/opendexter-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "OpenDexter plugin for OpenClaw — search, price-check, and pay for any x402 API with automatic USDC settlement across Solana, Base, Polygon, Arbitrum, Optimism, and Avalanche.",
+  "keywords": [
+    "openclaw",
+    "opendexter",
+    "x402",
+    "dexter",
+    "solana",
+    "base",
+    "evm",
+    "payments",
+    "usdc",
+    "marketplace",
+    "ai-agents",
+    "micropayments"
+  ],
+  "author": "Dexter AI <dev@dexter.cash>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Dexter-DAO/opendexter-plugin"
+  },
+  "homepage": "https://dexter.cash/opendexter",
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.24-beta.2",
+      "minGatewayVersion": "2026.3.24-beta.2"
+    },
+    "build": {
+      "openclawVersion": "2026.4.5",
+      "pluginSdkVersion": "2026.4.5"
+    }
+  },
+  "dependencies": {
+    "@dexterai/x402": "^2.0.0",
+    "@sinclair/typebox": "^0.32.0"
+  },
+  "peerDependencies": {
+    "openclaw": "*"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "openclaw": "^2026.4.8"
+  }
+}

package/skills/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: opendexter
+description: "Use OpenDexter to search, price-check, and pay for any x402 API. Trigger whenever the user wants to find paid APIs, call an x402 endpoint, check pricing, see wallet info, or interact with the x402 marketplace."
+---
+
+# OpenDexter — x402 API Marketplace
+
+OpenDexter gives you access to the x402 API marketplace across Solana and EVM chains (Base, Polygon, Arbitrum, Optimism, Avalanche). Search, preview pricing, and call any endpoint with automatic USDC payment. No API keys or subscriptions needed for the endpoints — you just pay per call.
+
+## Tools
+
+### `x402_search` — Find APIs
+
+Search the OpenDexter marketplace. Results are ranked by a composite score (quality, usage, freshness, reputation, reliability).
+
+Each result includes: name, price (USDC), network, qualityScore (0-100), verified status, seller, and call count.
+
+Highlight verified endpoints (qualityScore 75+). Search is fuzzy — typos still find results.
+
+### `x402_check` — Preview Pricing
+
+Probe an endpoint for payment requirements without paying. Returns per-chain pricing options. Always use before `x402_fetch` so the user knows the cost upfront.
+
+### `x402_fetch` — Call and Pay
+
+Call any x402 endpoint with automatic payment from the configured wallet. The plugin checks USDC balances across all funded chains and picks the best option. Returns the API response data plus a payment receipt.
+
+If the wallet has no funds on any accepted chain, tell the user to fund their wallet.
+
+### `x402_pay` — Alias for `x402_fetch`
+
+Same tool, alternate name.
+
+### `x402_wallet` — Wallet Status
+
+Shows which wallets are configured (Solana, EVM), the per-call spending limit, and the active network. Use when the user asks about their wallet or setup.
+
+## Workflows
+
+### "Find me an API for X"
+1. `x402_search` with their query
+2. Present top results with prices and quality scores
+3. `x402_check` on their pick
+4. Show per-chain pricing
+5. `x402_fetch` to call it
+
+### "Call this URL"
+1. `x402_check` to show the price
+2. `x402_fetch` to call and pay
+
+### "What's my wallet setup?"
+1. `x402_wallet`
+
+## Quality Scores
+- 90-100: Excellent. Verified, reliable, well-documented.
+- 75-89: Good. Passed verification.
+- 50-74: Mediocre. May have issues.
+- Below 50: Untested or poor.
+
+## Tips
+- Most endpoints cost $0.01-$0.10 per call.
+- Use `verified: true` to filter to tested endpoints.
+- The plugin auto-selects the cheapest chain that the endpoint accepts and the wallet has funds on.
+- If no wallet is configured, tools return a config help message.

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": false,
+    "types": ["node"]
+  },
+  "include": ["index.ts", "openclaw.d.ts"]
+}