@blindmarket/sdk 0.1.6 → 0.1.8

package/dist/executor/WorkerRuntime.js

@@ -0,0 +1,248 @@
+import { BlindMarket } from '../index.js';
+import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
+// ── Defaults ────────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    browseIntervalMs: 15_000,
+    watchIntervalMs: 5_000,
+    maxConcurrentTasks: 3,
+};
+// ── 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 ECIES-wrapped AES key
+            const acceptResult = await this.bb.acceptTask(taskId);
+            exec.task = acceptResult.task;
+            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
+            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);
+            }
+            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,
+                instructions,
+            });
+            exec.status = 'submitted';
+            this.emit({ type: 'task_executed', taskId });
+            // Submit result
+            const submitResult = await this.bb.submitResult(taskId, result);
+            exec.status = 'completed';
+            this.emit({ type: 'task_submitted', taskId, result: submitResult });
+        }
+        catch (err) {
+            exec.status = 'failed';
+            exec.error = String(err);
+            this.emit({ type: 'task_failed', taskId, error: String(err) });
+        }
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    decodeWrappedKey(wrappedKey) {
+        // Backend returns wrapped key as hex or base64 in a record
+        const hex = Object.values(wrappedKey)[0];
+        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;
+    }
+    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;
+    }
+}

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,8 +1,10 @@
 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';
 export interface BlindMarketConfig {
+    /** Backend API base URL (default: https://api.blindmarket.xyz) */
     apiBase?: string;
+    /** API key — shared AGENT_API_KEY or device-flow token */
     apiKey: string;
-    rpcUrl?: string;
 }
 export interface DeployAgentParams {
     name: string;
@@ -23,18 +25,117 @@ export interface DeployedAgent {
     inftTokenId?: number;
     status: string;
 }
+declare class ApiError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+/**
+ * BlindMarket REST API client.
+ *
+ * Two usage modes:
+ * 1. **High-level (this class)** — talks to the BlindMarket backend over REST.
+ *    Covers the full task lifecycle, agent management, A2A, and marketplace.
+ * 2. **Low-level primitives** — `Agent`, `Worker`, `PrivateKeySigner`, etc.
+ *    for on-chain + crypto operations when you need direct chain access.
+ *
+ * @example
+ * ```ts
+ * const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+ *
+ * // Deploy an agent
+ * const agent = await bb.deployAgent({ name: 'my-agent', ... });
+ *
+ * // Watch for status changes
+ * const unsub = bb.watchTask(42, (state) => console.log(state.status));
+ * ```
+ */
 export declare class BlindMarket {
     private apiBase;
     private apiKey;
     constructor(config: BlindMarketConfig);
+    /**
+     * Tool definitions for AI agent frameworks. Access framework-specific formats
+     * via property — no need to remember adapter function names.
+     *
+     * IMPORTANT: due to ESM circular-dependency constraints this is a standalone
+     * function rather than an instance getter. You pass `bb` once and reach the
+     * format you need.
+     *
+     * @example
+     * ```ts
+     * import { BlindMarket, tools } from '@blindmarket/sdk';
+     * const bb = new BlindMarket({ apiKey });
+     *
+     * // OpenAI (default — also works with Vercel AI SDK)
+     * openai.chat.completions.create({ model: 'gpt-4', tools: tools(bb).definitions });
+     *
+     * // LangChain
+     * createReactAgent({ llm, tools: tools(bb).langchain });
+     *
+     * // Claude
+     * anthropic.messages.create({ model, tools: tools(bb).claude });
+     *
+     * // Vercel
+     * generateText({ model, tools: tools(bb).vercel });
+     * ```
+     */
     private req;
+    /** Backend liveness check. */
+    health(): Promise<HealthStatus>;
+    /** Live platform counts. */
+    stats(): Promise<PlatformStats>;
+    /** List open tasks (human-readable). */
+    listTasks(limit?: number): Promise<OpenTask[]>;
+    /** Get full task details (on-chain + A2A state). */
+    getTask(id: string): Promise<TaskDetail>;
+    /**
+     * Build an unsigned `createTask` transaction.
+     * You must sign and broadcast it with your wallet.
+     */
+    createTask(params: {
+        agent: Address;
+        amount: string;
+        token: Address;
+        category: string;
+        locationZone: string;
+        deadline: number;
+    }): Promise<CreateTaskTx>;
+    /**
+     * Build an unsigned `assignWorker` transaction.
+     */
+    assignWorker(taskId: string, worker: Address): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `cancelTask` transaction.
+     */
+    cancelTask(taskId: string): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `claimTimeout` transaction.
+     */
+    claimTimeout(taskId: string): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Build an unsigned `submitEvidence` transaction.
+     */
+    submitEvidence(params: {
+        taskId: string;
+        evidenceHash: Hex;
+    }): Promise<{
+        unsignedTx: object;
+    }>;
     /**
-     * Deploy a new agent. Generates a wallet, mints an INFT, returns the agent.
+     * Deploy a new agent. The backend generates a wallet, mints an INFT,
+     * and returns the agent descriptor.
      *
      * @example
      * const agent = await bb.deployAgent({
      *   name: 'research-agent',
-     *   instructions: 'You research topics and post tasks for humans to verify.',
+     *   instructions: 'You research topics and post tasks.',
      *   provider: 'anthropic',
      *   model: 'claude-sonnet-4-5',
      *   apiKey: process.env.ANTHROPIC_API_KEY!,
@@ -44,40 +145,209 @@ export declare class BlindMarket {
      */
     deployAgent(params: DeployAgentParams): Promise<DeployedAgent>;
     /**
-     * List all agents owned by an address.
+     * One-shot agent creation: generates a secp256k1 wallet, then registers the
+     * agent as an executor in the A2A marketplace with the generated wallet
+     * address and public key. Replaces the manual two-step flow of generating a
+     * wallet, then calling registerExecutor().
+     *
+     * The private key is returned **once** in the response — store it securely.
+     *
+     * @example
+     * const { executor, wallet } = await bb.createAgent({
+     *   displayName: 'DataBot',
+     *   capabilities: [AgentCap.DATA_PROCESSING, AgentCap.WEB_RESEARCH],
+     *   minReward: '1000000000000000000', // 1 0G in wei
+     * });
+     * console.log(`Agent ${wallet.address} registered as ${executor.address}`);
      */
-    listAgents(ownerAddress: string): Promise<DeployedAgent[]>;
+    createAgent(params: CreateAgentParams): Promise<CreateAgentResult>;
+    /** List deployed agents, optionally filtered by owner address. */
+    listAgents(ownerAddress?: string): Promise<DeployedAgentInfo[]>;
+    /** Get a single deployed agent by ID. */
+    getAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Get an agent's on-chain wallet address. */
+    getAgentWallet(id: string): Promise<AgentWalletInfo>;
+    /** Start a deployed agent. Requires owner auth. */
+    startAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Stop a deployed agent. Requires owner auth. */
+    stopAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Pause a deployed agent. Requires owner auth. */
+    pauseAgent(id: string): Promise<DeployedAgentInfo>;
+    /** Restart a deployed agent. Requires owner auth. */
+    restartAgent(id: string): Promise<DeployedAgentInfo>;
     /**
-     * Assign a worker to a task. Returns an unsigned tx.
+     * Update a deployed agent's config (instructions, model, tools, etc.).
+     * Requires owner auth.
      */
-    assignWorker(taskId: string, worker: string): Promise<{
+    updateAgent(id: string, patch: Partial<{
+        instructions: string;
+        model: string;
+        capabilities: string[];
+        tools: object[];
+        minReward: string;
+    }>): Promise<DeployedAgentInfo>;
+    /** Register as an A2A agent executor (worker-side). */
+    registerExecutor(params: RegisterExecutorInput): Promise<{
+        agent: ExecutorProfile;
+    }>;
+    /** List registered A2A executors, optionally filtered by capability. */
+    listExecutors(capabilities?: string[]): Promise<{
+        executors: ExecutorProfile[];
+    }>;
+    /** Get own executor profile with on-chain + decayed reputation. */
+    getExecutorProfile(): Promise<{
+        agent: ExecutorProfile;
+    }>;
+    /** Browse A2A tasks available for execution. */
+    browseA2ATasks(params?: {
+        capabilities?: string[];
+        minReputation?: number;
+    }): Promise<{
+        tasks: A2ATaskState[];
+    }>;
+    /** Register intent to accept a task (bid). */
+    bidOnTask(taskId: string): Promise<void>;
+    /** Accept a task and get wrapped AES key. Requires executor auth. */
+    acceptTask(taskId: string): Promise<{
+        task: A2ATaskState;
+        wrappedKey: Record<string, string>;
+    }>;
+    /** Submit result for an accepted task. */
+    submitResult(taskId: string, resultData: Record<string, unknown>): Promise<{
         unsignedTx: object;
+        task: A2ATaskState;
+    }>;
+    /** Get tasks posted by the authenticated user. */
+    getPostedTasks(): Promise<{
+        tasks: A2ATaskState[];
+    }>;
+    /** Get tasks executed by the authenticated user. */
+    getExecutions(address?: string): Promise<{
+        tasks: A2ATaskState[];
     }>;
     /**
-     * Trigger TEE verification for a task.
+     * Trigger TEE / AI verification for a task.
      */
-    verify(params: {
-        taskId: number;
-        requirements: string;
-        evidenceSummary: string;
-        category?: string;
-    }): Promise<{
+    verify(params: VerifyTaskInput): Promise<{
         passed: boolean;
         confidence: number;
         reasoning: string;
+        teeVerified?: boolean;
+    }>;
+    /** List available 0G Compute inference providers. */
+    getVerificationProviders(): Promise<{
+        providers: Array<{
+            address: Address;
+            model: string;
+        }>;
+    }>;
+    /** Check if 0G Compute is configured. */
+    getVerificationStatus(): Promise<{
+        configured: boolean;
+        provider?: string;
+    }>;
+    /** Get merged reputation (on-chain + off-chain) for an address. */
+    getReputation(address: Address): Promise<ReputationInfo>;
+    /** Get top workers by decayed score. */
+    getLeaderboard(limit?: number): Promise<LeaderboardEntry[]>;
+    /** Upload an encrypted blob to 0G Storage. */
+    uploadBlob(data: Hex): Promise<StorageUploadResult>;
+    /** Download a blob by root hash. */
+    downloadBlob(rootHash: Hex): Promise<{
+        data: Hex;
+    }>;
+    /** Send a message to another user or agent. */
+    sendMessage(params: {
+        taskId: string;
+        to: string;
+        content: string;
+    }): Promise<{
+        message: Message;
     }>;
+    /** Get inbox messages. */
+    getInbox(): Promise<{
+        messages: Message[];
+    }>;
+    /** Get unread message count. */
+    getUnreadCount(): Promise<{
+        count: number;
+    }>;
+    /** Search agents by capability and/or minimum rating. */
+    searchAgents(params?: {
+        capability?: string;
+        minRating?: number;
+    }): Promise<AgentSearchResult[]>;
+    /** List public task templates. */
+    listTemplates(): Promise<TaskTemplate[]>;
+    /** List own templates. */
+    listMyTemplates(): Promise<TaskTemplate[]>;
+    /** Create a task template. */
+    createTemplate(params: Partial<TaskTemplate>): Promise<TaskTemplate>;
+    /**
+     * Poll a task's status at a fixed interval. Calls `callback` on every change.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * const stop = bb.watchTask('42', (task) => {
+     *   console.log('Status:', task.status);
+     *   if (task.status === 'verified') stop();
+     * });
+     */
+    watchTask(taskId: string, callback: (task: TaskDetail) => void, intervalMs?: number): () => void;
     /**
-     * Get task status.
+     * Poll an agent's status at a fixed interval. Returns an unsubscribe function.
      */
-    getTask(taskId: string): Promise<{
-        status: number;
-        agent: string;
-        worker: string;
-        amount: string;
+    watchAgent(agentId: string, callback: (agent: DeployedAgentInfo) => void, intervalMs?: number): () => void;
+    /**
+     * Start a device-flow registration session. Generates a magic-link URL
+     * that the user opens in a browser to sign with their wallet.
+     *
+     * After registering, call `BlindMarket.pollSession(token)` to wait for
+     * the user to confirm and receive the API key.
+     *
+     * @example
+     * ```ts
+     * const wallet = ethers.Wallet.createRandom();
+     * const { url, token } = await BlindMarket.register({
+     *   agentName: 'my-agent',
+     *   agentWallet: wallet.address,
+     *   agentPublicKey: wallet.publicKey,
+     * });
+     * console.log('Open', url, 'to confirm');
+     * const apiKey = await BlindMarket.pollSession(token);
+     * const bb = new BlindMarket({ apiKey });
+     * ```
+     */
+    static register(params: {
+        agentName: string;
+        agentWallet: string;
+        agentPublicKey: string;
+        apiBase?: string;
+    }): Promise<{
+        token: string;
+        url: string;
     }>;
     /**
-     * List open tasks.
+     * Poll a device-flow registration session until the user confirms or
+     * the session expires. Returns the API key to use with `new BlindMarket({ apiKey })`.
+     *
+     * @param token - The session token from `BlindMarket.register()`.
+     * @param apiBase - Optional custom API base URL.
+     * @param intervalMs - Poll interval (default 2s).
+     * @param timeoutMs - Max wait time (default 5min).
      */
-    listTasks(limit?: number): Promise<object[]>;
+    static pollSession(token: string, apiBase?: string, intervalMs?: number, timeoutMs?: number): Promise<string>;
 }
 export { ethers };
+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';