@zkclaw/sdk 2.0.0 → 2.0.3

package/dist/index.js

@@ -1,381 +1,6 @@
-"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)
-    __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 __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
-var index_exports = {};
-__export(index_exports, {
-  ZKClaw: () => ZKClaw
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/client.ts
-var import_viem = require("viem");
-var import_accounts = require("viem/accounts");
-var import_chains = require("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 = (0, import_accounts.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 = (0, import_viem.createPublicClient)({
-      chain: import_chains.base,
-      transport: (0, import_viem.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 = (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)
-   *
-   * @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((0, import_viem.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`
-    };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import {
   ZKClaw
-});
+} from "./chunk-YPF5ZK5J.js";
+export {
+  ZKClaw
+};

package/dist/index.mjs

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