@blindmarket/sdk 0.1.8 → 0.5.0

package/dist/executor/WorkerRuntime.d.ts

@@ -1,3 +1,4 @@
+import { BlindMarket } from '../index.js';
 import type { A2ATaskState, AgentCapability, ExecutorProfile, Message } from '../types.js';
 export interface WorkerRuntimeConfig {
     apiKey: string;
@@ -13,6 +14,12 @@ export interface WorkerRuntimeConfig {
     browseIntervalMs?: number;
     watchIntervalMs?: number;
     maxConcurrentTasks?: number;
+    /**
+     * RPC URL used to sign + broadcast `submitEvidence` after `submitResult()`.
+     * Defaults to the 0G testnet RPC (matches `backend/agents/worker.js`'s
+     * default). Point this at the RPC for whichever chain your tasks settle on.
+     */
+    rpcUrl?: string;
 }
 export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
 export interface TaskContext {
@@ -61,6 +68,10 @@ export type WorkerRuntimeEvent = {
     type: 'task_submitted';
     taskId: string;
     result: Record<string, unknown>;
+} | {
+    type: 'task_finalized';
+    taskId: string;
+    finalize: Awaited<ReturnType<BlindMarket['finalize']>>;
 } | {
     type: 'task_failed';
     taskId: string;
@@ -108,6 +119,16 @@ export declare class WorkerRuntime {
     private browse;
     private watchForAssignment;
     private executeTask;
+    /**
+     * Decode a wrapped-key hex string — acceptTask()'s wrappedKey field is a
+     * single hex string (this executor's ECIES-wrapped AES key), not a
+     * Record. The old code here called `Object.values` on that STRING
+     * argument (treating it as if it were a Record), which returned its
+     * first CHARACTER (e.g. "0" from "04a1b2…") — `clean.length / 2` was
+     * then 0 and every decrypt got an empty key.
+     */
     private decodeWrappedKey;
     private hexToBytes;
+    /** Decode a base64 string (e.g. downloadBlob()'s `blob` field) into bytes. */
+    private base64ToBytes;
 }

package/dist/executor/WorkerRuntime.js

@@ -1,3 +1,4 @@
+import { ethers } from 'ethers';
 import { BlindMarket } from '../index.js';
 import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
 // ── Defaults ────────────────────────────────────────────────────────────────
@@ -5,6 +6,7 @@ const DEFAULTS = {
     browseIntervalMs: 15_000,
     watchIntervalMs: 5_000,
     maxConcurrentTasks: 3,
+    rpcUrl: 'https://evmrpc-testnet.0g.ai',
 };
 // ── WorkerRuntime ───────────────────────────────────────────────────────────
 export class WorkerRuntime {
@@ -184,39 +186,61 @@ export class WorkerRuntime {
             return;
         try {
             exec.status = 'assigned';
-            // Accept task — get the ECIES-wrapped AES key
+            // Accept task — get the rootHash + this executor's ECIES-wrapped AES
+            // key. wrappedKey is a single hex string (this caller's slice), not a
+            // Record — see acceptTask()'s doc comment in ../index.ts.
             const acceptResult = await this.bb.acceptTask(taskId);
-            exec.task = acceptResult.task;
+            exec.task = a2a;
             this.emit({ type: 'task_accepted', taskId });
-            // Get full task detail for the storage root hash
-            const detail = await this.bb.getTask(taskId);
-            const taskHash = detail.taskHash;
-            // Decrypt the wrapped key with the worker's private key
+            // Decrypt the brief. 'public' tasks carry no wrappedKey by design — the
+            // blob at rootHash is already plaintext, so skip ECIES/AES entirely.
+            // Download by acceptResult.rootHash (the 0G Storage pointer) — NOT the
+            // on-chain taskHash, which is a different value (sha256 of the
+            // ciphertext, used as the escrow's commitment) and isn't a valid
+            // storage lookup key.
             let instructions = '';
-            if (acceptResult.wrappedKey && taskHash) {
-                const wrappedBytes = this.decodeWrappedKey(acceptResult.wrappedKey);
-                const aesKey = await eciesDecrypt(wrappedBytes, this.wallet.privateKey);
-                // Download ciphertext from storage via REST API
-                const storageResult = await this.bb.downloadBlob(taskHash);
-                const ciphertext = this.hexToBytes(storageResult.data);
-                // AES decrypt to get plaintext instructions
-                const plaintext = await aesDecrypt(ciphertext, aesKey);
-                instructions = new TextDecoder().decode(plaintext);
+            if (acceptResult.rootHash) {
+                const storageResult = await this.bb.downloadBlob(acceptResult.rootHash);
+                const blobBytes = this.base64ToBytes(storageResult.blob);
+                if (acceptResult.privacy === 'public') {
+                    instructions = new TextDecoder().decode(blobBytes);
+                }
+                else if (acceptResult.wrappedKey) {
+                    const wrappedBytes = this.decodeWrappedKey(acceptResult.wrappedKey);
+                    const aesKey = await eciesDecrypt(wrappedBytes, this.wallet.privateKey);
+                    const plaintext = await aesDecrypt(blobBytes, aesKey);
+                    instructions = new TextDecoder().decode(plaintext);
+                }
             }
             exec.status = 'working';
             this.emit({ type: 'task_working', taskId });
             // Call the user-provided execution handler with decrypted instructions
             const result = await this.config.executeTask({
                 taskId,
-                task: acceptResult.task,
+                task: a2a,
                 instructions,
             });
             exec.status = 'submitted';
             this.emit({ type: 'task_executed', taskId });
-            // Submit result
+            // Submit result — the contract requires the assigned worker to sign
+            // submitEvidence personally (onlyWorker), so the backend hands back an
+            // unsigned tx instead of broadcasting it for us.
             const submitResult = await this.bb.submitResult(taskId, result);
+            // Sign + broadcast submitEvidence with the runtime's own wallet, wait
+            // for confirmation, then tell the backend to proceed with
+            // verification. Without this the on-chain task never leaves
+            // 'Assigned' and completeVerification always reverts — the task only
+            // LOOKS complete.
+            if (submitResult.unsignedSubmitEvidence) {
+                const provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+                const signer = new ethers.Wallet(this.wallet.privateKey, provider);
+                const tx = await signer.sendTransaction(submitResult.unsignedSubmitEvidence);
+                await tx.wait();
+            }
+            const finalizeResult = await this.bb.finalize(taskId);
             exec.status = 'completed';
-            this.emit({ type: 'task_submitted', taskId, result: submitResult });
+            this.emit({ type: 'task_submitted', taskId, result });
+            this.emit({ type: 'task_finalized', taskId, finalize: finalizeResult });
         }
         catch (err) {
             exec.status = 'failed';
@@ -225,17 +249,18 @@ export class WorkerRuntime {
         }
     }
     // ── Helpers ─────────────────────────────────────────────────────────────
-    decodeWrappedKey(wrappedKey) {
-        // Backend returns wrapped key as hex or base64 in a record
-        const hex = Object.values(wrappedKey)[0];
+    /**
+     * Decode a wrapped-key hex string — acceptTask()'s wrappedKey field is a
+     * single hex string (this executor's ECIES-wrapped AES key), not a
+     * Record. The old code here called `Object.values` on that STRING
+     * argument (treating it as if it were a Record), which returned its
+     * first CHARACTER (e.g. "0" from "04a1b2…") — `clean.length / 2` was
+     * then 0 and every decrypt got an empty key.
+     */
+    decodeWrappedKey(hex) {
         if (!hex)
             throw new Error('Empty wrapped key');
-        const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-        const bytes = new Uint8Array(clean.length / 2);
-        for (let i = 0; i < bytes.length; i++) {
-            bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
-        }
-        return bytes;
+        return this.hexToBytes(hex);
     }
     hexToBytes(hex) {
         const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
@@ -245,4 +270,8 @@ export class WorkerRuntime {
         }
         return bytes;
     }
+    /** Decode a base64 string (e.g. downloadBlob()'s `blob` field) into bytes. */
+    base64ToBytes(b64) {
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ethers } from 'ethers';
-import type { Address, Hex, HealthStatus, PlatformStats, OpenTask, TaskDetail, CreateTaskTx, ExecutorProfile, RegisterExecutorInput, DeployedAgentInfo, AgentWalletInfo, ReputationInfo, LeaderboardEntry, StorageUploadResult, Message, AgentSearchResult, TaskTemplate, VerifyTaskInput, A2ATaskState, CreateAgentParams, CreateAgentResult } from './types.js';
+import type { Address, Hex, RootHash, HealthStatus, PlatformStats, OpenTask, TaskDetail, CreateTaskTx, ExecutorProfile, RegisterExecutorInput, DeployedAgentInfo, AgentWalletInfo, ReputationInfo, LeaderboardEntry, StorageUploadResult, Message, AgentSearchResult, TaskTemplate, VerifyTaskInput, A2ATaskState, CreateAgentParams, CreateAgentResult } from './types.js';
 export interface BlindMarketConfig {
     /** Backend API base URL (default: https://api.blindmarket.xyz) */
     apiBase?: string;
@@ -207,15 +207,55 @@ export declare class BlindMarket {
     }>;
     /** Register intent to accept a task (bid). */
     bidOnTask(taskId: string): Promise<void>;
-    /** Accept a task and get wrapped AES key. Requires executor auth. */
+    /**
+     * Accept a task and get the rootHash + ECIES-wrapped AES key for the
+     * caller's address. Requires executor auth.
+     *
+     * Note the shape here matches `backend/src/routes/a2a.ts`'s `/accept`
+     * handler exactly — there is no `task` field, and `wrappedKey` is a single
+     * hex string (this executor's slice), not a `Record`.
+     */
     acceptTask(taskId: string): Promise<{
-        task: A2ATaskState;
-        wrappedKey: Record<string, string>;
+        taskId: string;
+        status: string;
+        rootHash?: RootHash;
+        /** ECIES-wrapped AES key, hex-encoded with no 0x prefix. Absent on public tasks or legacy tasks with no brief. */
+        wrappedKey?: string;
+        /** 'public' means the blob at rootHash is plaintext — no wrappedKey by design. Absent means private/encrypted. */
+        privacy?: 'public' | 'private';
+        alreadySettled?: boolean;
+        assignTxHash?: Hex;
     }>;
-    /** Submit result for an accepted task. */
+    /**
+     * Submit result for an accepted task. Returns an unsigned `submitEvidence`
+     * transaction — the contract requires the assigned worker to sign it
+     * personally (`onlyWorker`), so the caller must sign + broadcast
+     * `unsignedSubmitEvidence` and then call `finalize()`.
+     */
     submitResult(taskId: string, resultData: Record<string, unknown>): Promise<{
-        unsignedTx: object;
-        task: A2ATaskState;
+        taskId: string;
+        onChainTaskId?: string;
+        status: string;
+        evidenceHash?: Hex;
+        unsignedSubmitEvidence?: Record<string, unknown> | null;
+    }>;
+    /**
+     * Tell the backend your `submitEvidence` tx has confirmed on-chain so it
+     * can proceed with verification — auto-verify, or hand off to the poster
+     * / a designated verifier agent depending on the task's verificationMode.
+     * Call this after signing and broadcasting `unsignedSubmitEvidence` from
+     * `submitResult()`. Without this the escrow never settles.
+     */
+    finalize(taskId: string): Promise<{
+        taskId: string;
+        status: string;
+        verifier?: string;
+        awaitingPosterApproval?: boolean;
+        verificationResult?: {
+            passed: boolean;
+            reasons?: string[];
+        };
+        reconciled?: boolean;
     }>;
     /** Get tasks posted by the authenticated user. */
     getPostedTasks(): Promise<{
@@ -252,9 +292,15 @@ export declare class BlindMarket {
     getLeaderboard(limit?: number): Promise<LeaderboardEntry[]>;
     /** Upload an encrypted blob to 0G Storage. */
     uploadBlob(data: Hex): Promise<StorageUploadResult>;
-    /** Download a blob by root hash. */
+    /**
+     * Download a blob by root hash. `blob` is base64-encoded raw bytes — the
+     * caller decodes (and, for encrypted tasks, decrypts) it client-side.
+     * Matches `backend/src/routes/storage.ts`'s `GET /:rootHash` handler,
+     * which returns `{ rootHash, blob }`, not `{ data }`.
+     */
     downloadBlob(rootHash: Hex): Promise<{
-        data: Hex;
+        rootHash: Hex;
+        blob: string;
     }>;
     /** Send a message to another user or agent. */
     sendMessage(params: {
@@ -298,6 +344,14 @@ export declare class BlindMarket {
      * Poll an agent's status at a fixed interval. Returns an unsubscribe function.
      */
     watchAgent(agentId: string, callback: (agent: DeployedAgentInfo) => void, intervalMs?: number): () => void;
+    /**
+     * Canonical registration challenge signed by the agent wallet, proving
+     * control of `agentWallet`. Must stay byte-identical to
+     * `agentRegistrationMessage` in `backend/src/routes/registration.ts` — the
+     * SDK cannot import from the backend, so this is duplicated. A mismatch
+     * here silently breaks registration.
+     */
+    private static agentRegistrationMessage;
     /**
      * Start a device-flow registration session. Generates a magic-link URL
      * that the user opens in a browser to sign with their wallet.
@@ -305,6 +359,11 @@ export declare class BlindMarket {
      * After registering, call `BlindMarket.pollSession(token)` to wait for
      * the user to confirm and receive the API key.
      *
+     * Requires proof of control of `agentWallet`: pass either `agentSigner`
+     * (anything with a `signMessage`, e.g. an ethers `Wallet`) so the SDK signs
+     * the challenge itself, or a pre-computed `agentSignature` for callers
+     * holding a remote signer. Exactly one of the two is required.
+     *
      * @example
      * ```ts
      * const wallet = ethers.Wallet.createRandom();
@@ -312,6 +371,7 @@ export declare class BlindMarket {
      *   agentName: 'my-agent',
      *   agentWallet: wallet.address,
      *   agentPublicKey: wallet.publicKey,
+     *   agentSigner: wallet,
      * });
      * console.log('Open', url, 'to confirm');
      * const apiKey = await BlindMarket.pollSession(token);
@@ -322,6 +382,12 @@ export declare class BlindMarket {
         agentName: string;
         agentWallet: string;
         agentPublicKey: string;
+        /** Signs the registration challenge proving control of agentWallet. */
+        agentSigner?: {
+            signMessage(message: string): Promise<string>;
+        };
+        /** Pre-computed alternative to agentSigner, for callers holding a remote signer. */
+        agentSignature?: string;
         apiBase?: string;
     }): Promise<{
         token: string;

package/dist/index.js

@@ -252,14 +252,36 @@ export class BlindMarket {
     async bidOnTask(taskId) {
         return this.req('POST', `/api/v1/a2a/tasks/${taskId}/bid`);
     }
-    /** Accept a task and get wrapped AES key. Requires executor auth. */
+    /**
+     * Accept a task and get the rootHash + ECIES-wrapped AES key for the
+     * caller's address. Requires executor auth.
+     *
+     * Note the shape here matches `backend/src/routes/a2a.ts`'s `/accept`
+     * handler exactly — there is no `task` field, and `wrappedKey` is a single
+     * hex string (this executor's slice), not a `Record`.
+     */
     async acceptTask(taskId) {
         return this.req('POST', `/api/v1/a2a/tasks/${taskId}/accept`);
     }
-    /** Submit result for an accepted task. */
+    /**
+     * Submit result for an accepted task. Returns an unsigned `submitEvidence`
+     * transaction — the contract requires the assigned worker to sign it
+     * personally (`onlyWorker`), so the caller must sign + broadcast
+     * `unsignedSubmitEvidence` and then call `finalize()`.
+     */
     async submitResult(taskId, resultData) {
         return this.req('POST', `/api/v1/a2a/tasks/${taskId}/submit`, { resultData });
     }
+    /**
+     * Tell the backend your `submitEvidence` tx has confirmed on-chain so it
+     * can proceed with verification — auto-verify, or hand off to the poster
+     * / a designated verifier agent depending on the task's verificationMode.
+     * Call this after signing and broadcasting `unsignedSubmitEvidence` from
+     * `submitResult()`. Without this the escrow never settles.
+     */
+    async finalize(taskId) {
+        return this.req('POST', `/api/v1/a2a/tasks/${taskId}/finalize`);
+    }
     /** Get tasks posted by the authenticated user. */
     async getPostedTasks() {
         return this.req('GET', '/api/v1/a2a/tasks/posted');
@@ -275,9 +297,9 @@ export class BlindMarket {
      */
     async verify(params) {
         return this.req('POST', '/api/v1/verification/verify', {
-            taskId: params.taskId,
+            taskHash: params.taskHash,
             taskCategory: params.taskCategory,
-            taskRequirements: params.taskRequirements,
+            ...(params.taskRequirements ? { taskRequirements: params.taskRequirements } : {}),
             evidenceSummary: params.evidenceSummary,
         });
     }
@@ -303,7 +325,12 @@ export class BlindMarket {
     async uploadBlob(data) {
         return this.req('POST', '/api/v1/storage/upload', { data });
     }
-    /** Download a blob by root hash. */
+    /**
+     * Download a blob by root hash. `blob` is base64-encoded raw bytes — the
+     * caller decodes (and, for encrypted tasks, decrypts) it client-side.
+     * Matches `backend/src/routes/storage.ts`'s `GET /:rootHash` handler,
+     * which returns `{ rootHash, blob }`, not `{ data }`.
+     */
     async downloadBlob(rootHash) {
         return this.req('GET', `/api/v1/storage/${rootHash}`);
     }
@@ -391,6 +418,16 @@ export class BlindMarket {
         return () => clearInterval(id);
     }
     // ── Device-flow registration (static) ─────────────────────────────────────
+    /**
+     * Canonical registration challenge signed by the agent wallet, proving
+     * control of `agentWallet`. Must stay byte-identical to
+     * `agentRegistrationMessage` in `backend/src/routes/registration.ts` — the
+     * SDK cannot import from the backend, so this is duplicated. A mismatch
+     * here silently breaks registration.
+     */
+    static agentRegistrationMessage(agentName, agentWallet, agentPublicKey) {
+        return `BlindMarket agent registration\nname: ${agentName}\nwallet: ${agentWallet.toLowerCase()}\npubkey: ${agentPublicKey.toLowerCase()}`;
+    }
     /**
      * Start a device-flow registration session. Generates a magic-link URL
      * that the user opens in a browser to sign with their wallet.
@@ -398,6 +435,11 @@ export class BlindMarket {
      * After registering, call `BlindMarket.pollSession(token)` to wait for
      * the user to confirm and receive the API key.
      *
+     * Requires proof of control of `agentWallet`: pass either `agentSigner`
+     * (anything with a `signMessage`, e.g. an ethers `Wallet`) so the SDK signs
+     * the challenge itself, or a pre-computed `agentSignature` for callers
+     * holding a remote signer. Exactly one of the two is required.
+     *
      * @example
      * ```ts
      * const wallet = ethers.Wallet.createRandom();
@@ -405,6 +447,7 @@ export class BlindMarket {
      *   agentName: 'my-agent',
      *   agentWallet: wallet.address,
      *   agentPublicKey: wallet.publicKey,
+     *   agentSigner: wallet,
      * });
      * console.log('Open', url, 'to confirm');
      * const apiKey = await BlindMarket.pollSession(token);
@@ -412,6 +455,11 @@ export class BlindMarket {
      * ```
      */
     static async register(params) {
+        if (!params.agentSigner === !params.agentSignature) {
+            throw new ApiError(400, 'Exactly one of agentSigner or agentSignature is required to prove control of agentWallet');
+        }
+        const message = BlindMarket.agentRegistrationMessage(params.agentName, params.agentWallet, params.agentPublicKey);
+        const agentSignature = params.agentSignature ?? await params.agentSigner.signMessage(message);
         const base = params.apiBase ?? 'https://api.blindmarket.xyz';
         const res = await fetch(`${base}/api/v1/registration/session`, {
             method: 'POST',
@@ -420,6 +468,7 @@ export class BlindMarket {
                 agentName: params.agentName,
                 agentWallet: params.agentWallet,
                 agentPublicKey: params.agentPublicKey,
+                agentSignature,
             }),
         });
         const json = await res.json();

package/dist/tools/helpers.js

@@ -124,13 +124,22 @@ export function createBlindMarketTools(bb) {
             return bb.updateAgent(a.agentId, a);
         }, ['agentId']),
         tool(bb, 'verify_task', 'Trigger AI/TEE verification for a submitted task result', {
-            taskId: num('Numeric task ID'),
-            taskCategory: str('Task category (e.g. photography, research)'),
-            taskRequirements: str('What the task required'),
+            // taskHash, not a numeric id: ids collide across 0G and Base, so a number
+            // cannot identify a task. taskRequirements is optional and privileged —
+            // the backend builds the standard from the task the poster created and
+            // accepts this only from the poster or designated verifier.
+            taskHash: str('Task hash (bytes32 hex, 0x-prefixed)'),
+            taskCategory: str('Task category slug (letters, numbers, spaces, _ and - only)'),
+            taskRequirements: str('Optional supplemental requirements (poster/verifier only)'),
             evidenceSummary: str('Summary of submitted evidence'),
         }, async (a) => {
-            return bb.verify(a);
-        }, ['taskId', 'taskCategory', 'taskRequirements', 'evidenceSummary']),
+            return bb.verify({
+                taskHash: a.taskHash,
+                taskCategory: a.taskCategory,
+                ...(a.taskRequirements ? { taskRequirements: a.taskRequirements } : {}),
+                evidenceSummary: a.evidenceSummary,
+            });
+        }, ['taskHash', 'taskCategory', 'evidenceSummary']),
         tool(bb, 'get_reputation', "Get an address's on-chain + off-chain reputation", {
             address: str('Wallet address (0x...)'),
         }, async (a) => {

package/dist/types.d.ts

@@ -228,9 +228,14 @@ export interface TaskTemplate {
     estimatedReward?: string;
 }
 export interface VerifyTaskInput {
-    taskId: number;
+    /** taskHash (bytes32 hex). Not the numeric on-chain id — those collide
+     *  across 0G and Base, so they cannot identify a task. */
+    taskHash: string;
     taskCategory: string;
-    taskRequirements: string;
+    /** Optional supplemental requirements. The backend builds the standard being
+     *  judged against from the task the poster created; this is accepted only
+     *  from the poster or the designated verifier, never the executor. */
+    taskRequirements?: string;
     evidenceSummary: string;
 }
 /** Dot-notation access to valid capability strings. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blindmarket/sdk",
-  "version": "0.1.8",
+  "version": "0.5.0",
   "description": "BlindMarket SDK — deploy agents, assign workers, verify evidence",
   "author": "BlindMarket Team",
   "license": "MIT",
@@ -31,6 +31,9 @@
     "vercel-ai-sdk"
   ],
   "type": "module",
+  "files": [
+    "dist"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -41,6 +44,10 @@
     "./tools": {
       "import": "./dist/tools/index.js",
       "types": "./dist/tools/index.d.ts"
+    },
+    "./crypto": {
+      "import": "./dist/crypto/index.js",
+      "types": "./dist/crypto/index.d.ts"
     }
   },
   "scripts": {

package/biome.json

@@ -1,19 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "organizeImports": { "enabled": true },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "suspicious": { "noExplicitAny": "error" },
-      "style": { "useImportType": "error" }
-    }
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 120,
-    "lineEnding": "lf"
-  }
-}

package/examples/agent-demo.ts

@@ -1,121 +0,0 @@
-/**
- * Agent → Worker end-to-end demo, using MemoryStorage + a mock escrow so the
- * script runs anywhere without an RPC or funded wallet. Shows the full flow:
- *
- *   1. Agent creates an encrypted task (AES-encrypt instructions, upload blob)
- *   2. Agent assigns a worker (ECIES-wrap the AES key to worker's pubkey)
- *   3. Worker decrypts the instructions
- *   4. Worker submits evidence (seals a dual-recipient envelope for agent + TEE)
- *   5. Agent decrypts the evidence
- *
- * Run from sdk/:  npx tsx examples/agent-demo.ts
- *
- * For the real chain, swap MockEscrow for `new ChainClient({ network, signer }).escrow`
- * and swap MemoryStorage for `new ZgStorage({ indexerUrl, rpcUrl, signer: ethersWallet })`.
- */
-import { Agent } from '../src/agent/index.js';
-import type { BlindEscrowClient, CreateTaskArgs } from '../src/chain/index.js';
-import { generateKeyPair } from '../src/crypto/index.js';
-import { EventBus, type SdkEvents } from '../src/events/index.js';
-import { InMemoryKeyStore } from '../src/keystore/index.js';
-import { PrivateKeySigner } from '../src/signer/index.js';
-import { MemoryStorage } from '../src/storage/index.js';
-import type { Address, Hex, RootHash, TaskId, TxReceiptLike } from '../src/types.js';
-import { Worker } from '../src/worker/index.js';
-
-// ── Mock escrow for offline demo (use real ChainClient in production) ──
-class MockEscrow {
-  private nextId = 1n;
-  private evidenceByTask = new Map<string, RootHash>();
-  async createTask(args: CreateTaskArgs) {
-    const taskId = this.nextId++;
-    return { taskId, receipt: r('0xa') };
-  }
-  async assignWorker(_taskId: TaskId, _worker: Address) { return r('0xb'); }
-  async cancelTask(_taskId: TaskId) { return r('0xc'); }
-  async submitEvidence(taskId: TaskId, evidenceHash: Hex) {
-    this.evidenceByTask.set(taskId.toString(), evidenceHash as RootHash);
-    return r('0xd');
-  }
-  getEvidenceHash(taskId: TaskId) { return this.evidenceByTask.get(taskId.toString()); }
-}
-function r(prefix: string): TxReceiptLike {
-  return { hash: (prefix + 'f'.repeat(63 - prefix.length + 2)).slice(0, 66) as Hex, blockNumber: 1, gasUsed: 21000n };
-}
-
-// ── Shared deps ──
-const AGENT_PK = '0x' + '1'.repeat(64);
-const WORKER_PK = '0x' + '2'.repeat(64);
-const USDC = '0x317227efcA18D004E12CA8046AEf7E1597458F25' as Address;
-
-const storage = new MemoryStorage();
-const escrow = new MockEscrow();
-const events = new EventBus<SdkEvents>();
-events.on('task.created', (p) => console.log(`  • task.created taskId=${p.taskId} rootHash=${p.rootHash.slice(0, 18)}…`));
-events.on('task.assigned', (p) => console.log(`  • task.assigned taskId=${p.taskId} worker=${p.worker.slice(0, 10)}…`));
-events.on('evidence.submitted', (p) => console.log(`  • evidence.submitted taskId=${p.taskId} rootHash=${p.rootHash.slice(0, 18)}…`));
-
-// ── Identities ──
-const agentSigner = new PrivateKeySigner(AGENT_PK);
-const workerSigner = new PrivateKeySigner(WORKER_PK);
-const agentPubKey = await agentSigner.getPublicKey();
-const workerPubKey = await workerSigner.getPublicKey();
-const workerAddr = (await workerSigner.getAddress()) as Address;
-const enclaveKeys = generateKeyPair(); // TEE pubkey — fetched from broker in production
-
-const agent = new Agent({
-  // biome-ignore lint/suspicious/noExplicitAny: demo mock
-  escrow: escrow as any as BlindEscrowClient,
-  storage,
-  keystore: new InMemoryKeyStore(),
-  signer: agentSigner,
-  events,
-});
-const worker = new Worker({
-  // biome-ignore lint/suspicious/noExplicitAny: demo mock
-  escrow: escrow as any as BlindEscrowClient,
-  // biome-ignore lint/suspicious/noExplicitAny: demo: no registry needed for this path
-  registry: null as any,
-  storage,
-  signer: workerSigner,
-  events,
-});
-
-// ── 1. Agent creates an encrypted task ──
-console.log('\n[1] Agent creates encrypted task');
-const created = await agent.createTask({
-  instructions: 'Take 3 photos of the storefront at 123 Main St, Lagos',
-  category: 'photography',
-  locationZone: 'Lagos, NG',
-  reward: { token: USDC, amount: 5_000000n },
-  deadline: new Date(Date.now() + 24 * 3600_000),
-});
-
-// ── 2. Agent assigns the worker ──
-console.log('\n[2] Agent assigns worker (wraps AES key to worker pubkey)');
-const { wrappedKey } = await agent.assignWorker(created.taskId, workerAddr, workerPubKey);
-
-// ── 3. Worker decrypts the instructions ──
-console.log('\n[3] Worker decrypts instructions');
-const instructions = await worker.decryptInstructions({
-  wrappedKey,
-  workerPrivKey: WORKER_PK,
-  taskHash: created.rootHash,
-});
-console.log(`  → "${new TextDecoder().decode(instructions)}"`);
-
-// ── 4. Worker submits evidence ──
-console.log('\n[4] Worker submits evidence (dual-recipient envelope: agent + TEE)');
-const submitted = await worker.submitEvidence({
-  taskId: created.taskId,
-  evidence: 'photo1.jpg photo2.jpg photo3.jpg (attached)',
-  agentPubKey,
-  enclavePubKey: enclaveKeys.publicKey,
-});
-
-// ── 5. Agent fetches + decrypts evidence ──
-console.log('\n[5] Agent decrypts evidence');
-const recovered = await agent.fetchAndDecryptEvidence(submitted.rootHash, AGENT_PK);
-console.log(`  → "${new TextDecoder().decode(recovered)}"`);
-
-console.log('\n✓ full lifecycle completed');