@zkclaw/sdk 1.0.0 → 2.0.0

package/dist/chunk-L5QERYJQ.mjs

@@ -0,0 +1,350 @@
+// src/client.ts
+import {
+  createPublicClient,
+  http,
+  formatUnits,
+  hashMessage
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { base } from "viem/chains";
+var DEFAULT_TOKEN_ADDRESS = "0x000000000000000000000000000000000000dead";
+var DEFAULT_POST_THRESHOLD = BigInt("5000") * BigInt(10 ** 18);
+var DEFAULT_PROMOTE_THRESHOLD = BigInt("2000000") * BigInt(10 ** 18);
+var cachedConfig = null;
+var configFetchPromise = null;
+var ERC20_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var ZKClaw = class {
+  constructor(config) {
+    this.config = null;
+    if (!config.privateKey && !config.account && !config.signer) {
+      throw new Error(
+        "ZKClaw requires one of: privateKey, account, or signer"
+      );
+    }
+    if (config.signer) {
+      this.signer = config.signer;
+    } else if (config.account) {
+      const account = config.account;
+      this.signer = {
+        getAddress: () => account.address,
+        signMessage: async (message) => {
+          if ("signMessage" in account && typeof account.signMessage === "function") {
+            return account.signMessage({ message });
+          }
+          throw new Error("Account does not support signMessage");
+        }
+      };
+    } else if (config.privateKey) {
+      const account = privateKeyToAccount(config.privateKey);
+      this.signer = {
+        getAddress: () => account.address,
+        signMessage: (message) => account.signMessage({ message })
+      };
+    } else {
+      throw new Error("Invalid configuration");
+    }
+    this.apiUrl = config.apiUrl || "https://zkclaw.com";
+    const rpcUrl = config.rpcUrl || process.env.BASE_RPC_URL || "https://mainnet.base.org";
+    this.publicClient = createPublicClient({
+      chain: base,
+      transport: http(rpcUrl)
+    });
+    this.fetchConfig().catch(() => {
+    });
+  }
+  /**
+   * Fetch remote config from API (cached)
+   */
+  async fetchConfig() {
+    if (this.config) return this.config;
+    if (cachedConfig) {
+      this.config = cachedConfig;
+      return cachedConfig;
+    }
+    if (configFetchPromise) {
+      const config = await configFetchPromise;
+      this.config = config;
+      return config;
+    }
+    configFetchPromise = (async () => {
+      try {
+        const response = await fetch(`${this.apiUrl}/api/config`);
+        if (!response.ok) throw new Error("Failed to fetch config");
+        const config = await response.json();
+        cachedConfig = config;
+        this.config = config;
+        return config;
+      } catch {
+        const defaultConfig = {
+          token: {
+            address: DEFAULT_TOKEN_ADDRESS,
+            chainId: 8453,
+            decimals: 18,
+            symbol: "ZKCLAW"
+          },
+          thresholds: {
+            post: 5e3,
+            promote: 2e6
+          },
+          limits: {
+            maxPostLength: 320,
+            maxImages: { farcaster: 2, twitter: 4 }
+          },
+          links: {
+            buy: `https://app.uniswap.org/swap?outputCurrency=${DEFAULT_TOKEN_ADDRESS}&chain=base`,
+            farcaster: "https://farcaster.xyz/zkclaw",
+            twitter: "https://x.com/zkclawcom"
+          }
+        };
+        this.config = defaultConfig;
+        return defaultConfig;
+      } finally {
+        configFetchPromise = null;
+      }
+    })();
+    return configFetchPromise;
+  }
+  /**
+   * Get current config (fetches if not cached)
+   */
+  async getConfig() {
+    return this.fetchConfig();
+  }
+  /**
+   * Get the wallet address
+   */
+  getAddress() {
+    const address = this.signer.getAddress();
+    if (typeof address === "string") return address;
+    throw new Error("getAddress returned a promise, use getAddressAsync instead");
+  }
+  /**
+   * Get the wallet address (async version)
+   */
+  async getAddressAsync() {
+    return this.signer.getAddress();
+  }
+  /**
+   * Generate a ZK proof locally
+   * Proof generation happens in your Node.js environment using WASM
+   */
+  async generateProofLocally() {
+    const { AnonBalanceVerifier, BALANCE_THRESHOLDS } = await import("@anon/credentials");
+    const address = await this.signer.getAddress();
+    const message = `Verify $ZKCLAW balance for anonymous posting
+
+Timestamp: ${Date.now()}`;
+    const signature = await this.signer.signMessage(message);
+    const messageHash = hashMessage(message);
+    const verifier = new AnonBalanceVerifier();
+    const { input } = await verifier.buildInput(address, BALANCE_THRESHOLDS.POST);
+    const actualBalance = input.storageProof[0].value;
+    if (actualBalance < BALANCE_THRESHOLDS.POST) {
+      const config = await this.fetchConfig();
+      throw new Error(
+        `Insufficient $ZKCLAW balance. Required: ${config.thresholds.post.toLocaleString()}, got: ${Number(formatUnits(actualBalance, 18)).toLocaleString()}. Buy at: ${config.links.buy}`
+      );
+    }
+    const threshold = actualBalance >= BALANCE_THRESHOLDS.PROMOTE ? BALANCE_THRESHOLDS.PROMOTE : BALANCE_THRESHOLDS.POST;
+    const { input: finalInput } = await verifier.buildInput(address, threshold);
+    const proofResult = await verifier.generateProof({
+      ...finalInput,
+      signature,
+      messageHash
+    });
+    return {
+      proof: {
+        proof: Array.from(proofResult.proof),
+        publicInputs: proofResult.publicInputs
+      },
+      balance: actualBalance
+    };
+  }
+  /**
+   * Post anonymously to Farcaster (and Twitter if you have 2M+ tokens)
+   *
+   * @param text - The text content of your post (max 320 characters)
+   * @param options - Optional images and embeds
+   * @returns Post result with URLs to the published content
+   *
+   * @example
+   * ```typescript
+   * // Simple post
+   * await bot.post('Hello world!')
+   *
+   * // Post with image
+   * await bot.post('Check this out', {
+   *   images: ['https://example.com/image.png']
+   * })
+   *
+   * // Post with embed
+   * await bot.post('Great thread', {
+   *   embeds: ['https://farcaster.xyz/user/0x123']
+   * })
+   * ```
+   */
+  async post(text, options) {
+    const config = await this.fetchConfig();
+    if (!text || text.trim().length === 0) {
+      return {
+        success: false,
+        error: "Text is required"
+      };
+    }
+    if (text.length > config.limits.maxPostLength) {
+      return {
+        success: false,
+        error: `Text exceeds ${config.limits.maxPostLength} character limit (got ${text.length})`
+      };
+    }
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      const canPromote = balance >= promoteThreshold;
+      const body = {
+        proof,
+        text: text.trim(),
+        platforms: {
+          farcaster: true,
+          twitter: canPromote
+          // Auto-enable Twitter if user has enough balance
+        }
+      };
+      if (options?.images && options.images.length > 0) {
+        body.images = options.images;
+      }
+      if (options?.embeds && options.embeds.length > 0) {
+        body.embeds = options.embeds;
+      }
+      const response = await fetch(`${this.apiUrl}/api/post`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          error: errorData.error || `HTTP error: ${response.status}`
+        };
+      }
+      const result = await response.json();
+      return result;
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to generate proof or post"
+      };
+    }
+  }
+  /**
+   * Check your $ZKCLAW token balance
+   *
+   * @returns Balance information including whether you can post/promote
+   *
+   * @example
+   * ```typescript
+   * const balance = await bot.getBalance()
+   * console.log(balance.formatted) // "5,000"
+   * console.log(balance.canPost)   // true
+   * console.log(balance.canPromote) // false
+   * ```
+   */
+  async getBalance() {
+    const config = await this.fetchConfig();
+    const address = await this.signer.getAddress();
+    const balance = await this.publicClient.readContract({
+      address: config.token.address,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [address]
+    });
+    const balanceBigInt = balance;
+    const formatted = Number(formatUnits(balanceBigInt, config.token.decimals)).toLocaleString();
+    const postThreshold = BigInt(config.thresholds.post) * BigInt(10 ** config.token.decimals);
+    const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+    const canPost = balanceBigInt >= postThreshold;
+    const canPromote = balanceBigInt >= promoteThreshold;
+    let tier = "none";
+    if (canPromote) tier = "promote";
+    else if (canPost) tier = "post";
+    return {
+      balance: balanceBigInt.toString(),
+      formatted,
+      canPost,
+      canPromote,
+      tier
+    };
+  }
+  /**
+   * Generate a ZK proof without posting
+   *
+   * Useful for testing or caching proofs
+   *
+   * @returns Proof data that can be reused
+   */
+  async generateProof() {
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const config = await this.fetchConfig();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      return {
+        success: true,
+        proof,
+        balance: balance.toString(),
+        tier: balance >= promoteThreshold ? "promote" : "post"
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Failed to generate proof"
+      };
+    }
+  }
+  /**
+   * Get the Uniswap link to buy $ZKCLAW tokens
+   */
+  async getBuyLink() {
+    const config = await this.fetchConfig();
+    return config.links.buy;
+  }
+  /**
+   * Get the Uniswap link to buy $ZKCLAW tokens (sync version with fallback)
+   */
+  getBuyLinkSync() {
+    const tokenAddress = this.config?.token.address || DEFAULT_TOKEN_ADDRESS;
+    return `https://app.uniswap.org/swap?outputCurrency=${tokenAddress}&chain=base`;
+  }
+  /**
+   * Get token requirements
+   */
+  async getRequirements() {
+    const config = await this.fetchConfig();
+    return {
+      post: `${config.thresholds.post.toLocaleString()} $ZKCLAW`,
+      promote: `${config.thresholds.promote.toLocaleString()} $ZKCLAW`
+    };
+  }
+  /**
+   * Get token requirements (sync version with defaults)
+   */
+  getRequirementsSync() {
+    const config = this.config;
+    return {
+      post: `${(config?.thresholds.post || 5e3).toLocaleString()} $ZKCLAW`,
+      promote: `${(config?.thresholds.promote || 2e6).toLocaleString()} $ZKCLAW`
+    };
+  }
+};
+
+export {
+  ZKClaw
+};

