veriql-agentkit 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Veriql
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,66 @@
-# Temporary Holding Version
+# veriql-agentkit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Veriql checks for [Coinbase AgentKit](https://github.com/coinbase/agentkit) agents that move money.
+
+| Action | When the agent should call it | Cost |
+|---|---|---|
+| `check_payee` | Before sending funds to any address. OFAC SDN sanctions, the Drain Watch list of known drainer and scam addresses, and whether Tether or Circle has frozen the address (read from the issuer's own contract). EVM, Solana, Bitcoin, Tron. | $0.005 |
+| `check_signature` | Before signing anything. Decodes approvals, Permit and Permit2, EIP-7702 delegations, transfers and revokes, and checks whoever gains the power. Answers `block`, `warn` or `allow`. An undecodable payload is `block` and is not charged. | $0.005 |
+| `check_denylist` | A free, instant screen against OFAC SDN plus Drain Watch, cached for an hour. | free |
+
+Veriql is read-only. It never asks for a key, never signs and never moves funds.
+
+## Install
+
+```bash
+npm install veriql-agentkit
+```
+
+AgentKit 0.10 itself needs Node 22 or later.
+
+```ts
+import { AgentKit } from "@coinbase/agentkit";
+import { veriqlActionProvider } from "veriql-agentkit";
+
+const agentkit = await AgentKit.from({
+  walletProvider,
+  actionProviders: [veriqlActionProvider()],
+});
+```
+
+## Paying for calls
+
+There are two ways to pay. Pick one:
+
+- **x402, no account (the default).** The agent pays each call itself in USDC on Base or Solana, from the wallet AgentKit already holds. A payment option priced above `maxPaymentUsdc` (default `0.01`, env `VERIQL_MAX_PAYMENT_USDC`) is refused before anything is signed.
+- **An API key.** Pass `apiKey` or set `VERIQL_API_KEY`. Calls then spend prepaid credits and the agent never signs a payment. A free key with 250 credits is at <https://veriql.app/api/checkout?pack=free>.
+
+```ts
+veriqlActionProvider({ apiKey: process.env.VERIQL_API_KEY, maxPaymentUsdc: 0.01 });
+```
+
+## What the answers mean
+
+- `no_known_risk` or `allow` means nothing adverse was found when the check ran. It is not a guarantee.
+- `incomplete` means a check could not run. Treat the address as unverified, not as clean.
+- Any error comes back as `{"error": true, ...}` and tells the agent to treat the input as unverified. A failure is never reported as clean.
+
+## Tests
+
+```bash
+npm test   # builds with tsc, then runs node --test on the compiled output (Node 22+)
+```
+
+The tests run against `dist/`, not the TypeScript sources. AgentKit's `@CreateAction` decides whether an action receives the wallet by reading the parameter-type metadata that only `tsc` emits (`emitDecoratorMetadata`). A runner built on esbuild would silently register every action as walletless.
+
+## Contributing this upstream
+
+`src/veriql/` follows the layout of AgentKit's own `typescript/agentkit/src/action-providers/<name>/` folders: `schemas.ts`, `constants.ts`, `veriqlActionProvider.ts` and `index.ts`. To move it into the AgentKit repo:
+
+1. Import `ActionProvider`, `CreateAction` and the wallet providers relatively (`../actionProvider`, `../actionDecorator`, `../../wallet-providers`) instead of from `@coinbase/agentkit`.
+2. Drop the `.js` import suffixes.
+3. Add `export * from "./veriql";` to `action-providers/index.ts`.
+
+## Licence
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./veriql/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./veriql/index.js";

package/dist/veriql/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const VERIQL_BASE_URL = "https://veriql.app";
+/**
+ * Sent on every request so Veriql can tell which framework a call came
+ * through. Kept equal to package.json by a test.
+ */
+export declare const USER_AGENT = "veriql-agentkit/0.1.1";
+/**
+ * Veriql charges $0.005 per call. The default cap leaves room for a price
+ * change without letting a misconfigured endpoint charge an agent real money:
+ * any payment option above it is dropped before anything is signed.
+ */
+export declare const DEFAULT_MAX_PAYMENT_USDC = 0.01;
+/** USDC has 6 decimals on every network Veriql accepts (Base, Solana). */
+export declare const USDC_DECIMALS = 6;
+/**
+ * The free denylist changes once a day; an hour keeps an agent from
+ * re-downloading it on every lookup.
+ */
+export declare const DENYLIST_TTL_MS: number;

package/dist/veriql/constants.js

@@ -0,0 +1,19 @@
+export const VERIQL_BASE_URL = "https://veriql.app";
+/**
+ * Sent on every request so Veriql can tell which framework a call came
+ * through. Kept equal to package.json by a test.
+ */
+export const USER_AGENT = "veriql-agentkit/0.1.1";
+/**
+ * Veriql charges $0.005 per call. The default cap leaves room for a price
+ * change without letting a misconfigured endpoint charge an agent real money:
+ * any payment option above it is dropped before anything is signed.
+ */
+export const DEFAULT_MAX_PAYMENT_USDC = 0.01;
+/** USDC has 6 decimals on every network Veriql accepts (Base, Solana). */
+export const USDC_DECIMALS = 6;
+/**
+ * The free denylist changes once a day; an hour keeps an agent from
+ * re-downloading it on every lookup.
+ */
+export const DENYLIST_TTL_MS = 60 * 60 * 1000;

package/dist/veriql/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./veriqlActionProvider.js";
+export * from "./schemas.js";

package/dist/veriql/index.js

@@ -0,0 +1,2 @@
+export * from "./veriqlActionProvider.js";
+export * from "./schemas.js";

package/dist/veriql/schemas.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const CheckPayeeSchema: z.ZodObject<{
+    address: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    address: string;
+}, {
+    address: string;
+}>;
+export declare const CheckSignatureSchema: z.ZodObject<{
+    payload: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    payload: string;
+}, {
+    payload: string;
+}>;
+export declare const CheckDenylistSchema: z.ZodObject<{
+    address: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    address: string;
+}, {
+    address: string;
+}>;

package/dist/veriql/schemas.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export const CheckPayeeSchema = z
+    .object({
+    address: z
+        .string()
+        .min(1)
+        .describe("The address you are about to send money to: EVM (0x...), Solana, Bitcoin or Tron."),
+})
+    .strict()
+    .describe("Input for checking a payment recipient before sending funds");
+export const CheckSignatureSchema = z
+    .object({
+    payload: z
+        .string()
+        .min(1)
+        .describe("What you were asked to sign: raw transaction calldata (0x...), an EIP-712 typed-data JSON string, or a JSON-RPC signing request as a JSON string."),
+})
+    .strict()
+    .describe("Input for checking a signing request before signing it");
+export const CheckDenylistSchema = z
+    .object({
+    address: z
+        .string()
+        .min(1)
+        .describe("The address to look up: EVM (0x...), Solana, Bitcoin or Tron."),
+})
+    .strict()
+    .describe("Input for a free lookup against the Veriql denylist");

package/dist/veriql/veriqlActionProvider.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import { ActionProvider, WalletProvider } from "@coinbase/agentkit";
+import { CheckDenylistSchema, CheckPayeeSchema, CheckSignatureSchema } from "./schemas.js";
+export interface VeriqlActionProviderConfig {
+    /**
+     * A Veriql API key (`vq_live_...`). With one, calls spend prepaid credits
+     * and no payment is ever signed. Falls back to `VERIQL_API_KEY`.
+     */
+    apiKey?: string;
+    /**
+     * Without a key, calls are paid per request over x402 from the agent's own
+     * wallet. Any payment option above this many USDC is refused before
+     * signing. Falls back to `VERIQL_MAX_PAYMENT_USDC`, then 0.01.
+     */
+    maxPaymentUsdc?: number;
+    /** Override for testing against a non-production deployment. */
+    baseUrl?: string;
+}
+type Family = "evm" | "solana" | "tron" | "btc";
+/**
+ * Which denylist family an address belongs to, by shape alone. Tron is checked
+ * before Solana because a 34-character Tron address also passes a base58
+ * length check.
+ *
+ * @param address - The address to classify
+ * @returns The address family, or null if the shape is not recognised
+ */
+export declare function familyOf(address: string): Family | null;
+/**
+ * Converts a whole-USDC cap to atomic units without floating-point drift:
+ * `0.29 * 1e6` is `289999.99999999994`, which truncates to the wrong amount.
+ *
+ * @param usdc - The amount in whole USDC
+ * @returns The amount in atomic units (6 decimals)
+ */
+export declare function usdcToAtomic(usdc: number): bigint;
+/**
+ * Drops every payment option priced above `capAtomic`. x402 v2 carries the
+ * price as `amount`, v1 as `maxAmountRequired`; an option carrying neither is
+ * dropped too, because a price we cannot read is not one we can agree to.
+ *
+ * @param capAtomic - The highest acceptable price, in atomic USDC units
+ * @returns An x402 payment policy that filters the offered requirements
+ */
+export declare function priceCapPolicy(capAtomic: bigint): <T extends object>(_version: number, reqs: T[]) => T[];
+/**
+ * Veriql checks for agents that move money.
+ *
+ * - `check_payee` before sending funds: OFAC SDN, the Drain Watch scam list,
+ *   and whether Tether or Circle has frozen the address (read from the issuer's
+ *   own contract).
+ * - `check_signature` before signing: decodes approvals, Permit/Permit2,
+ *   EIP-7702 delegations, transfers and revokes, and checks who gains the power.
+ * - `check_denylist`: a free lookup against the same lists, no payment.
+ *
+ * Read-only: Veriql never asks for a key, never signs and never moves funds.
+ */
+export declare class VeriqlActionProvider extends ActionProvider<WalletProvider> {
+    private readonly apiKey?;
+    private readonly capAtomic;
+    private readonly baseUrl;
+    private denylist;
+    /**
+     * Creates a new VeriqlActionProvider.
+     *
+     * @param config - Optional API key, payment cap and base URL
+     */
+    constructor(config?: VeriqlActionProviderConfig);
+    /**
+     * Checks a payment recipient before funds are sent.
+     *
+     * @param walletProvider - The wallet that pays for the call over x402
+     * @param args - The recipient address
+     * @returns The verdict as a JSON string, or an error telling the agent to treat it as unverified
+     */
+    checkPayee(walletProvider: WalletProvider, args: z.infer<typeof CheckPayeeSchema>): Promise<string>;
+    /**
+     * Checks a signing request before it is signed.
+     *
+     * @param walletProvider - The wallet that pays for the call over x402
+     * @param args - The payload the agent was asked to sign
+     * @returns The decision as a JSON string, or an error telling the agent to treat it as unverified
+     */
+    checkSignature(walletProvider: WalletProvider, args: z.infer<typeof CheckSignatureSchema>): Promise<string>;
+    /**
+     * Looks an address up in the free Veriql denylist.
+     *
+     * @param args - The address to look up
+     * @returns Whether the address is listed, as a JSON string
+     */
+    checkDenylist(args: z.infer<typeof CheckDenylistSchema>): Promise<string>;
+    /**
+     * Veriql is a read-only API, so every network is supported.
+     *
+     * @returns Always true
+     */
+    supportsNetwork: () => boolean;
+    /**
+     * Loads one family of the denylist, cached for an hour. A failed refresh
+     * keeps the previous copy rather than reading as an empty list.
+     *
+     * @param family - The address family to load
+     * @returns The listed addresses, EVM ones lowercased
+     */
+    private loadDenylist;
+    /**
+     * Calls a paid Veriql endpoint with the API key, or over x402 from the wallet.
+     *
+     * @param walletProvider - The wallet that pays when no API key is set
+     * @param url - The endpoint URL
+     * @param init - The request options
+     * @returns The response body as a JSON string, or an error object
+     */
+    private call;
+    /**
+     * Creates an x402 client for the wallet, capped at the configured price.
+     *
+     * @param walletProvider - The wallet that signs the payment
+     * @returns The client, or null if the wallet cannot pay over x402
+     */
+    private createX402Client;
+}
+/**
+ * Creates a VeriqlActionProvider.
+ *
+ * @param config - Optional API key, payment cap and base URL
+ * @returns A new VeriqlActionProvider
+ */
+export declare const veriqlActionProvider: (config?: VeriqlActionProviderConfig) => VeriqlActionProvider;
+export {};

package/dist/veriql/veriqlActionProvider.js

@@ -0,0 +1,359 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { z } from "zod";
+import { ActionProvider, CreateAction, EvmWalletProvider, SvmWalletProvider, WalletProvider, } from "@coinbase/agentkit";
+import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { registerExactSvmScheme } from "@x402/svm/exact/client";
+import { CheckDenylistSchema, CheckPayeeSchema, CheckSignatureSchema } from "./schemas.js";
+import { DEFAULT_MAX_PAYMENT_USDC, DENYLIST_TTL_MS, USDC_DECIMALS, USER_AGENT, VERIQL_BASE_URL, } from "./constants.js";
+/**
+ * The global fetch, with our user-agent added unless the caller set one.
+ * Resolved per call so a fetch swapped in later (tests, polyfills) is used.
+ *
+ * @param input - The URL or Request
+ * @param init - The request options
+ * @returns The response
+ */
+const veriqlFetch = (input, init) => {
+    if (input instanceof Request) {
+        const headers = new Headers(input.headers);
+        if (!headers.has("user-agent"))
+            headers.set("user-agent", USER_AGENT);
+        return fetch(new Request(input, { ...init, headers }));
+    }
+    const headers = new Headers(init?.headers);
+    if (!headers.has("user-agent"))
+        headers.set("user-agent", USER_AGENT);
+    return fetch(input, { ...init, headers });
+};
+/**
+ * Which denylist family an address belongs to, by shape alone. Tron is checked
+ * before Solana because a 34-character Tron address also passes a base58
+ * length check.
+ *
+ * @param address - The address to classify
+ * @returns The address family, or null if the shape is not recognised
+ */
+export function familyOf(address) {
+    const a = address.trim();
+    if (/^0x[0-9a-fA-F]{40}$/.test(a))
+        return "evm";
+    if (/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(a))
+        return "tron";
+    if (/^(bc1[02-9ac-hj-np-z]{11,71}|[13][1-9A-HJ-NP-Za-km-z]{25,34})$/.test(a))
+        return "btc";
+    if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(a))
+        return "solana";
+    return null;
+}
+/**
+ * Converts a whole-USDC cap to atomic units without floating-point drift:
+ * `0.29 * 1e6` is `289999.99999999994`, which truncates to the wrong amount.
+ *
+ * @param usdc - The amount in whole USDC
+ * @returns The amount in atomic units (6 decimals)
+ */
+export function usdcToAtomic(usdc) {
+    return BigInt(Math.round(usdc * 10 ** USDC_DECIMALS));
+}
+/**
+ * Drops every payment option priced above `capAtomic`. x402 v2 carries the
+ * price as `amount`, v1 as `maxAmountRequired`; an option carrying neither is
+ * dropped too, because a price we cannot read is not one we can agree to.
+ *
+ * @param capAtomic - The highest acceptable price, in atomic USDC units
+ * @returns An x402 payment policy that filters the offered requirements
+ */
+export function priceCapPolicy(capAtomic) {
+    return (_version, reqs) => reqs.filter(r => {
+        const rec = r;
+        const raw = rec.amount ?? rec.maxAmountRequired;
+        if (typeof raw !== "string" && typeof raw !== "number")
+            return false;
+        try {
+            return BigInt(raw) <= capAtomic;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Veriql checks for agents that move money.
+ *
+ * - `check_payee` before sending funds: OFAC SDN, the Drain Watch scam list,
+ *   and whether Tether or Circle has frozen the address (read from the issuer's
+ *   own contract).
+ * - `check_signature` before signing: decodes approvals, Permit/Permit2,
+ *   EIP-7702 delegations, transfers and revokes, and checks who gains the power.
+ * - `check_denylist`: a free lookup against the same lists, no payment.
+ *
+ * Read-only: Veriql never asks for a key, never signs and never moves funds.
+ */
+export class VeriqlActionProvider extends ActionProvider {
+    apiKey;
+    capAtomic;
+    baseUrl;
+    denylist = new Map();
+    /**
+     * Creates a new VeriqlActionProvider.
+     *
+     * @param config - Optional API key, payment cap and base URL
+     */
+    constructor(config = {}) {
+        super("veriql", []);
+        this.apiKey = config.apiKey ?? process.env.VERIQL_API_KEY ?? undefined;
+        const envCap = Number(process.env.VERIQL_MAX_PAYMENT_USDC);
+        const cap = config.maxPaymentUsdc ?? (Number.isFinite(envCap) && envCap > 0 ? envCap : DEFAULT_MAX_PAYMENT_USDC);
+        this.capAtomic = usdcToAtomic(cap);
+        this.baseUrl = (config.baseUrl ?? VERIQL_BASE_URL).replace(/\/+$/, "");
+    }
+    /**
+     * Checks a payment recipient before funds are sent.
+     *
+     * @param walletProvider - The wallet that pays for the call over x402
+     * @param args - The recipient address
+     * @returns The verdict as a JSON string, or an error telling the agent to treat it as unverified
+     */
+    async checkPayee(walletProvider, args) {
+        const url = `${this.baseUrl}/api/v1/payee?address=${encodeURIComponent(args.address.trim())}`;
+        return this.call(walletProvider, url, { method: "GET" });
+    }
+    /**
+     * Checks a signing request before it is signed.
+     *
+     * @param walletProvider - The wallet that pays for the call over x402
+     * @param args - The payload the agent was asked to sign
+     * @returns The decision as a JSON string, or an error telling the agent to treat it as unverified
+     */
+    async checkSignature(walletProvider, args) {
+        // Typed data arrives as a JSON string from a model; send it as the object
+        // it describes so the server decodes the structure, not a quoted string.
+        let payload = args.payload.trim();
+        if (typeof payload === "string" && /^[[{]/.test(payload)) {
+            try {
+                payload = JSON.parse(payload);
+            }
+            catch {
+                // Not JSON after all: the server reports it as undecodable (block).
+            }
+        }
+        return this.call(walletProvider, `${this.baseUrl}/api/v1/signature`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ payload }),
+        });
+    }
+    /**
+     * Looks an address up in the free Veriql denylist.
+     *
+     * @param args - The address to look up
+     * @returns Whether the address is listed, as a JSON string
+     */
+    async checkDenylist(args) {
+        const address = args.address.trim();
+        const family = familyOf(address);
+        if (!family) {
+            return JSON.stringify({ error: true, message: "Not a recognised EVM, Solana, Bitcoin or Tron address." });
+        }
+        try {
+            const values = await this.loadDenylist(family);
+            const needle = family === "evm" ? address.toLowerCase() : address;
+            const listed = values.has(needle);
+            return JSON.stringify({
+                address,
+                family,
+                listed,
+                verdict: listed ? "do_not_pay" : "not_listed",
+                note: listed
+                    ? "Listed on OFAC SDN or Drain Watch. Do not send funds. Run check_payee for the reasons."
+                    : "No listing found. This is not a statement that the address is safe.",
+            });
+        }
+        catch (error) {
+            return JSON.stringify({
+                error: true,
+                message: `Denylist unavailable: ${error instanceof Error ? error.message : String(error)}. Treat the address as unverified.`,
+            });
+        }
+    }
+    /**
+     * Veriql is a read-only API, so every network is supported.
+     *
+     * @returns Always true
+     */
+    supportsNetwork = () => true;
+    /**
+     * Loads one family of the denylist, cached for an hour. A failed refresh
+     * keeps the previous copy rather than reading as an empty list.
+     *
+     * @param family - The address family to load
+     * @returns The listed addresses, EVM ones lowercased
+     */
+    async loadDenylist(family) {
+        const hit = this.denylist.get(family);
+        if (hit && Date.now() - hit.at < DENYLIST_TTL_MS)
+            return hit.values;
+        const res = await veriqlFetch(`${this.baseUrl}/api/denylist?family=${family}`);
+        if (!res.ok) {
+            // The feed answers 503 rather than an empty list; keep a stale copy.
+            if (hit)
+                return hit.values;
+            throw new Error(`HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        if (!Array.isArray(body.items)) {
+            if (hit)
+                return hit.values;
+            throw new Error("unexpected response");
+        }
+        const values = new Set();
+        for (const item of body.items) {
+            if (typeof item?.value !== "string")
+                continue;
+            values.add(family === "evm" ? item.value.toLowerCase() : item.value);
+        }
+        this.denylist.set(family, { at: Date.now(), values });
+        return values;
+    }
+    /**
+     * Calls a paid Veriql endpoint with the API key, or over x402 from the wallet.
+     *
+     * @param walletProvider - The wallet that pays when no API key is set
+     * @param url - The endpoint URL
+     * @param init - The request options
+     * @returns The response body as a JSON string, or an error object
+     */
+    async call(walletProvider, url, init) {
+        try {
+            let res;
+            if (this.apiKey) {
+                res = await veriqlFetch(url, { ...init, headers: { ...init.headers, "x-api-key": this.apiKey } });
+            }
+            else {
+                const client = await this.createX402Client(walletProvider);
+                if (!client) {
+                    return JSON.stringify({
+                        error: true,
+                        message: "This wallet cannot pay over x402 (needs an EVM or Solana wallet holding USDC on Base or Solana). Set VERIQL_API_KEY instead: a free key is at https://veriql.app/api/checkout?pack=free",
+                    });
+                }
+                res = await wrapFetchWithPayment(veriqlFetch, client)(url, init);
+            }
+            const text = await res.text();
+            let data = text;
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                // Leave non-JSON bodies as text.
+            }
+            if (!res.ok) {
+                return JSON.stringify({
+                    error: true,
+                    status: res.status,
+                    message: res.status === 402
+                        ? `Payment was not completed. Veriql's price may be above this agent's cap (${Number(this.capAtomic) / 10 ** USDC_DECIMALS} USDC), or the wallet lacks USDC on Base or Solana.`
+                        : `Veriql answered ${res.status}. Treat the address or payload as unverified.`,
+                    details: data,
+                });
+            }
+            const settlement = res.headers.get("payment-response") ?? res.headers.get("x-payment-response");
+            return JSON.stringify(settlement ? { ...data, paid: true } : data);
+        }
+        catch (error) {
+            return JSON.stringify({
+                error: true,
+                message: `Veriql request failed: ${error instanceof Error ? error.message : String(error)}. Treat the address or payload as unverified.`,
+            });
+        }
+    }
+    /**
+     * Creates an x402 client for the wallet, capped at the configured price.
+     *
+     * @param walletProvider - The wallet that signs the payment
+     * @returns The client, or null if the wallet cannot pay over x402
+     */
+    async createX402Client(walletProvider) {
+        const client = new x402Client();
+        if (walletProvider instanceof EvmWalletProvider) {
+            registerExactEvmScheme(client, { signer: walletProvider.toSigner() });
+        }
+        else if (walletProvider instanceof SvmWalletProvider) {
+            registerExactSvmScheme(client, { signer: await walletProvider.toSigner() });
+        }
+        else {
+            return null;
+        }
+        client.registerPolicy(priceCapPolicy(this.capAtomic));
+        return client;
+    }
+}
+__decorate([
+    CreateAction({
+        name: "check_payee",
+        description: `Check an address BEFORE sending it any money (a transfer, a payment, a payout).
+Checks the US Treasury OFAC sanctions list, the Veriql Drain Watch list of known drainer and scam
+addresses, and whether Tether or Circle has frozen the address (read from the issuer's contract).
+Works for EVM, Solana, Bitcoin and Tron addresses.
+
+Returns a verdict:
+- do_not_pay: do NOT send funds. Tell the user why, using the reasons returned.
+- no_known_risk: nothing adverse was found. This is not a guarantee the recipient is safe.
+- incomplete: some checks could not run. Treat it as unverified, not as clean.
+
+Costs $0.005 in USDC from this wallet (or one credit with an API key).`,
+        schema: CheckPayeeSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VeriqlActionProvider.prototype, "checkPayee", null);
+__decorate([
+    CreateAction({
+        name: "check_signature",
+        description: `Check a signing request BEFORE signing it. Pass exactly what you were asked to sign:
+raw transaction calldata (0x...), an EIP-712 typed-data JSON string, or a JSON-RPC signing request.
+Decodes token approvals, Permit and Permit2, EIP-7702 delegations, transfers and revokes, and checks
+whoever gains the power against OFAC and Drain Watch.
+
+Returns block, warn or allow, with the decoded action in plain words.
+- block: do NOT sign. A payload that cannot be decoded is also block, and is not charged.
+- warn: explain the risk to the user and get explicit confirmation before signing.
+- allow: no known risk was found in what this payload does.
+
+Costs $0.005 in USDC from this wallet (or one credit with an API key).`,
+        schema: CheckSignatureSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VeriqlActionProvider.prototype, "checkSignature", null);
+__decorate([
+    CreateAction({
+        name: "check_denylist",
+        description: `Free, instant lookup of an address against the Veriql denylist (OFAC SDN sanctions plus
+Drain Watch known drainer and scam addresses), refreshed daily. No payment.
+Use it for a quick screen. Before actually sending funds prefer check_payee, which also reads
+Tether and Circle freezes. An address NOT on the list means no listing was found, not that it is safe.`,
+        schema: CheckDenylistSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], VeriqlActionProvider.prototype, "checkDenylist", null);
+/**
+ * Creates a VeriqlActionProvider.
+ *
+ * @param config - Optional API key, payment cap and base URL
+ * @returns A new VeriqlActionProvider
+ */
+export const veriqlActionProvider = (config = {}) => new VeriqlActionProvider(config);

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "veriql-agentkit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Veriql for Coinbase AgentKit: check a recipient (OFAC, Drain Watch, Tether/Circle freeze) before an agent pays, decode a signing request before it signs, and load a free denylist for wallet policies.",
+  "keywords": [
+    "agentkit",
+    "coinbase",
+    "x402",
+    "ai-agents",
+    "sanctions",
+    "ofac",
+    "wallet-security",
+    "signature",
+    "permit2",
+    "eip-7702",
+    "solana",
+    "base"
+  ],
+  "homepage": "https://veriql.app/api",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test \"test/*.test.mjs\"",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@coinbase/agentkit": ">=0.10.0"
+  },
+  "dependencies": {
+    "@x402/evm": "^2.0.0",
+    "@x402/fetch": "^2.0.0",
+    "@x402/svm": "^2.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@coinbase/agentkit": "0.10.4",
+    "typescript": "^5.6.0"
+  }
+}