@agenc/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,620 @@
+"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, {
+  DEVNET_RPC: () => DEVNET_RPC,
+  MAINNET_RPC: () => MAINNET_RPC,
+  PRIVACY_CASH_PROGRAM_ID: () => PRIVACY_CASH_PROGRAM_ID,
+  PROGRAM_ID: () => PROGRAM_ID,
+  PrivacyClient: () => PrivacyClient,
+  TaskState: () => TaskState,
+  VERIFIER_PROGRAM_ID: () => VERIFIER_PROGRAM_ID,
+  VERSION: () => VERSION,
+  claimTask: () => claimTask,
+  completeTask: () => completeTask,
+  completeTaskPrivate: () => completeTaskPrivate,
+  createTask: () => createTask,
+  generateProof: () => generateProof,
+  getTask: () => getTask,
+  verifyProofLocally: () => verifyProofLocally
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_web33 = require("@solana/web3.js");
+var import_anchor = require("@coral-xyz/anchor");
+
+// src/privacy.ts
+var import_web3 = require("@solana/web3.js");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var AgenCPrivacyClient = class {
+  connection;
+  program;
+  circuitPath;
+  privacyCash = null;
+  rpcUrl;
+  constructor(connection, program, circuitPath = "./circuits/task_completion", rpcUrl) {
+    this.connection = connection;
+    this.program = program;
+    this.circuitPath = circuitPath;
+    this.rpcUrl = rpcUrl || connection.rpcEndpoint;
+  }
+  /**
+   * Set Privacy Cash client instance
+   * Users should create their own Privacy Cash instance and pass it here
+   */
+  setPrivacyCash(privacyCash) {
+    this.privacyCash = privacyCash;
+    console.log("Privacy Cash client set for:", privacyCash.publicKey.toBase58());
+  }
+  /**
+   * Initialize Privacy Cash client for a specific wallet
+   * Requires privacycash package to be installed separately
+   */
+  async initPrivacyCash(owner) {
+    try {
+      const { PrivacyCash } = await import("privacycash");
+      this.privacyCash = new PrivacyCash({
+        RPC_url: this.rpcUrl,
+        owner,
+        enableDebug: true
+      });
+      console.log("Privacy Cash client initialized for:", owner.publicKey.toBase58());
+    } catch (error) {
+      console.warn("Privacy Cash SDK not available. Install with: npm install privacycash");
+      console.warn("Or use setPrivacyCash() to provide your own instance.");
+    }
+  }
+  /**
+   * Check if Privacy Cash is initialized
+   */
+  hasPrivacyCash() {
+    return this.privacyCash !== null;
+  }
+  /**
+   * Shield escrow funds into Privacy Cash pool
+   * Called by task creator when creating a private task
+   */
+  async shieldEscrow(creator, lamports) {
+    if (!this.privacyCash) {
+      await this.initPrivacyCash(creator);
+    }
+    if (!this.privacyCash) {
+      throw new Error("Privacy Cash not available. Install privacycash or use setPrivacyCash().");
+    }
+    console.log(`Shielding ${lamports / import_web3.LAMPORTS_PER_SOL} SOL into privacy pool...`);
+    const result = await this.privacyCash.deposit({ lamports });
+    console.log("Escrow shielded successfully");
+    return {
+      txSignature: result?.signature || result?.tx || "deposited",
+      shieldedAmount: lamports
+    };
+  }
+  /**
+   * Get shielded balance for current wallet
+   */
+  async getShieldedBalance() {
+    if (!this.privacyCash) {
+      throw new Error("Privacy Cash not initialized. Call initPrivacyCash first.");
+    }
+    return await this.privacyCash.getPrivateBalance();
+  }
+  /**
+   * Complete a task privately using ZK proofs and Privacy Cash withdrawal
+   *
+   * Flow:
+   * 1. Generate ZK proof that worker completed task correctly (Noir/Sunspot)
+   * 2. Submit proof on-chain for verification
+   * 3. Upon verification, withdraw shielded escrow to worker via Privacy Cash
+   */
+  async completeTaskPrivate(params, worker) {
+    const { taskId, output, salt, recipientWallet, escrowLamports } = params;
+    await this.initPrivacyCash(worker);
+    const task = await this.fetchTask(taskId);
+    const constraintHash = task.constraintHash;
+    const outputCommitment = await this.computeCommitment(output, salt);
+    console.log("Step 1/3: Generating ZK proof of task completion...");
+    const { zkProof, publicWitness } = await this.generateTaskCompletionProof({
+      taskId,
+      agentPubkey: worker.publicKey,
+      constraintHash,
+      outputCommitment,
+      output,
+      salt
+    });
+    console.log("ZK proof generated:", zkProof.length, "bytes");
+    console.log("Step 2/3: Submitting proof to on-chain verifier...");
+    const tx = await this.buildCompleteTaskPrivateTx({
+      taskId,
+      zkProof,
+      publicWitness,
+      worker: worker.publicKey
+    });
+    const proofTxSignature = await this.connection.sendTransaction(tx, [worker]);
+    await this.connection.confirmTransaction(proofTxSignature);
+    console.log("Proof verified on-chain:", proofTxSignature);
+    console.log("Step 3/3: Withdrawing shielded escrow via Privacy Cash...");
+    if (!this.privacyCash) {
+      throw new Error("Privacy Cash not initialized");
+    }
+    const withdrawResult = await this.privacyCash.withdraw({
+      lamports: escrowLamports,
+      recipientAddress: recipientWallet.toBase58()
+    });
+    console.log("Private payment completed!");
+    return {
+      proofTxSignature,
+      withdrawResult
+    };
+  }
+  /**
+   * Generate ZK proof for task completion using Noir/Sunspot
+   */
+  async generateTaskCompletionProof(params) {
+    const { taskId, agentPubkey, constraintHash, outputCommitment, output, salt } = params;
+    const proverToml = this.generateProverToml({
+      taskId,
+      agentPubkey: Array.from(agentPubkey.toBytes()),
+      constraintHash: "0x" + constraintHash.toString("hex"),
+      outputCommitment: "0x" + outputCommitment.toString(16),
+      output: output.map((o) => o.toString()),
+      salt: salt.toString()
+    });
+    const proverPath = path.join(this.circuitPath, "Prover.toml");
+    fs.writeFileSync(proverPath, proverToml);
+    (0, import_child_process.execSync)("nargo execute", { cwd: this.circuitPath });
+    (0, import_child_process.execSync)(
+      "sunspot prove target/task_completion.ccs target/task_completion.pk target/task_completion.gz -o target/task_completion.proof",
+      { cwd: this.circuitPath }
+    );
+    const zkProof = fs.readFileSync(
+      path.join(this.circuitPath, "target/task_completion.proof")
+    );
+    const publicWitness = fs.readFileSync(
+      path.join(this.circuitPath, "target/task_completion.pw")
+    );
+    return { zkProof, publicWitness };
+  }
+  /**
+   * Build the complete_task_private transaction
+   * This submits the ZK proof for on-chain verification
+   */
+  async buildCompleteTaskPrivateTx(params) {
+    const { taskId, zkProof, publicWitness, worker } = params;
+    if (!this.program) {
+      throw new Error("Program not initialized");
+    }
+    const [taskPda] = import_web3.PublicKey.findProgramAddressSync(
+      [Buffer.from("task"), Buffer.from(new Uint8Array(new BigUint64Array([BigInt(taskId)]).buffer))],
+      this.program.programId
+    );
+    const [claimPda] = import_web3.PublicKey.findProgramAddressSync(
+      [Buffer.from("claim"), taskPda.toBuffer(), worker.toBuffer()],
+      this.program.programId
+    );
+    const verifierProgramId = await this.getVerifierProgramId();
+    const ix = await this.program.methods.completeTaskPrivate(taskId, {
+      zkProof: Array.from(zkProof),
+      publicWitness: Array.from(publicWitness)
+    }).accounts({
+      worker,
+      task: taskPda,
+      taskClaim: claimPda,
+      zkVerifier: verifierProgramId,
+      systemProgram: import_web3.PublicKey.default
+    }).instruction();
+    const tx = new import_web3.Transaction().add(ix);
+    tx.feePayer = worker;
+    tx.recentBlockhash = (await this.connection.getLatestBlockhash()).blockhash;
+    return tx;
+  }
+  /**
+   * Compute Poseidon commitment for output
+   */
+  async computeCommitment(output, salt) {
+    console.log("Computing commitment...");
+    return BigInt(0);
+  }
+  /**
+   * Generate Prover.toml content
+   */
+  generateProverToml(params) {
+    return `# Auto-generated Prover.toml
+task_id = "${params.taskId}"
+agent_pubkey = [${params.agentPubkey.join(", ")}]
+constraint_hash = "${params.constraintHash}"
+output_commitment = "${params.outputCommitment}"
+output = [${params.output.map((o) => `"${o}"`).join(", ")}]
+salt = "${params.salt}"
+`;
+  }
+  async fetchTask(taskId) {
+    if (!this.program) {
+      throw new Error("Program not initialized");
+    }
+    const [taskPda] = import_web3.PublicKey.findProgramAddressSync(
+      [Buffer.from("task"), Buffer.from(new Uint8Array(new BigUint64Array([BigInt(taskId)]).buffer))],
+      this.program.programId
+    );
+    return await this.program.account.task.fetch(taskPda);
+  }
+  async getVerifierProgramId() {
+    return new import_web3.PublicKey("8fHUGmjNzSh76r78v1rPt7BhWmAu2gXrvW9A2XXonwQQ");
+  }
+};
+
+// src/constants.ts
+var import_web32 = require("@solana/web3.js");
+var PROGRAM_ID = new import_web32.PublicKey("EopUaCV2svxj9j4hd7KjbrWfdjkspmm2BCBe7jGpKzKZ");
+var VERIFIER_PROGRAM_ID = new import_web32.PublicKey("8fHUGmjNzSh76r78v1rPt7BhWmAu2gXrvW9A2XXonwQQ");
+var PRIVACY_CASH_PROGRAM_ID = new import_web32.PublicKey("9fhQBbumKEFuXtMBDw8AaQyAjCorLGJQiS3skWZdQyQD");
+var DEVNET_RPC = "https://api.devnet.solana.com";
+var MAINNET_RPC = "https://api.mainnet-beta.solana.com";
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2[TaskState2["Open"] = 0] = "Open";
+  TaskState2[TaskState2["Claimed"] = 1] = "Claimed";
+  TaskState2[TaskState2["Completed"] = 2] = "Completed";
+  TaskState2[TaskState2["Disputed"] = 3] = "Disputed";
+  TaskState2[TaskState2["Cancelled"] = 4] = "Cancelled";
+  return TaskState2;
+})(TaskState || {});
+var SEEDS = {
+  PROTOCOL: Buffer.from("protocol"),
+  TASK: Buffer.from("task"),
+  CLAIM: Buffer.from("claim"),
+  AGENT: Buffer.from("agent"),
+  ESCROW: Buffer.from("escrow")
+};
+
+// src/client.ts
+var PrivacyClient = class {
+  connection;
+  program = null;
+  privacyClient = null;
+  config;
+  wallet = null;
+  constructor(config = {}) {
+    this.config = {
+      devnet: false,
+      circuitPath: "./circuits/task_completion",
+      debug: false,
+      ...config
+    };
+    const rpcUrl = config.rpcUrl || (this.config.devnet ? DEVNET_RPC : MAINNET_RPC);
+    this.connection = new import_web33.Connection(rpcUrl, "confirmed");
+    if (config.wallet) {
+      this.wallet = config.wallet;
+    }
+    if (this.config.debug) {
+      console.log("PrivacyClient initialized");
+      console.log("  RPC:", rpcUrl);
+      console.log("  Circuit:", this.config.circuitPath);
+    }
+  }
+  /**
+   * Initialize the client with a wallet
+   */
+  async init(wallet) {
+    this.wallet = wallet;
+    const anchorWallet = new import_anchor.Wallet(wallet);
+    const provider = new import_anchor.AnchorProvider(
+      this.connection,
+      anchorWallet,
+      { commitment: "confirmed" }
+    );
+    if (this.config.debug) {
+      console.log("Wallet initialized:", wallet.publicKey.toBase58());
+    }
+    this.privacyClient = new AgenCPrivacyClient(
+      this.connection,
+      this.program,
+      this.config.circuitPath,
+      this.connection.rpcEndpoint
+    );
+    await this.privacyClient.initPrivacyCash(wallet);
+  }
+  /**
+   * Get connection instance
+   */
+  getConnection() {
+    return this.connection;
+  }
+  /**
+   * Get wallet public key
+   */
+  getPublicKey() {
+    return this.wallet?.publicKey || null;
+  }
+  /**
+   * Shield SOL into the privacy pool
+   */
+  async shield(lamports) {
+    if (!this.wallet || !this.privacyClient) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    const result = await this.privacyClient.shieldEscrow(this.wallet, lamports);
+    return {
+      txSignature: result.txSignature,
+      amount: result.shieldedAmount
+    };
+  }
+  /**
+   * Get shielded balance
+   */
+  async getShieldedBalance() {
+    if (!this.privacyClient) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    const { lamports } = await this.privacyClient.getShieldedBalance();
+    return lamports;
+  }
+  /**
+   * Complete a task privately with ZK proof
+   */
+  async completeTaskPrivate(params) {
+    if (!this.wallet || !this.privacyClient) {
+      throw new Error("Client not initialized. Call init() first.");
+    }
+    return await this.privacyClient.completeTaskPrivate(params, this.wallet);
+  }
+  /**
+   * Get the underlying AgenCPrivacyClient for advanced operations
+   */
+  getPrivacyClient() {
+    return this.privacyClient;
+  }
+  /**
+   * Format lamports as SOL string
+   */
+  static formatSol(lamports) {
+    return (lamports / import_web33.LAMPORTS_PER_SOL).toFixed(9) + " SOL";
+  }
+  /**
+   * Parse SOL string to lamports
+   */
+  static parseSol(sol) {
+    const value = typeof sol === "string" ? parseFloat(sol) : sol;
+    return Math.floor(value * import_web33.LAMPORTS_PER_SOL);
+  }
+};
+
+// src/proofs.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+async function generateProof(params) {
+  const circuitPath = params.circuitPath || "./circuits/task_completion";
+  const startTime = Date.now();
+  const proverToml = generateProverToml(params);
+  const proverPath = path2.join(circuitPath, "Prover.toml");
+  fs2.writeFileSync(proverPath, proverToml);
+  try {
+    (0, import_child_process2.execSync)("nargo execute", {
+      cwd: circuitPath,
+      stdio: "pipe"
+    });
+    (0, import_child_process2.execSync)(
+      "sunspot prove target/task_completion.ccs target/task_completion.pk target/task_completion.gz -o target/task_completion.proof",
+      {
+        cwd: circuitPath,
+        stdio: "pipe"
+      }
+    );
+    const proof = fs2.readFileSync(path2.join(circuitPath, "target/task_completion.proof"));
+    const publicWitness = fs2.readFileSync(path2.join(circuitPath, "target/task_completion.pw"));
+    const generationTime = Date.now() - startTime;
+    return {
+      proof,
+      publicWitness,
+      proofSize: proof.length,
+      generationTime
+    };
+  } catch (error) {
+    throw new Error(`Proof generation failed: ${error.message}`);
+  }
+}
+async function verifyProofLocally(proof, publicWitness, circuitPath = "./circuits/task_completion") {
+  const proofPath = path2.join(circuitPath, "target/verify_test.proof");
+  const witnessPath = path2.join(circuitPath, "target/verify_test.pw");
+  fs2.writeFileSync(proofPath, proof);
+  fs2.writeFileSync(witnessPath, publicWitness);
+  try {
+    (0, import_child_process2.execSync)(
+      `sunspot verify target/task_completion.ccs target/task_completion.vk ${proofPath} ${witnessPath}`,
+      {
+        cwd: circuitPath,
+        stdio: "pipe"
+      }
+    );
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fs2.unlinkSync(proofPath);
+      fs2.unlinkSync(witnessPath);
+    } catch {
+    }
+  }
+}
+function generateProverToml(params) {
+  const agentBytes = Array.from(params.agentPubkey.toBytes());
+  return `# Auto-generated Prover.toml for AgenC task completion proof
+task_id = "${params.taskId}"
+agent_pubkey = [${agentBytes.join(", ")}]
+constraint_hash = "0x${params.constraintHash.toString("hex")}"
+output_commitment = "0x${params.outputCommitment.toString(16)}"
+output = [${params.output.map((o) => `"${o.toString()}"`).join(", ")}]
+salt = "${params.salt.toString()}"
+`;
+}
+
+// src/tasks.ts
+var import_web34 = require("@solana/web3.js");
+var import_anchor2 = require("@coral-xyz/anchor");
+function deriveTaskPda(taskId, programId = PROGRAM_ID) {
+  const taskIdBuffer = Buffer.alloc(8);
+  taskIdBuffer.writeBigUInt64LE(BigInt(taskId));
+  const [pda] = import_web34.PublicKey.findProgramAddressSync(
+    [SEEDS.TASK, taskIdBuffer],
+    programId
+  );
+  return pda;
+}
+function deriveClaimPda(taskPda, agent, programId = PROGRAM_ID) {
+  const [pda] = import_web34.PublicKey.findProgramAddressSync(
+    [SEEDS.CLAIM, taskPda.toBuffer(), agent.toBuffer()],
+    programId
+  );
+  return pda;
+}
+function deriveEscrowPda(taskPda, programId = PROGRAM_ID) {
+  const [pda] = import_web34.PublicKey.findProgramAddressSync(
+    [SEEDS.ESCROW, taskPda.toBuffer()],
+    programId
+  );
+  return pda;
+}
+async function createTask(connection, program, creator, params) {
+  const [protocolPda] = import_web34.PublicKey.findProgramAddressSync(
+    [SEEDS.PROTOCOL],
+    program.programId
+  );
+  const protocolState = await program.account.protocolState.fetch(protocolPda);
+  const taskId = protocolState.nextTaskId?.toNumber() || 0;
+  const taskPda = deriveTaskPda(taskId, program.programId);
+  const escrowPda = deriveEscrowPda(taskPda, program.programId);
+  const tx = await program.methods.createTask({
+    description: params.description,
+    escrowLamports: new import_anchor2.BN(params.escrowLamports),
+    deadline: new import_anchor2.BN(params.deadline),
+    constraintHash: params.constraintHash ? Array.from(params.constraintHash) : null,
+    requiredSkills: params.requiredSkills || [],
+    maxClaims: params.maxClaims || 1
+  }).accounts({
+    creator: creator.publicKey,
+    task: taskPda,
+    escrow: escrowPda,
+    protocolState: protocolPda,
+    systemProgram: import_web34.SystemProgram.programId
+  }).signers([creator]).rpc();
+  return { taskId, txSignature: tx };
+}
+async function claimTask(connection, program, agent, taskId) {
+  const taskPda = deriveTaskPda(taskId, program.programId);
+  const claimPda = deriveClaimPda(taskPda, agent.publicKey, program.programId);
+  const [agentPda] = import_web34.PublicKey.findProgramAddressSync(
+    [SEEDS.AGENT, agent.publicKey.toBuffer()],
+    program.programId
+  );
+  const tx = await program.methods.claimTask(taskId).accounts({
+    agent: agent.publicKey,
+    agentAccount: agentPda,
+    task: taskPda,
+    taskClaim: claimPda,
+    systemProgram: import_web34.SystemProgram.programId
+  }).signers([agent]).rpc();
+  return { txSignature: tx };
+}
+async function completeTask(connection, program, worker, taskId, resultHash) {
+  const taskPda = deriveTaskPda(taskId, program.programId);
+  const claimPda = deriveClaimPda(taskPda, worker.publicKey, program.programId);
+  const escrowPda = deriveEscrowPda(taskPda, program.programId);
+  const task = await program.account.task.fetch(taskPda);
+  const tx = await program.methods.completeTask({
+    resultHash: Array.from(resultHash)
+  }).accounts({
+    worker: worker.publicKey,
+    task: taskPda,
+    taskClaim: claimPda,
+    escrow: escrowPda,
+    creator: task.creator,
+    systemProgram: import_web34.SystemProgram.programId
+  }).signers([worker]).rpc();
+  return { txSignature: tx };
+}
+async function completeTaskPrivate(connection, program, worker, taskId, zkProof, publicWitness, verifierProgramId) {
+  const taskPda = deriveTaskPda(taskId, program.programId);
+  const claimPda = deriveClaimPda(taskPda, worker.publicKey, program.programId);
+  const tx = await program.methods.completeTaskPrivate(taskId, {
+    zkProof: Array.from(zkProof),
+    publicWitness: Array.from(publicWitness)
+  }).accounts({
+    worker: worker.publicKey,
+    task: taskPda,
+    taskClaim: claimPda,
+    zkVerifier: verifierProgramId,
+    systemProgram: import_web34.SystemProgram.programId
+  }).signers([worker]).rpc();
+  return { txSignature: tx };
+}
+async function getTask(connection, program, taskId) {
+  const taskPda = deriveTaskPda(taskId, program.programId);
+  try {
+    const task = await program.account.task.fetch(taskPda);
+    const taskData = task;
+    return {
+      taskId,
+      state: taskData.state,
+      creator: taskData.creator,
+      escrowLamports: taskData.escrowLamports?.toNumber() || 0,
+      deadline: taskData.deadline?.toNumber() || 0,
+      constraintHash: taskData.constraintHash ? Buffer.from(taskData.constraintHash) : null,
+      claimedBy: taskData.claimedBy || null,
+      completedAt: taskData.completedAt?.toNumber() || null
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEVNET_RPC,
+  MAINNET_RPC,
+  PRIVACY_CASH_PROGRAM_ID,
+  PROGRAM_ID,
+  PrivacyClient,
+  TaskState,
+  VERIFIER_PROGRAM_ID,
+  VERSION,
+  claimTask,
+  completeTask,
+  completeTaskPrivate,
+  createTask,
+  generateProof,
+  getTask,
+  verifyProofLocally
+});