package/dist/cli.js

@@ -1,5 +1,27 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/client.ts
 var import_viem = require("viem");
@@ -50,7 +72,7 @@ var ZKClaw = class {
       throw new Error("Invalid configuration");
     }
     this.apiUrl = config.apiUrl || "https://zkclaw.com";
-    const rpcUrl = config.rpcUrl || process.env.BASE_RPC_URL || void 0;
+    const rpcUrl = config.rpcUrl || process.env.BASE_RPC_URL || "https://mainnet.base.org";
     this.publicClient = (0, import_viem.createPublicClient)({
       chain: import_chains.base,
       transport: (0, import_viem.http)(rpcUrl)
@@ -130,6 +152,42 @@ var ZKClaw = class {
   async getAddressAsync() {
     return this.signer.getAddress();
   }
+  /**
+   * Generate a ZK proof locally
+   * Proof generation happens in your Node.js environment using WASM
+   */
+  async generateProofLocally() {
+    const { AnonBalanceVerifier, BALANCE_THRESHOLDS } = await import("@anon/credentials");
+    const address = await this.signer.getAddress();
+    const message = `Verify $ZKCLAW balance for anonymous posting
+
+Timestamp: ${Date.now()}`;
+    const signature = await this.signer.signMessage(message);
+    const messageHash = (0, import_viem.hashMessage)(message);
+    const verifier = new AnonBalanceVerifier();
+    const { input } = await verifier.buildInput(address, BALANCE_THRESHOLDS.POST);
+    const actualBalance = input.storageProof[0].value;
+    if (actualBalance < BALANCE_THRESHOLDS.POST) {
+      const config = await this.fetchConfig();
+      throw new Error(
+        `Insufficient $ZKCLAW balance. Required: ${config.thresholds.post.toLocaleString()}, got: ${Number((0, import_viem.formatUnits)(actualBalance, 18)).toLocaleString()}. Buy at: ${config.links.buy}`
+      );
+    }
+    const threshold = actualBalance >= BALANCE_THRESHOLDS.PROMOTE ? BALANCE_THRESHOLDS.PROMOTE : BALANCE_THRESHOLDS.POST;
+    const { input: finalInput } = await verifier.buildInput(address, threshold);
+    const proofResult = await verifier.generateProof({
+      ...finalInput,
+      signature,
+      messageHash
+    });
+    return {
+      proof: {
+        proof: Array.from(proofResult.proof),
+        publicInputs: proofResult.publicInputs
+      },
+      balance: actualBalance
+    };
+  }
   /**
    * Post anonymously to Farcaster (and Twitter if you have 2M+ tokens)
    *
@@ -167,38 +225,45 @@ var ZKClaw = class {
         error: `Text exceeds ${config.limits.maxPostLength} character limit (got ${text.length})`
       };
     }
-    const address = await this.signer.getAddress();
-    const timestamp = Date.now();
-    const message = `Verify $ZKCLAW balance for anonymous posting
-
-Timestamp: ${timestamp}`;
-    const signature = await this.signer.signMessage(message);
-    const body = {
-      address,
-      signature,
-      message,
-      text: text.trim()
-    };
-    if (options?.images && options.images.length > 0) {
-      body.images = options.images;
-    }
-    if (options?.embeds && options.embeds.length > 0) {
-      body.embeds = options.embeds;
-    }
-    const response = await fetch(`${this.apiUrl}/api/agent/post`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      const canPromote = balance >= promoteThreshold;
+      const body = {
+        proof,
+        text: text.trim(),
+        platforms: {
+          farcaster: true,
+          twitter: canPromote
+          // Auto-enable Twitter if user has enough balance
+        }
+      };
+      if (options?.images && options.images.length > 0) {
+        body.images = options.images;
+      }
+      if (options?.embeds && options.embeds.length > 0) {
+        body.embeds = options.embeds;
+      }
+      const response = await fetch(`${this.apiUrl}/api/post`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          error: errorData.error || `HTTP error: ${response.status}`
+        };
+      }
+      const result = await response.json();
+      return result;
+    } catch (err) {
       return {
         success: false,
-        error: errorData.error || `HTTP error: ${response.status}`
+        error: err instanceof Error ? err.message : "Failed to generate proof or post"
       };
     }
-    const result = await response.json();
-    return result;
   }
   /**
    * Check your $ZKCLAW token balance
@@ -242,31 +307,27 @@ Timestamp: ${timestamp}`;
   /**
    * Generate a ZK proof without posting
    *
-   * Useful for caching proofs (valid for ~2 days)
+   * Useful for testing or caching proofs
    *
    * @returns Proof data that can be reused
    */
   async generateProof() {
-    const address = await this.signer.getAddress();
-    const timestamp = Date.now();
-    const message = `Verify $ZKCLAW balance for anonymous posting
-
-Timestamp: ${timestamp}`;
-    const signature = await this.signer.signMessage(message);
-    const response = await fetch(`${this.apiUrl}/api/agent/prove`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ address, signature, message })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const config = await this.fetchConfig();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      return {
+        success: true,
+        proof,
+        balance: balance.toString(),
+        tier: balance >= promoteThreshold ? "promote" : "post"
+      };
+    } catch (err) {
       return {
         success: false,
-        error: errorData.error || `HTTP error: ${response.status}`
+        error: err instanceof Error ? err.message : "Failed to generate proof"
       };
     }
-    const result = await response.json();
-    return result;
   }
   /**
    * Get the Uniswap link to buy $ZKCLAW tokens

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ZKClaw
-} from "./chunk-E4ECHE77.mjs";
+} from "./chunk-L5QERYJQ.mjs";
 
 // src/cli.ts
 var HELP = `

package/dist/index.d.mts

@@ -124,6 +124,7 @@ type ZKClawRemoteConfig = {
  * ZKClaw SDK Client
  *
  * Post anonymously to Farcaster and Twitter using ZK proofs.
+ * Proof generation happens locally in your Node.js environment.
  *
  * @example
  * ```typescript
@@ -159,6 +160,11 @@ declare class ZKClaw {
      * Get the wallet address (async version)
      */
     getAddressAsync(): Promise<string>;
+    /**
+     * Generate a ZK proof locally
+     * Proof generation happens in your Node.js environment using WASM
+     */
+    private generateProofLocally;
     /**
      * Post anonymously to Farcaster (and Twitter if you have 2M+ tokens)
      *
@@ -200,7 +206,7 @@ declare class ZKClaw {
     /**
      * Generate a ZK proof without posting
      *
-     * Useful for caching proofs (valid for ~2 days)
+     * Useful for testing or caching proofs
      *
      * @returns Proof data that can be reused
      */

package/dist/index.d.ts

@@ -124,6 +124,7 @@ type ZKClawRemoteConfig = {
  * ZKClaw SDK Client
  *
  * Post anonymously to Farcaster and Twitter using ZK proofs.
+ * Proof generation happens locally in your Node.js environment.
  *
  * @example
  * ```typescript
@@ -159,6 +160,11 @@ declare class ZKClaw {
      * Get the wallet address (async version)
      */
     getAddressAsync(): Promise<string>;
+    /**
+     * Generate a ZK proof locally
+     * Proof generation happens in your Node.js environment using WASM
+     */
+    private generateProofLocally;
     /**
      * Post anonymously to Farcaster (and Twitter if you have 2M+ tokens)
      *
@@ -200,7 +206,7 @@ declare class ZKClaw {
     /**
      * Generate a ZK proof without posting
      *
-     * Useful for caching proofs (valid for ~2 days)
+     * Useful for testing or caching proofs
      *
      * @returns Proof data that can be reused
      */

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -73,7 +83,7 @@ var ZKClaw = class {
       throw new Error("Invalid configuration");
     }
     this.apiUrl = config.apiUrl || "https://zkclaw.com";
-    const rpcUrl = config.rpcUrl || process.env.BASE_RPC_URL || void 0;
+    const rpcUrl = config.rpcUrl || process.env.BASE_RPC_URL || "https://mainnet.base.org";
     this.publicClient = (0, import_viem.createPublicClient)({
       chain: import_chains.base,
       transport: (0, import_viem.http)(rpcUrl)
@@ -153,6 +163,42 @@ var ZKClaw = class {
   async getAddressAsync() {
     return this.signer.getAddress();
   }
+  /**
+   * Generate a ZK proof locally
+   * Proof generation happens in your Node.js environment using WASM
+   */
+  async generateProofLocally() {
+    const { AnonBalanceVerifier, BALANCE_THRESHOLDS } = await import("@anon/credentials");
+    const address = await this.signer.getAddress();
+    const message = `Verify $ZKCLAW balance for anonymous posting
+
+Timestamp: ${Date.now()}`;
+    const signature = await this.signer.signMessage(message);
+    const messageHash = (0, import_viem.hashMessage)(message);
+    const verifier = new AnonBalanceVerifier();
+    const { input } = await verifier.buildInput(address, BALANCE_THRESHOLDS.POST);
+    const actualBalance = input.storageProof[0].value;
+    if (actualBalance < BALANCE_THRESHOLDS.POST) {
+      const config = await this.fetchConfig();
+      throw new Error(
+        `Insufficient $ZKCLAW balance. Required: ${config.thresholds.post.toLocaleString()}, got: ${Number((0, import_viem.formatUnits)(actualBalance, 18)).toLocaleString()}. Buy at: ${config.links.buy}`
+      );
+    }
+    const threshold = actualBalance >= BALANCE_THRESHOLDS.PROMOTE ? BALANCE_THRESHOLDS.PROMOTE : BALANCE_THRESHOLDS.POST;
+    const { input: finalInput } = await verifier.buildInput(address, threshold);
+    const proofResult = await verifier.generateProof({
+      ...finalInput,
+      signature,
+      messageHash
+    });
+    return {
+      proof: {
+        proof: Array.from(proofResult.proof),
+        publicInputs: proofResult.publicInputs
+      },
+      balance: actualBalance
+    };
+  }
   /**
    * Post anonymously to Farcaster (and Twitter if you have 2M+ tokens)
    *
@@ -190,38 +236,45 @@ var ZKClaw = class {
         error: `Text exceeds ${config.limits.maxPostLength} character limit (got ${text.length})`
       };
     }
-    const address = await this.signer.getAddress();
-    const timestamp = Date.now();
-    const message = `Verify $ZKCLAW balance for anonymous posting
-
-Timestamp: ${timestamp}`;
-    const signature = await this.signer.signMessage(message);
-    const body = {
-      address,
-      signature,
-      message,
-      text: text.trim()
-    };
-    if (options?.images && options.images.length > 0) {
-      body.images = options.images;
-    }
-    if (options?.embeds && options.embeds.length > 0) {
-      body.embeds = options.embeds;
-    }
-    const response = await fetch(`${this.apiUrl}/api/agent/post`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      const canPromote = balance >= promoteThreshold;
+      const body = {
+        proof,
+        text: text.trim(),
+        platforms: {
+          farcaster: true,
+          twitter: canPromote
+          // Auto-enable Twitter if user has enough balance
+        }
+      };
+      if (options?.images && options.images.length > 0) {
+        body.images = options.images;
+      }
+      if (options?.embeds && options.embeds.length > 0) {
+        body.embeds = options.embeds;
+      }
+      const response = await fetch(`${this.apiUrl}/api/post`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          error: errorData.error || `HTTP error: ${response.status}`
+        };
+      }
+      const result = await response.json();
+      return result;
+    } catch (err) {
       return {
         success: false,
-        error: errorData.error || `HTTP error: ${response.status}`
+        error: err instanceof Error ? err.message : "Failed to generate proof or post"
       };
     }
-    const result = await response.json();
-    return result;
   }
   /**
    * Check your $ZKCLAW token balance
@@ -265,31 +318,27 @@ Timestamp: ${timestamp}`;
   /**
    * Generate a ZK proof without posting
    *
-   * Useful for caching proofs (valid for ~2 days)
+   * Useful for testing or caching proofs
    *
    * @returns Proof data that can be reused
    */
   async generateProof() {
-    const address = await this.signer.getAddress();
-    const timestamp = Date.now();
-    const message = `Verify $ZKCLAW balance for anonymous posting
-
-Timestamp: ${timestamp}`;
-    const signature = await this.signer.signMessage(message);
-    const response = await fetch(`${this.apiUrl}/api/agent/prove`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ address, signature, message })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
+    try {
+      const { proof, balance } = await this.generateProofLocally();
+      const config = await this.fetchConfig();
+      const promoteThreshold = BigInt(config.thresholds.promote) * BigInt(10 ** config.token.decimals);
+      return {
+        success: true,
+        proof,
+        balance: balance.toString(),
+        tier: balance >= promoteThreshold ? "promote" : "post"
+      };
+    } catch (err) {
       return {
         success: false,
-        error: errorData.error || `HTTP error: ${response.status}`
+        error: err instanceof Error ? err.message : "Failed to generate proof"
       };
     }
-    const result = await response.json();
-    return result;
   }
   /**
    * Get the Uniswap link to buy $ZKCLAW tokens

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import {
   ZKClaw
-} from "./chunk-E4ECHE77.mjs";
+} from "./chunk-L5QERYJQ.mjs";
 export {
   ZKClaw
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkclaw/sdk",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "SDK for AI agents to post anonymously on Farcaster and X using ZK proofs",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -45,6 +45,7 @@
     "url": "https://zkclaw.com"
   },
   "dependencies": {
+    "@anon/credentials": "workspace:*",
     "viem": "^2.21.55"
   },
   "devDependencies": {