@blindmarket/sdk 0.1.7 → 0.4.0

package/dist/executor/WorkerRuntime.d.ts

@@ -0,0 +1,134 @@
+import { BlindMarket } from '../index.js';
+import type { A2ATaskState, AgentCapability, ExecutorProfile, Message } from '../types.js';
+export interface WorkerRuntimeConfig {
+    apiKey: string;
+    apiBase?: string;
+    displayName: string;
+    capabilities: AgentCapability[];
+    executeTask: ExecuteTaskHandler;
+    existingPrivateKey?: string;
+    existingAddress?: string;
+    existingPublicKey?: string;
+    minReward?: string;
+    preferredCapabilities?: AgentCapability[];
+    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 {
+    taskId: string;
+    task: A2ATaskState;
+    instructions: string;
+}
+export interface TaskExecutionInfo {
+    taskId: string;
+    status: 'bidding' | 'assigned' | 'working' | 'submitted' | 'completed' | 'failed';
+    task?: A2ATaskState;
+    error?: string;
+    startedAt: number;
+}
+export type WorkerRuntimeEvent = {
+    type: 'started';
+} | {
+    type: 'stopped';
+} | {
+    type: 'paused';
+} | {
+    type: 'resumed';
+} | {
+    type: 'registered';
+    profile: ExecutorProfile;
+} | {
+    type: 'task_found';
+    taskId: string;
+    task: A2ATaskState;
+} | {
+    type: 'task_bidded';
+    taskId: string;
+} | {
+    type: 'task_assigned';
+    taskId: string;
+} | {
+    type: 'task_accepted';
+    taskId: string;
+} | {
+    type: 'task_working';
+    taskId: string;
+} | {
+    type: 'task_executed';
+    taskId: string;
+} | {
+    type: 'task_submitted';
+    taskId: string;
+    result: Record<string, unknown>;
+} | {
+    type: 'task_finalized';
+    taskId: string;
+    finalize: Awaited<ReturnType<BlindMarket['finalize']>>;
+} | {
+    type: 'task_failed';
+    taskId: string;
+    error: string;
+} | {
+    type: 'message_received';
+    message: Message;
+    count: number;
+} | {
+    type: 'browse_done';
+    found: number;
+} | {
+    type: 'error';
+    error: string;
+};
+export declare class WorkerRuntime {
+    private bb;
+    private config;
+    private wallet?;
+    private profile?;
+    private running;
+    private paused;
+    private browseTimer?;
+    private watchTimers;
+    private executions;
+    private listeners;
+    constructor(config: WorkerRuntimeConfig);
+    get isRunning(): boolean;
+    get isPaused(): boolean;
+    get activeExecutions(): TaskExecutionInfo[];
+    /** Get own executor profile (available after start). */
+    get executorProfile(): ExecutorProfile | undefined;
+    /** Get own wallet info (available after start). */
+    get executorWallet(): {
+        address: string;
+        publicKey: string;
+    } | undefined;
+    on(listener: (event: WorkerRuntimeEvent) => void): () => void;
+    private emit;
+    start(): Promise<ExecutorProfile>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    private startBrowseLoop;
+    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

@@ -0,0 +1,277 @@
+import { ethers } from 'ethers';
+import { BlindMarket } from '../index.js';
+import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
+// ── Defaults ────────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    browseIntervalMs: 15_000,
+    watchIntervalMs: 5_000,
+    maxConcurrentTasks: 3,
+    rpcUrl: 'https://evmrpc-testnet.0g.ai',
+};
+// ── WorkerRuntime ───────────────────────────────────────────────────────────
+export class WorkerRuntime {
+    bb;
+    config;
+    wallet;
+    profile;
+    running = false;
+    paused = false;
+    browseTimer;
+    watchTimers = new Map();
+    executions = new Map();
+    listeners = new Set();
+    constructor(config) {
+        this.config = { ...DEFAULTS, ...config };
+        this.bb = new BlindMarket({ apiKey: config.apiKey, apiBase: config.apiBase });
+    }
+    // ── Status ──────────────────────────────────────────────────────────────
+    get isRunning() {
+        return this.running;
+    }
+    get isPaused() {
+        return this.paused;
+    }
+    get activeExecutions() {
+        return [...this.executions.values()];
+    }
+    /** Get own executor profile (available after start). */
+    get executorProfile() {
+        return this.profile;
+    }
+    /** Get own wallet info (available after start). */
+    get executorWallet() {
+        return this.wallet;
+    }
+    // ── Events ──────────────────────────────────────────────────────────────
+    on(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(event) {
+        for (const l of this.listeners)
+            l(event);
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async start() {
+        if (this.running)
+            return this.profile;
+        // 1. Register or restore executor
+        if (this.config.existingPrivateKey && this.config.existingAddress && this.config.existingPublicKey) {
+            this.wallet = {
+                address: this.config.existingAddress,
+                privateKey: this.config.existingPrivateKey,
+                publicKey: this.config.existingPublicKey,
+            };
+            // Fetch existing profile — backend identifies by API key
+            const result = await this.bb.getExecutorProfile();
+            this.profile = result.agent;
+        }
+        else {
+            const result = await this.bb.createAgent({
+                displayName: this.config.displayName,
+                capabilities: this.config.capabilities,
+                minReward: this.config.minReward,
+                preferredCapabilities: this.config.preferredCapabilities,
+            });
+            this.wallet = {
+                address: result.wallet.address,
+                privateKey: result.wallet.privateKey,
+                publicKey: result.wallet.publicKey,
+            };
+            this.profile = result.executor;
+        }
+        this.emit({ type: 'registered', profile: this.profile });
+        // 2. Start the browse loop
+        this.running = true;
+        this.startBrowseLoop();
+        this.emit({ type: 'started' });
+        return this.profile;
+    }
+    stop() {
+        this.running = false;
+        if (this.browseTimer) {
+            clearInterval(this.browseTimer);
+            this.browseTimer = undefined;
+        }
+        for (const t of this.watchTimers.values())
+            clearInterval(t);
+        this.watchTimers.clear();
+        this.emit({ type: 'stopped' });
+    }
+    pause() {
+        if (!this.running || this.paused)
+            return;
+        this.paused = true;
+        this.emit({ type: 'paused' });
+    }
+    resume() {
+        if (!this.running || !this.paused)
+            return;
+        this.paused = false;
+        this.emit({ type: 'resumed' });
+        // Immediately browse instead of waiting for next interval
+        this.browse();
+    }
+    // ── Browse loop ─────────────────────────────────────────────────────────
+    startBrowseLoop() {
+        const ms = this.config.browseIntervalMs;
+        this.browseTimer = setInterval(() => this.browse(), ms);
+        this.browse();
+    }
+    async browse() {
+        if (this.paused)
+            return;
+        try {
+            const active = this.activeExecutions;
+            const inFlight = active.filter(e => e.status === 'bidding' || e.status === 'working').length;
+            if (inFlight >= this.config.maxConcurrentTasks)
+                return;
+            const result = await this.bb.browseA2ATasks({
+                capabilities: this.config.capabilities,
+            });
+            this.emit({ type: 'browse_done', found: result.tasks.length });
+            for (const task of result.tasks) {
+                if (this.executions.has(task.taskId))
+                    continue;
+                if (task.status !== 'open' && task.status !== 'bidding')
+                    continue;
+                if (task.executorAddress && task.executorAddress !== this.wallet?.address)
+                    continue;
+                this.executions.set(task.taskId, {
+                    taskId: task.taskId,
+                    status: 'bidding',
+                    task,
+                    startedAt: Date.now(),
+                });
+                this.emit({ type: 'task_found', taskId: task.taskId, task });
+                await this.bb.bidOnTask(task.taskId);
+                this.emit({ type: 'task_bidded', taskId: task.taskId });
+                this.watchForAssignment(task.taskId);
+            }
+        }
+        catch (err) {
+            this.emit({ type: 'error', error: `Browse failed: ${err}` });
+        }
+    }
+    // ── Assignment watching ─────────────────────────────────────────────────
+    watchForAssignment(taskId) {
+        if (!this.running)
+            return;
+        const ms = this.config.watchIntervalMs;
+        const timer = setInterval(async () => {
+            if (!this.running || this.paused)
+                return;
+            try {
+                const detail = await this.bb.getTask(taskId);
+                const a2a = detail.a2aState;
+                if (!a2a)
+                    return;
+                if (a2a.status === 'assigned') {
+                    clearInterval(timer);
+                    this.watchTimers.delete(taskId);
+                    this.emit({ type: 'task_assigned', taskId });
+                    await this.executeTask(taskId, a2a);
+                }
+            }
+            catch {
+                // Retry next tick
+            }
+        }, ms);
+        this.watchTimers.set(taskId, timer);
+    }
+    // ── Task execution ──────────────────────────────────────────────────────
+    async executeTask(taskId, a2a) {
+        const exec = this.executions.get(taskId);
+        if (!exec)
+            return;
+        try {
+            exec.status = 'assigned';
+            // 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 = a2a;
+            this.emit({ type: 'task_accepted', taskId });
+            // 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.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: a2a,
+                instructions,
+            });
+            exec.status = 'submitted';
+            this.emit({ type: 'task_executed', taskId });
+            // 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 });
+            this.emit({ type: 'task_finalized', taskId, finalize: finalizeResult });
+        }
+        catch (err) {
+            exec.status = 'failed';
+            exec.error = String(err);
+            this.emit({ type: 'task_failed', taskId, error: String(err) });
+        }
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    /**
+     * 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');
+        return this.hexToBytes(hex);
+    }
+    hexToBytes(hex) {
+        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;
+    }
+    /** Decode a base64 string (e.g. downloadBlob()'s `blob` field) into bytes. */
+    base64ToBytes(b64) {
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
+}

package/dist/executor/index.d.ts

@@ -0,0 +1 @@
+export { WorkerRuntime, type WorkerRuntimeConfig, type ExecuteTaskHandler, type TaskContext, type TaskExecutionInfo, type WorkerRuntimeEvent, } from './WorkerRuntime.js';

package/dist/executor/index.js

@@ -0,0 +1 @@
+export { WorkerRuntime, } from './WorkerRuntime.js';

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;
@@ -343,4 +409,11 @@ export { ApiError };
 export { tools, createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './tools/index.js';
 export type { Tool, ToolKit, ToolDefinition } from './tools/types.js';
 export type { BlindMarketTools } from './tools/index.js';
+export * from './executor/index.js';
 export * from './types.js';
+export { EVMChainAdapter } from './chain/evm/index.js';
+export { createChainAdapter } from './chain/createChainAdapter.js';
+export type { CreateChainAdapterOptions } from './chain/createChainAdapter.js';
+export type { IBlindMarketChain } from './chain/IBlindMarketChain.js';
+export type { Network, EVMNetwork, BlockchainType, CreateTaskParams, DomainTask, DomainTaskMeta, DomainReputation, DomainTxReceipt, ChainSigner, } from './chain/domain-types.js';
+export { isEVMNetwork } from './network/resolve.js';