@nullclear/x402-arbiter 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nullclear-Protocol
+
+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,37 @@
-# Temporary Holding Version
+# @nullclear/x402-arbiter
 
-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.
+Autonomous Agent SDK for zero-risk HTTP 402 calls via NullClear Deferred Non-Custodial Schema Escrow.
+
+## Key Features
+- **Automatic 402 Interception:** Intercepts standard `402 Payment Required` headers and signs EIP-3009 authorizations.
+- **Zod & JSON Schema Enforcement:** Define expected response structures with standard Zod or JSON schemas.
+- **$0 Spend Protection:** If the seller crashes, returns 500, or hallucinates bad types, settlement is voided and $0 is spent.
+
+## Quickstart
+
+```typescript
+import { createNullClearFetch } from "@nullclear/x402-arbiter";
+import { z } from "zod";
+
+const nullclearFetch = createNullClearFetch({
+  accountOrPrivateKey: "0x...", // Buyer private key or viem account
+  chainId: 8453, // Base Mainnet (or 84532 for Base Sepolia)
+  arbiterUrl: "https://arbiter.nullclear.dev"
+});
+
+// Make requests normally - 402 will be intercepted and escrow-routed
+const response = await nullclearFetch("https://seller-agent.com/v1/alpha", {
+  nullclear: {
+    sellerAgentId: "42",
+    minTrustScore: 60,
+    schema: z.object({
+      ticker: z.string(),
+      price: z.number(),
+      confidence: z.number()
+    })
+  }
+});
+
+const data = await response.json();
+console.log("Verified data:", data);
+```

package/dist/index.cjs

@@ -0,0 +1,320 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NullClearClient: () => NullClearClient,
+  NullClearEscrowAbortedError: () => NullClearEscrowAbortedError,
+  createNullClearFetch: () => createNullClearFetch,
+  signX402Payment: () => signX402Payment,
+  zodToJsonSchema: () => zodToJsonSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/signer.ts
+var import_accounts = require("viem/accounts");
+var import_shared = require("@nullclear/shared");
+async function signX402Payment(signer, option, resourceUrl) {
+  let accountAddress;
+  let signTypedDataFn;
+  if (typeof signer === "string" && signer.startsWith("0x")) {
+    const account = (0, import_accounts.privateKeyToAccount)(signer);
+    accountAddress = account.address;
+    signTypedDataFn = (params) => account.signTypedData(params);
+  } else if (typeof signer === "object" && signer !== null && "signTypedData" in signer && "account" in signer && signer.account) {
+    const rawAccount = signer.account;
+    accountAddress = typeof rawAccount === "string" ? rawAccount : rawAccount.address;
+    signTypedDataFn = (params) => signer.signTypedData(params);
+  } else {
+    throw new Error("Invalid signer provided to signX402Payment: must be private key or viem account/wallet client");
+  }
+  const randomBytes = new Uint8Array(32);
+  crypto.getRandomValues(randomBytes);
+  const nonce = `0x` + Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const validAfter = "0";
+  const timeoutSeconds = option.maxTimeoutSeconds && option.maxTimeoutSeconds > 0 ? option.maxTimeoutSeconds : 300;
+  const validBefore = String(Math.floor(Date.now() / 1e3) + timeoutSeconds);
+  const chainConfig = (0, import_shared.getChainConfig)(option.network);
+  const domain = {
+    name: chainConfig.usdcDomain.name,
+    version: chainConfig.usdcDomain.version,
+    chainId: chainConfig.chainId,
+    verifyingContract: chainConfig.usdc
+  };
+  const authorization = {
+    from: accountAddress,
+    to: option.payTo,
+    value: option.amount,
+    validAfter,
+    validBefore,
+    nonce
+  };
+  const signature = await signTypedDataFn({
+    domain,
+    types: import_shared.EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: authorization.from,
+      to: authorization.to,
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    }
+  });
+  const payload = {
+    x402Version: 2,
+    resource: resourceUrl ? { url: resourceUrl } : void 0,
+    accepted: option,
+    payload: {
+      signature,
+      authorization
+    }
+  };
+  return (0, import_shared.encodeBase64Json)(payload);
+}
+
+// src/client.ts
+var NullClearClient = class {
+  arbiterUrl;
+  defaultChainId;
+  customFetch;
+  constructor(config = {}) {
+    this.arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+    this.defaultChainId = config.defaultChainId || 8453;
+    this.customFetch = config.fetch || fetch;
+  }
+  async getScore(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/score/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to fetch score for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async clear(request) {
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+    const data = await res.json();
+    return data;
+  }
+  async getKya(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      if (res.status === 404) return null;
+      const err = await res.text();
+      throw new Error(`Failed to fetch KYA mandate for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async attestKya(mandate, chainId, signature, signerAddress) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/attest`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        mandate,
+        chainId: targetChainId,
+        signature,
+        signerAddress
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to attest KYA mandate: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+};
+
+// src/fetch-wrapper.ts
+var import_zod = require("zod");
+var import_shared2 = require("@nullclear/shared");
+var NullClearEscrowAbortedError = class extends Error {
+  stage;
+  buyerCharged;
+  validationErrors;
+  score;
+  upstreamStatus;
+  reason;
+  constructor(message, details) {
+    super(message);
+    this.name = "NullClearEscrowAbortedError";
+    this.stage = details.stage;
+    this.buyerCharged = details.buyerCharged || "0";
+    this.validationErrors = details.validationErrors || [];
+    this.score = details.score;
+    this.upstreamStatus = details.upstreamStatus;
+    this.reason = details.reason;
+  }
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  if (!def) return {};
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: def.type ? zodToJsonSchema(def.type) : {}
+      };
+    case "ZodObject": {
+      const shape = def.shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const subDef = value._def;
+        if (subDef.typeName !== "ZodOptional" && subDef.typeName !== "ZodNullable") {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      };
+    }
+    case "ZodEnum":
+      return {
+        type: "string",
+        enum: def.values
+      };
+    case "ZodOptional":
+    case "ZodNullable":
+      return def.innerType ? zodToJsonSchema(def.innerType) : {};
+    default:
+      return {};
+  }
+}
+function createNullClearFetch(config) {
+  const chainId = config.chainId || 8453;
+  const arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+  const defaultMinTrustScore = config.defaultMinTrustScore || 50;
+  const customFetch = config.customFetch || fetch;
+  return async function nullclearFetch(input, init) {
+    const targetUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const fetchInit = { ...init };
+    delete fetchInit.nullclear;
+    const initialRes = await customFetch(input, fetchInit);
+    if (initialRes.status !== 402) {
+      return initialRes;
+    }
+    const paymentRequiredHeader = initialRes.headers.get("PAYMENT-REQUIRED") || initialRes.headers.get("payment-required");
+    if (!paymentRequiredHeader) {
+      return initialRes;
+    }
+    let paymentRequired;
+    try {
+      paymentRequired = (0, import_shared2.decodeBase64Json)(paymentRequiredHeader);
+    } catch {
+      return initialRes;
+    }
+    const targetNetwork = `eip155:${chainId}`;
+    const selectedOption = paymentRequired.accepts.find(
+      (opt) => opt.network === targetNetwork && opt.scheme === "exact"
+    );
+    if (!selectedOption) {
+      throw new Error(
+        `Seller does not accept payments on network ${targetNetwork}. Accepted: ${paymentRequired.accepts.map((a) => a.network).join(", ")}`
+      );
+    }
+    const paymentSignatureHeader = await signX402Payment(
+      config.accountOrPrivateKey,
+      selectedOption,
+      targetUrl
+    );
+    let jsonSchema;
+    if (init?.nullclear?.schema) {
+      if (init.nullclear.schema instanceof import_zod.z.ZodType) {
+        jsonSchema = zodToJsonSchema(init.nullclear.schema);
+      } else if (typeof init.nullclear.schema === "object") {
+        jsonSchema = init.nullclear.schema;
+      }
+    }
+    const clearPayload = {
+      targetUrl,
+      method: init?.method || "GET",
+      headers: init?.headers || {},
+      body: init?.body,
+      paymentSignatureHeader,
+      sellerAgentId: init?.nullclear?.sellerAgentId,
+      minTrustScore: init?.nullclear?.minTrustScore ?? defaultMinTrustScore,
+      validation: {
+        expectedStatus: [200],
+        jsonSchema,
+        requiredFields: init?.nullclear?.requiredFields,
+        sha256Match: init?.nullclear?.sha256Match
+      }
+    };
+    const arbiterRes = await customFetch(`${arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(clearPayload)
+    });
+    const arbiterData = await arbiterRes.json();
+    if (arbiterRes.status === 200 && arbiterData.cleared) {
+      const resBody = typeof arbiterData.data === "string" ? arbiterData.data : JSON.stringify(arbiterData.data);
+      const resHeaders = new Headers();
+      resHeaders.set("Content-Type", "application/json");
+      const paymentResponseHdr = arbiterRes.headers.get("PAYMENT-RESPONSE");
+      if (paymentResponseHdr) resHeaders.set("PAYMENT-RESPONSE", paymentResponseHdr);
+      const attestationHdr = arbiterRes.headers.get("X-NullClear-Attestation");
+      if (attestationHdr) resHeaders.set("X-NullClear-Attestation", attestationHdr);
+      return new Response(resBody, {
+        status: 200,
+        headers: resHeaders
+      });
+    }
+    throw new NullClearEscrowAbortedError(
+      `NullClear Escrow Aborted: ${arbiterData.stage || "FAILED"} - ${arbiterData.reason || arbiterData.error || (arbiterData.validationErrors || []).join("; ")}`,
+      {
+        stage: arbiterData.stage || "UNKNOWN_FAILURE",
+        buyerCharged: arbiterData.buyerCharged || "0",
+        validationErrors: arbiterData.validationErrors || [],
+        score: arbiterData.score,
+        upstreamStatus: arbiterData.upstreamStatus,
+        reason: arbiterData.reason || arbiterData.error
+      }
+    );
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NullClearClient,
+  NullClearEscrowAbortedError,
+  createNullClearFetch,
+  signX402Payment,
+  zodToJsonSchema
+});

package/dist/index.d.cts

@@ -0,0 +1,104 @@
+import { PrivateKeyAccount } from 'viem/accounts';
+import { WalletClient } from 'viem';
+import { X402PaymentOption, KYAMandate } from '@nullclear/shared';
+import { z } from 'zod';
+
+type SignerInput = `0x${string}` | PrivateKeyAccount | {
+    account: {
+        address: `0x${string}`;
+    };
+    signTypedData: (params: any) => Promise<`0x${string}`>;
+} | WalletClient;
+/**
+ * Signs an EIP-3009 TransferWithAuthorization and returns a Base64 encoded X402PaymentSignaturePayload
+ */
+declare function signX402Payment(signer: SignerInput, option: X402PaymentOption, resourceUrl?: string): Promise<string>;
+
+interface NullClearClientConfig {
+    arbiterUrl?: string;
+    defaultChainId?: number;
+    fetch?: typeof fetch;
+}
+interface ClearRequest {
+    targetUrl: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    paymentSignatureHeader: string;
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    validation?: {
+        expectedStatus?: number[];
+        jsonSchema?: Record<string, unknown>;
+        requiredFields?: string[];
+        sha256Match?: string;
+    };
+}
+interface ClearResult<T = unknown> {
+    cleared: boolean;
+    settled: boolean;
+    clearingId?: string;
+    buyerCharged: string;
+    clearingFee?: string;
+    transaction?: `0x${string}`;
+    attestation?: unknown;
+    data?: T;
+    stage?: string;
+    error?: string;
+    validationErrors?: string[];
+}
+declare class NullClearClient {
+    private arbiterUrl;
+    private defaultChainId;
+    private customFetch;
+    constructor(config?: NullClearClientConfig);
+    getScore(agentId: string, chainId?: number): Promise<any>;
+    clear<T = unknown>(request: ClearRequest): Promise<ClearResult<T>>;
+    getKya(agentId: string, chainId?: number): Promise<any>;
+    attestKya(mandate: KYAMandate, chainId?: number, signature?: string, signerAddress?: `0x${string}`): Promise<any>;
+}
+
+declare class NullClearEscrowAbortedError extends Error {
+    stage: string;
+    buyerCharged: string;
+    validationErrors: string[];
+    score?: number;
+    upstreamStatus?: number;
+    reason?: string;
+    constructor(message: string, details: {
+        stage: string;
+        buyerCharged?: string;
+        validationErrors?: string[];
+        score?: number;
+        upstreamStatus?: number;
+        reason?: string;
+    });
+}
+/**
+ * Lightweight deterministic Zod-to-JSON-Schema converter
+ */
+declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;
+interface NullClearOptions {
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    schema?: z.ZodTypeAny | Record<string, unknown>;
+    requiredFields?: string[];
+    sha256Match?: string;
+}
+interface NullClearFetchConfig {
+    accountOrPrivateKey: SignerInput;
+    chainId?: number;
+    arbiterUrl?: string;
+    defaultMinTrustScore?: number;
+    customFetch?: typeof fetch;
+}
+type NullClearRequestInit = RequestInit & {
+    nullclear?: NullClearOptions;
+};
+/**
+ * Creates an enhanced fetch client that autonomously intercepts HTTP 402 Payment Required
+ * and safely wraps the call in NullClear Deferred Non-Custodial Schema Escrow
+ */
+declare function createNullClearFetch(config: NullClearFetchConfig): (input: RequestInfo | URL, init?: NullClearRequestInit) => Promise<Response>;
+
+export { type ClearRequest, type ClearResult, NullClearClient, type NullClearClientConfig, NullClearEscrowAbortedError, type NullClearFetchConfig, type NullClearOptions, type NullClearRequestInit, type SignerInput, createNullClearFetch, signX402Payment, zodToJsonSchema };

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import { PrivateKeyAccount } from 'viem/accounts';
+import { WalletClient } from 'viem';
+import { X402PaymentOption, KYAMandate } from '@nullclear/shared';
+import { z } from 'zod';
+
+type SignerInput = `0x${string}` | PrivateKeyAccount | {
+    account: {
+        address: `0x${string}`;
+    };
+    signTypedData: (params: any) => Promise<`0x${string}`>;
+} | WalletClient;
+/**
+ * Signs an EIP-3009 TransferWithAuthorization and returns a Base64 encoded X402PaymentSignaturePayload
+ */
+declare function signX402Payment(signer: SignerInput, option: X402PaymentOption, resourceUrl?: string): Promise<string>;
+
+interface NullClearClientConfig {
+    arbiterUrl?: string;
+    defaultChainId?: number;
+    fetch?: typeof fetch;
+}
+interface ClearRequest {
+    targetUrl: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    paymentSignatureHeader: string;
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    validation?: {
+        expectedStatus?: number[];
+        jsonSchema?: Record<string, unknown>;
+        requiredFields?: string[];
+        sha256Match?: string;
+    };
+}
+interface ClearResult<T = unknown> {
+    cleared: boolean;
+    settled: boolean;
+    clearingId?: string;
+    buyerCharged: string;
+    clearingFee?: string;
+    transaction?: `0x${string}`;
+    attestation?: unknown;
+    data?: T;
+    stage?: string;
+    error?: string;
+    validationErrors?: string[];
+}
+declare class NullClearClient {
+    private arbiterUrl;
+    private defaultChainId;
+    private customFetch;
+    constructor(config?: NullClearClientConfig);
+    getScore(agentId: string, chainId?: number): Promise<any>;
+    clear<T = unknown>(request: ClearRequest): Promise<ClearResult<T>>;
+    getKya(agentId: string, chainId?: number): Promise<any>;
+    attestKya(mandate: KYAMandate, chainId?: number, signature?: string, signerAddress?: `0x${string}`): Promise<any>;
+}
+
+declare class NullClearEscrowAbortedError extends Error {
+    stage: string;
+    buyerCharged: string;
+    validationErrors: string[];
+    score?: number;
+    upstreamStatus?: number;
+    reason?: string;
+    constructor(message: string, details: {
+        stage: string;
+        buyerCharged?: string;
+        validationErrors?: string[];
+        score?: number;
+        upstreamStatus?: number;
+        reason?: string;
+    });
+}
+/**
+ * Lightweight deterministic Zod-to-JSON-Schema converter
+ */
+declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;
+interface NullClearOptions {
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    schema?: z.ZodTypeAny | Record<string, unknown>;
+    requiredFields?: string[];
+    sha256Match?: string;
+}
+interface NullClearFetchConfig {
+    accountOrPrivateKey: SignerInput;
+    chainId?: number;
+    arbiterUrl?: string;
+    defaultMinTrustScore?: number;
+    customFetch?: typeof fetch;
+}
+type NullClearRequestInit = RequestInit & {
+    nullclear?: NullClearOptions;
+};
+/**
+ * Creates an enhanced fetch client that autonomously intercepts HTTP 402 Payment Required
+ * and safely wraps the call in NullClear Deferred Non-Custodial Schema Escrow
+ */
+declare function createNullClearFetch(config: NullClearFetchConfig): (input: RequestInfo | URL, init?: NullClearRequestInit) => Promise<Response>;
+
+export { type ClearRequest, type ClearResult, NullClearClient, type NullClearClientConfig, NullClearEscrowAbortedError, type NullClearFetchConfig, type NullClearOptions, type NullClearRequestInit, type SignerInput, createNullClearFetch, signX402Payment, zodToJsonSchema };

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import { PrivateKeyAccount } from 'viem/accounts';
+import { WalletClient } from 'viem';
+import { X402PaymentOption, KYAMandate } from '@nullclear/shared';
+import { z } from 'zod';
+
+type SignerInput = `0x${string}` | PrivateKeyAccount | {
+    account: {
+        address: `0x${string}`;
+    };
+    signTypedData: (params: any) => Promise<`0x${string}`>;
+} | WalletClient;
+/**
+ * Signs an EIP-3009 TransferWithAuthorization and returns a Base64 encoded X402PaymentSignaturePayload
+ */
+declare function signX402Payment(signer: SignerInput, option: X402PaymentOption, resourceUrl?: string): Promise<string>;
+
+interface NullClearClientConfig {
+    arbiterUrl?: string;
+    defaultChainId?: number;
+    fetch?: typeof fetch;
+}
+interface ClearRequest {
+    targetUrl: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    paymentSignatureHeader: string;
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    validation?: {
+        expectedStatus?: number[];
+        jsonSchema?: Record<string, unknown>;
+        requiredFields?: string[];
+        sha256Match?: string;
+    };
+}
+interface ClearResult<T = unknown> {
+    cleared: boolean;
+    settled: boolean;
+    clearingId?: string;
+    buyerCharged: string;
+    clearingFee?: string;
+    transaction?: `0x${string}`;
+    attestation?: unknown;
+    data?: T;
+    stage?: string;
+    error?: string;
+    validationErrors?: string[];
+}
+declare class NullClearClient {
+    private arbiterUrl;
+    private defaultChainId;
+    private customFetch;
+    constructor(config?: NullClearClientConfig);
+    getScore(agentId: string, chainId?: number): Promise<any>;
+    clear<T = unknown>(request: ClearRequest): Promise<ClearResult<T>>;
+    getKya(agentId: string, chainId?: number): Promise<any>;
+    attestKya(mandate: KYAMandate, chainId?: number, signature?: string, signerAddress?: `0x${string}`): Promise<any>;
+}
+
+declare class NullClearEscrowAbortedError extends Error {
+    stage: string;
+    buyerCharged: string;
+    validationErrors: string[];
+    score?: number;
+    upstreamStatus?: number;
+    reason?: string;
+    constructor(message: string, details: {
+        stage: string;
+        buyerCharged?: string;
+        validationErrors?: string[];
+        score?: number;
+        upstreamStatus?: number;
+        reason?: string;
+    });
+}
+/**
+ * Lightweight deterministic Zod-to-JSON-Schema converter
+ */
+declare function zodToJsonSchema(schema: z.ZodTypeAny): Record<string, unknown>;
+interface NullClearOptions {
+    sellerAgentId?: string;
+    minTrustScore?: number;
+    schema?: z.ZodTypeAny | Record<string, unknown>;
+    requiredFields?: string[];
+    sha256Match?: string;
+}
+interface NullClearFetchConfig {
+    accountOrPrivateKey: SignerInput;
+    chainId?: number;
+    arbiterUrl?: string;
+    defaultMinTrustScore?: number;
+    customFetch?: typeof fetch;
+}
+type NullClearRequestInit = RequestInit & {
+    nullclear?: NullClearOptions;
+};
+/**
+ * Creates an enhanced fetch client that autonomously intercepts HTTP 402 Payment Required
+ * and safely wraps the call in NullClear Deferred Non-Custodial Schema Escrow
+ */
+declare function createNullClearFetch(config: NullClearFetchConfig): (input: RequestInfo | URL, init?: NullClearRequestInit) => Promise<Response>;
+
+export { type ClearRequest, type ClearResult, NullClearClient, type NullClearClientConfig, NullClearEscrowAbortedError, type NullClearFetchConfig, type NullClearOptions, type NullClearRequestInit, type SignerInput, createNullClearFetch, signX402Payment, zodToJsonSchema };

package/dist/index.js

@@ -0,0 +1,295 @@
+// src/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  EIP3009_TYPES,
+  getChainConfig,
+  encodeBase64Json
+} from "@nullclear/shared";
+async function signX402Payment(signer, option, resourceUrl) {
+  let accountAddress;
+  let signTypedDataFn;
+  if (typeof signer === "string" && signer.startsWith("0x")) {
+    const account = privateKeyToAccount(signer);
+    accountAddress = account.address;
+    signTypedDataFn = (params) => account.signTypedData(params);
+  } else if (typeof signer === "object" && signer !== null && "signTypedData" in signer && "account" in signer && signer.account) {
+    const rawAccount = signer.account;
+    accountAddress = typeof rawAccount === "string" ? rawAccount : rawAccount.address;
+    signTypedDataFn = (params) => signer.signTypedData(params);
+  } else {
+    throw new Error("Invalid signer provided to signX402Payment: must be private key or viem account/wallet client");
+  }
+  const randomBytes = new Uint8Array(32);
+  crypto.getRandomValues(randomBytes);
+  const nonce = `0x` + Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const validAfter = "0";
+  const timeoutSeconds = option.maxTimeoutSeconds && option.maxTimeoutSeconds > 0 ? option.maxTimeoutSeconds : 300;
+  const validBefore = String(Math.floor(Date.now() / 1e3) + timeoutSeconds);
+  const chainConfig = getChainConfig(option.network);
+  const domain = {
+    name: chainConfig.usdcDomain.name,
+    version: chainConfig.usdcDomain.version,
+    chainId: chainConfig.chainId,
+    verifyingContract: chainConfig.usdc
+  };
+  const authorization = {
+    from: accountAddress,
+    to: option.payTo,
+    value: option.amount,
+    validAfter,
+    validBefore,
+    nonce
+  };
+  const signature = await signTypedDataFn({
+    domain,
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: authorization.from,
+      to: authorization.to,
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    }
+  });
+  const payload = {
+    x402Version: 2,
+    resource: resourceUrl ? { url: resourceUrl } : void 0,
+    accepted: option,
+    payload: {
+      signature,
+      authorization
+    }
+  };
+  return encodeBase64Json(payload);
+}
+
+// src/client.ts
+var NullClearClient = class {
+  arbiterUrl;
+  defaultChainId;
+  customFetch;
+  constructor(config = {}) {
+    this.arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+    this.defaultChainId = config.defaultChainId || 8453;
+    this.customFetch = config.fetch || fetch;
+  }
+  async getScore(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/score/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to fetch score for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async clear(request) {
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+    const data = await res.json();
+    return data;
+  }
+  async getKya(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      if (res.status === 404) return null;
+      const err = await res.text();
+      throw new Error(`Failed to fetch KYA mandate for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async attestKya(mandate, chainId, signature, signerAddress) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/attest`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        mandate,
+        chainId: targetChainId,
+        signature,
+        signerAddress
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to attest KYA mandate: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+};
+
+// src/fetch-wrapper.ts
+import { z } from "zod";
+import {
+  decodeBase64Json
+} from "@nullclear/shared";
+var NullClearEscrowAbortedError = class extends Error {
+  stage;
+  buyerCharged;
+  validationErrors;
+  score;
+  upstreamStatus;
+  reason;
+  constructor(message, details) {
+    super(message);
+    this.name = "NullClearEscrowAbortedError";
+    this.stage = details.stage;
+    this.buyerCharged = details.buyerCharged || "0";
+    this.validationErrors = details.validationErrors || [];
+    this.score = details.score;
+    this.upstreamStatus = details.upstreamStatus;
+    this.reason = details.reason;
+  }
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  if (!def) return {};
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: def.type ? zodToJsonSchema(def.type) : {}
+      };
+    case "ZodObject": {
+      const shape = def.shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const subDef = value._def;
+        if (subDef.typeName !== "ZodOptional" && subDef.typeName !== "ZodNullable") {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      };
+    }
+    case "ZodEnum":
+      return {
+        type: "string",
+        enum: def.values
+      };
+    case "ZodOptional":
+    case "ZodNullable":
+      return def.innerType ? zodToJsonSchema(def.innerType) : {};
+    default:
+      return {};
+  }
+}
+function createNullClearFetch(config) {
+  const chainId = config.chainId || 8453;
+  const arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+  const defaultMinTrustScore = config.defaultMinTrustScore || 50;
+  const customFetch = config.customFetch || fetch;
+  return async function nullclearFetch(input, init) {
+    const targetUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const fetchInit = { ...init };
+    delete fetchInit.nullclear;
+    const initialRes = await customFetch(input, fetchInit);
+    if (initialRes.status !== 402) {
+      return initialRes;
+    }
+    const paymentRequiredHeader = initialRes.headers.get("PAYMENT-REQUIRED") || initialRes.headers.get("payment-required");
+    if (!paymentRequiredHeader) {
+      return initialRes;
+    }
+    let paymentRequired;
+    try {
+      paymentRequired = decodeBase64Json(paymentRequiredHeader);
+    } catch {
+      return initialRes;
+    }
+    const targetNetwork = `eip155:${chainId}`;
+    const selectedOption = paymentRequired.accepts.find(
+      (opt) => opt.network === targetNetwork && opt.scheme === "exact"
+    );
+    if (!selectedOption) {
+      throw new Error(
+        `Seller does not accept payments on network ${targetNetwork}. Accepted: ${paymentRequired.accepts.map((a) => a.network).join(", ")}`
+      );
+    }
+    const paymentSignatureHeader = await signX402Payment(
+      config.accountOrPrivateKey,
+      selectedOption,
+      targetUrl
+    );
+    let jsonSchema;
+    if (init?.nullclear?.schema) {
+      if (init.nullclear.schema instanceof z.ZodType) {
+        jsonSchema = zodToJsonSchema(init.nullclear.schema);
+      } else if (typeof init.nullclear.schema === "object") {
+        jsonSchema = init.nullclear.schema;
+      }
+    }
+    const clearPayload = {
+      targetUrl,
+      method: init?.method || "GET",
+      headers: init?.headers || {},
+      body: init?.body,
+      paymentSignatureHeader,
+      sellerAgentId: init?.nullclear?.sellerAgentId,
+      minTrustScore: init?.nullclear?.minTrustScore ?? defaultMinTrustScore,
+      validation: {
+        expectedStatus: [200],
+        jsonSchema,
+        requiredFields: init?.nullclear?.requiredFields,
+        sha256Match: init?.nullclear?.sha256Match
+      }
+    };
+    const arbiterRes = await customFetch(`${arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(clearPayload)
+    });
+    const arbiterData = await arbiterRes.json();
+    if (arbiterRes.status === 200 && arbiterData.cleared) {
+      const resBody = typeof arbiterData.data === "string" ? arbiterData.data : JSON.stringify(arbiterData.data);
+      const resHeaders = new Headers();
+      resHeaders.set("Content-Type", "application/json");
+      const paymentResponseHdr = arbiterRes.headers.get("PAYMENT-RESPONSE");
+      if (paymentResponseHdr) resHeaders.set("PAYMENT-RESPONSE", paymentResponseHdr);
+      const attestationHdr = arbiterRes.headers.get("X-NullClear-Attestation");
+      if (attestationHdr) resHeaders.set("X-NullClear-Attestation", attestationHdr);
+      return new Response(resBody, {
+        status: 200,
+        headers: resHeaders
+      });
+    }
+    throw new NullClearEscrowAbortedError(
+      `NullClear Escrow Aborted: ${arbiterData.stage || "FAILED"} - ${arbiterData.reason || arbiterData.error || (arbiterData.validationErrors || []).join("; ")}`,
+      {
+        stage: arbiterData.stage || "UNKNOWN_FAILURE",
+        buyerCharged: arbiterData.buyerCharged || "0",
+        validationErrors: arbiterData.validationErrors || [],
+        score: arbiterData.score,
+        upstreamStatus: arbiterData.upstreamStatus,
+        reason: arbiterData.reason || arbiterData.error
+      }
+    );
+  };
+}
+export {
+  NullClearClient,
+  NullClearEscrowAbortedError,
+  createNullClearFetch,
+  signX402Payment,
+  zodToJsonSchema
+};

package/dist/index.mjs

@@ -0,0 +1,295 @@
+// src/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  EIP3009_TYPES,
+  getChainConfig,
+  encodeBase64Json
+} from "@nullclear/shared";
+async function signX402Payment(signer, option, resourceUrl) {
+  let accountAddress;
+  let signTypedDataFn;
+  if (typeof signer === "string" && signer.startsWith("0x")) {
+    const account = privateKeyToAccount(signer);
+    accountAddress = account.address;
+    signTypedDataFn = (params) => account.signTypedData(params);
+  } else if (typeof signer === "object" && signer !== null && "signTypedData" in signer && "account" in signer && signer.account) {
+    const rawAccount = signer.account;
+    accountAddress = typeof rawAccount === "string" ? rawAccount : rawAccount.address;
+    signTypedDataFn = (params) => signer.signTypedData(params);
+  } else {
+    throw new Error("Invalid signer provided to signX402Payment: must be private key or viem account/wallet client");
+  }
+  const randomBytes = new Uint8Array(32);
+  crypto.getRandomValues(randomBytes);
+  const nonce = `0x` + Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const validAfter = "0";
+  const timeoutSeconds = option.maxTimeoutSeconds && option.maxTimeoutSeconds > 0 ? option.maxTimeoutSeconds : 300;
+  const validBefore = String(Math.floor(Date.now() / 1e3) + timeoutSeconds);
+  const chainConfig = getChainConfig(option.network);
+  const domain = {
+    name: chainConfig.usdcDomain.name,
+    version: chainConfig.usdcDomain.version,
+    chainId: chainConfig.chainId,
+    verifyingContract: chainConfig.usdc
+  };
+  const authorization = {
+    from: accountAddress,
+    to: option.payTo,
+    value: option.amount,
+    validAfter,
+    validBefore,
+    nonce
+  };
+  const signature = await signTypedDataFn({
+    domain,
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: authorization.from,
+      to: authorization.to,
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    }
+  });
+  const payload = {
+    x402Version: 2,
+    resource: resourceUrl ? { url: resourceUrl } : void 0,
+    accepted: option,
+    payload: {
+      signature,
+      authorization
+    }
+  };
+  return encodeBase64Json(payload);
+}
+
+// src/client.ts
+var NullClearClient = class {
+  arbiterUrl;
+  defaultChainId;
+  customFetch;
+  constructor(config = {}) {
+    this.arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+    this.defaultChainId = config.defaultChainId || 8453;
+    this.customFetch = config.fetch || fetch;
+  }
+  async getScore(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/score/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to fetch score for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async clear(request) {
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+    const data = await res.json();
+    return data;
+  }
+  async getKya(agentId, chainId) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/${targetChainId}/${agentId}`);
+    if (!res.ok) {
+      if (res.status === 404) return null;
+      const err = await res.text();
+      throw new Error(`Failed to fetch KYA mandate for agent ${agentId}: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async attestKya(mandate, chainId, signature, signerAddress) {
+    const targetChainId = chainId || this.defaultChainId;
+    const res = await this.customFetch(`${this.arbiterUrl}/v1/kya/attest`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        mandate,
+        chainId: targetChainId,
+        signature,
+        signerAddress
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Failed to attest KYA mandate: ${res.status} ${err}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+};
+
+// src/fetch-wrapper.ts
+import { z } from "zod";
+import {
+  decodeBase64Json
+} from "@nullclear/shared";
+var NullClearEscrowAbortedError = class extends Error {
+  stage;
+  buyerCharged;
+  validationErrors;
+  score;
+  upstreamStatus;
+  reason;
+  constructor(message, details) {
+    super(message);
+    this.name = "NullClearEscrowAbortedError";
+    this.stage = details.stage;
+    this.buyerCharged = details.buyerCharged || "0";
+    this.validationErrors = details.validationErrors || [];
+    this.score = details.score;
+    this.upstreamStatus = details.upstreamStatus;
+    this.reason = details.reason;
+  }
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  if (!def) return {};
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: def.type ? zodToJsonSchema(def.type) : {}
+      };
+    case "ZodObject": {
+      const shape = def.shape();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const subDef = value._def;
+        if (subDef.typeName !== "ZodOptional" && subDef.typeName !== "ZodNullable") {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      };
+    }
+    case "ZodEnum":
+      return {
+        type: "string",
+        enum: def.values
+      };
+    case "ZodOptional":
+    case "ZodNullable":
+      return def.innerType ? zodToJsonSchema(def.innerType) : {};
+    default:
+      return {};
+  }
+}
+function createNullClearFetch(config) {
+  const chainId = config.chainId || 8453;
+  const arbiterUrl = (config.arbiterUrl || "https://arbiter.nullclear.dev").replace(/\/$/, "");
+  const defaultMinTrustScore = config.defaultMinTrustScore || 50;
+  const customFetch = config.customFetch || fetch;
+  return async function nullclearFetch(input, init) {
+    const targetUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const fetchInit = { ...init };
+    delete fetchInit.nullclear;
+    const initialRes = await customFetch(input, fetchInit);
+    if (initialRes.status !== 402) {
+      return initialRes;
+    }
+    const paymentRequiredHeader = initialRes.headers.get("PAYMENT-REQUIRED") || initialRes.headers.get("payment-required");
+    if (!paymentRequiredHeader) {
+      return initialRes;
+    }
+    let paymentRequired;
+    try {
+      paymentRequired = decodeBase64Json(paymentRequiredHeader);
+    } catch {
+      return initialRes;
+    }
+    const targetNetwork = `eip155:${chainId}`;
+    const selectedOption = paymentRequired.accepts.find(
+      (opt) => opt.network === targetNetwork && opt.scheme === "exact"
+    );
+    if (!selectedOption) {
+      throw new Error(
+        `Seller does not accept payments on network ${targetNetwork}. Accepted: ${paymentRequired.accepts.map((a) => a.network).join(", ")}`
+      );
+    }
+    const paymentSignatureHeader = await signX402Payment(
+      config.accountOrPrivateKey,
+      selectedOption,
+      targetUrl
+    );
+    let jsonSchema;
+    if (init?.nullclear?.schema) {
+      if (init.nullclear.schema instanceof z.ZodType) {
+        jsonSchema = zodToJsonSchema(init.nullclear.schema);
+      } else if (typeof init.nullclear.schema === "object") {
+        jsonSchema = init.nullclear.schema;
+      }
+    }
+    const clearPayload = {
+      targetUrl,
+      method: init?.method || "GET",
+      headers: init?.headers || {},
+      body: init?.body,
+      paymentSignatureHeader,
+      sellerAgentId: init?.nullclear?.sellerAgentId,
+      minTrustScore: init?.nullclear?.minTrustScore ?? defaultMinTrustScore,
+      validation: {
+        expectedStatus: [200],
+        jsonSchema,
+        requiredFields: init?.nullclear?.requiredFields,
+        sha256Match: init?.nullclear?.sha256Match
+      }
+    };
+    const arbiterRes = await customFetch(`${arbiterUrl}/v1/clear`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(clearPayload)
+    });
+    const arbiterData = await arbiterRes.json();
+    if (arbiterRes.status === 200 && arbiterData.cleared) {
+      const resBody = typeof arbiterData.data === "string" ? arbiterData.data : JSON.stringify(arbiterData.data);
+      const resHeaders = new Headers();
+      resHeaders.set("Content-Type", "application/json");
+      const paymentResponseHdr = arbiterRes.headers.get("PAYMENT-RESPONSE");
+      if (paymentResponseHdr) resHeaders.set("PAYMENT-RESPONSE", paymentResponseHdr);
+      const attestationHdr = arbiterRes.headers.get("X-NullClear-Attestation");
+      if (attestationHdr) resHeaders.set("X-NullClear-Attestation", attestationHdr);
+      return new Response(resBody, {
+        status: 200,
+        headers: resHeaders
+      });
+    }
+    throw new NullClearEscrowAbortedError(
+      `NullClear Escrow Aborted: ${arbiterData.stage || "FAILED"} - ${arbiterData.reason || arbiterData.error || (arbiterData.validationErrors || []).join("; ")}`,
+      {
+        stage: arbiterData.stage || "UNKNOWN_FAILURE",
+        buyerCharged: arbiterData.buyerCharged || "0",
+        validationErrors: arbiterData.validationErrors || [],
+        score: arbiterData.score,
+        upstreamStatus: arbiterData.upstreamStatus,
+        reason: arbiterData.reason || arbiterData.error
+      }
+    );
+  };
+}
+export {
+  NullClearClient,
+  NullClearEscrowAbortedError,
+  createNullClearFetch,
+  signX402Payment,
+  zodToJsonSchema
+};

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@nullclear/x402-arbiter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "NullClear Developer and Agent SDK for safe x402 calls with deferred schema escrow",
+  "license": "MIT",
+  "homepage": "https://nullclear.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Nullclear-Protocol/nullclear.git"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@nullclear/shared": "1.0.0",
+    "viem": "^2.23.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@nullclear/worker-arbiter": "1.0.0",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "echo \"@nullclear/x402-arbiter clean\""
+  }
 }