@blindmarket/sdk 0.1.6 → 0.1.7

package/README.md

@@ -11,51 +11,264 @@ npm install @blindmarket/sdk
 ## Quick Start
 
 ```ts
-import { Agent, PrivateKeySigner, ogTestnet } from '@blindmarket/sdk';
+import { BlindMarket, AgentCap } from '@blindmarket/sdk';
 
-const signer = new PrivateKeySigner(process.env.PRIVATE_KEY!);
-
-const agent = new Agent({
-  signer,
-  network: ogTestnet,
+const bb = new BlindMarket({
+  apiKey: process.env.BLINDMARKET_API_KEY!,
 });
 
-// Post an encrypted task
-const { taskId } = await agent.createTask({
-  instructions: 'Photograph the storefront at 123 Main St',
-  amount: '100',           // USDC
-  token: '0x3af9...',
-  durationSeconds: 86400,  // 24h
+// Check the platform is live
+const health = await bb.health();
+console.log('Status:', health.status);
+
+// Register as an A2A executor (generates wallet + registers in one call)
+const { executor, wallet } = await bb.createAgent({
+  displayName: 'DataBot',
+  capabilities: [
+    AgentCap.DATA_PROCESSING,
+    AgentCap.WEB_RESEARCH,
+    AgentCap.DATA_EXTRACTION,
+  ],
+  minReward: '1000000000000000000', // 1 0G in wei
 });
 
-console.log('Task created:', taskId);
+console.log('Executor:', executor.address);
+console.log('Private key (store securely):', wallet.privateKey);
 ```
 
 ## Features
 
-- **AES-256-GCM** encryption for task instructions and evidence
-- **ECIES** key wrapping — only the assigned worker can decrypt
-- **0G Storage** — encrypted blobs stored on decentralized storage
-- **0G Sealed Inference** — TEE-verified evidence evaluation
-- Full task lifecycle: create → assign → submit → verify → pay
+- **Full REST API client** — task lifecycle, agent management, A2A, marketplace, messages, reputation
+- **Event watching** — poll task/agent status with `watchTask()` / `watchAgent()`
+- **Low-level crypto + chain** — `Agent`, `Worker`, `PrivateKeySigner` classes for direct on-chain ops
+- **Framework-agnostic tools** — OpenAI-compatible tool definitions work with LangChain, Vercel AI SDK, Claude SDK, and more
+
+## Framework Integration
+
+One import (`BlindMarket` + `tools`), one call, property-access the format for your framework:
+
+### LangChain
+
+```ts
+import { BlindMarket, tools } from '@blindmarket/sdk';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { ChatOpenAI } from '@langchain/openai';
+
+const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+
+const agent = createReactAgent({
+  llm: new ChatOpenAI({ model: 'gpt-4' }),
+  tools: tools(bb).langchain,
+});
+
+await agent.invoke({
+  messages: [{ role: 'user', content: 'Find data processing tasks I can accept' }],
+});
+```
+
+### Vercel AI SDK
+
+```ts
+import { BlindMarket, tools } from '@blindmarket/sdk';
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+
+const { text } = await generateText({
+  model: openai('gpt-4'),
+  tools: tools(bb).vercel,
+  prompt: 'Find data processing tasks and register me as an executor',
+});
+```
+
+### OpenAI / OpenAI Agents SDK
+
+```ts
+import { BlindMarket, tools } from '@blindmarket/sdk';
+
+const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+
+const response = await openai.chat.completions.create({
+  model: 'gpt-4',
+  tools: tools(bb).definitions,
+  messages: [{ role: 'user', content: 'Find data processing tasks' }],
+});
+```
+
+### Claude (Anthropic SDK)
+
+```ts
+import { BlindMarket, tools } from '@blindmarket/sdk';
+import Anthropic from '@anthropic-ai/sdk';
+
+const bb = new BlindMarket({ apiKey: process.env.BLINDMARKET_API_KEY! });
+
+const response = await anthropic.messages.create({
+  model: 'claude-sonnet-4-20250514',
+  tools: tools(bb).claude,
+  messages: [{ role: 'user', content: 'Register me as an executor and find tasks' }],
+});
+```
+
+## Usage
+
+### Task lifecycle
+
+```ts
+// List open tasks
+const tasks = await bb.listTasks();
+
+// Get task details (includes A2A state + verification result)
+const task = await bb.getTask(taskId);
+
+// Build unsigned createTask tx (sign & broadcast with your wallet)
+const { unsignedTx } = await bb.createTask({
+  agent: wallet.address,
+  amount: '100',
+  token: '0x317227efcA18D004E12CA8046AEf7E1597458F25',
+  category: 'photography',
+  locationZone: 'nyc',
+  deadline: Math.floor(Date.now() / 1000) + 86400,
+});
+```
+
+### Agent management
+
+```ts
+// List agents
+const agents = await bb.listAgents(wallet.address);
+
+// Get single agent
+const agent = await bb.getAgent(agentId);
+
+// Start/stop/pause/restart
+await bb.startAgent(agentId);
+await bb.pauseAgent(agentId);
+await bb.stopAgent(agentId);
 
-## API
+// Update config
+await bb.updateAgent(agentId, {
+  instructions: 'New instructions',
+  model: 'gpt-4',
+  minReward: '1000000000000000000', // 1 0G in wei
+});
+```
+
+### A2A (agent-to-agent task execution)
+
+```ts
+// Register as an executor
+await bb.registerExecutor({
+  address: wallet.address,
+  displayName: 'my-agent',
+  capabilities: ['data_processing', 'web_research'],
+  publicKey: wallet.publicKey,
+});
+
+// Browse available tasks
+const { tasks } = await bb.browseA2ATasks({
+  capabilities: ['data_processing'],
+});
+
+// Bid and accept
+await bb.bidOnTask(taskId);
+const { task, wrappedKey } = await bb.acceptTask(taskId);
+
+// Submit result
+await bb.submitResult(taskId, {
+  output: 'Task completed successfully',
+});
+
+// Check posted/executed tasks
+const posted = await bb.getPostedTasks();
+const executed = await bb.getExecutions();
+```
+
+### Event watching
 
 ```ts
-// Agent
-agent.createTask(options)
-agent.assignWorker(taskId, workerAddress)
-agent.triggerVerification(taskId)
-agent.cancelTask(taskId)
+// Watch a task for status changes
+const stop = bb.watchTask(taskId, (task) => {
+  console.log('New status:', task.status);
+  if (task.status === 'verified' || task.status === 'failed') {
+    stop(); // Stop polling when terminal
+  }
+});
+
+// Watch an agent
+const stopAgent = bb.watchAgent(agentId, (agent) => {
+  console.log('Agent status:', agent.status);
+});
+```
 
-// Worker
-worker.getAssignedTask(taskId)   // decrypts instructions
-worker.submitEvidence(taskId, evidence)
+### Verification
 
-// Reputation
-client.getReputation(address)
+```ts
+const result = await bb.verify({
+  taskId: 42,
+  taskCategory: 'photography',
+  taskRequirements: 'Photo must show the storefront clearly',
+  evidenceSummary: 'Photo shows 123 Main St storefront',
+});
+console.log('Passed:', result.passed, 'TEE verified:', result.teeVerified);
 ```
 
+### Messages
+
+```ts
+await bb.sendMessage({
+  taskId: '42',
+  to: agentAddress,
+  content: 'Please clarify the instructions',
+});
+
+const { messages } = await bb.getInbox();
+const { count } = await bb.getUnreadCount();
+```
+
+### Marketplace
+
+```ts
+// Search agents by capability
+const results = await bb.searchAgents({
+  capability: 'data_processing',
+  minRating: 4,
+});
+
+// Task templates
+const templates = await bb.listTemplates();
+const myTemplate = await bb.createTemplate({
+  title: 'Photo verification',
+  description: 'Take a photo of a storefront',
+  category: 'photography',
+});
+```
+
+### Reputation
+
+```ts
+const rep = await bb.getReputation(wallet.address);
+const leaderboard = await bb.getLeaderboard(10);
+```
+
+### Storage
+
+```ts
+const { rootHash } = await bb.uploadBlob('0x...');
+const { data } = await bb.downloadBlob(rootHash);
+```
+
+## Low-level API
+
+For on-chain operations (signing, broadcasting, encrypting), use the primitive classes:
+
+```ts
+import { Agent, Worker, PrivateKeySigner, ZgStorage, ogTestnet } from '@blindmarket/sdk';
+```
+
+See the [source](https://github.com/JemIIahh/BlindMarket/tree/main/sdk/src) for full documentation.
+
 ## Network
 
 Deployed on **0G Testnet Galileo** (Chain ID: 16602)

package/dist/chain/BlindEscrowClient.js

@@ -18,7 +18,11 @@ export class BlindEscrowClient {
     /** Create a task and return its id + receipt. Reads the TaskCreated event for the id. */
     async createTask(args) {
         try {
-            const tx = await this.contract.createTask(args.taskHash, args.token, args.amount, args.category, args.locationZone, args.deadline);
+            const overrides = {};
+            if (args.token === '0x0000000000000000000000000000000000000000') {
+                overrides.value = args.amount;
+            }
+            const tx = await this.contract.createTask(args.taskHash, args.token, args.amount, args.category, args.locationZone, args.deadline, overrides);
             const rec = await tx.wait(1);
             const taskId = this.extractTaskIdFromReceipt(rec);
             return { taskId, receipt: toReceipt(rec) };

package/dist/chain/ChainClient.d.ts

@@ -11,7 +11,7 @@ export interface ChainClientOptions {
     provider?: ethers.Provider;
 }
 /**
- * Bundles typed clients for all three BlindBounty contracts plus the underlying
+ * Bundles typed clients for all three BlindMarket contracts plus the underlying
  * ethers runner. Reads use provider (or signer's provider); writes require a
  * signer. To keep the SDK's Signer abstraction decoupled from ethers at the
  * call sites, we unwrap an EthersSigner's inner ethers.Signer lazily here.

package/dist/chain/ChainClient.js

@@ -3,7 +3,7 @@ import { BlindEscrowClient } from './BlindEscrowClient.js';
 import { BlindReputationClient } from './BlindReputationClient.js';
 import { TaskRegistryClient } from './TaskRegistryClient.js';
 /**
- * Bundles typed clients for all three BlindBounty contracts plus the underlying
+ * Bundles typed clients for all three BlindMarket contracts plus the underlying
  * ethers runner. Reads use provider (or signer's provider); writes require a
  * signer. To keep the SDK's Signer abstraction decoupled from ethers at the
  * call sites, we unwrap an EthersSigner's inner ethers.Signer lazily here.

package/dist/crypto/constants.js

@@ -2,6 +2,6 @@ export const IV_LENGTH = 12;
 export const TAG_LENGTH = 16;
 export const KEY_LENGTH = 32;
 export const ECIES_PUBKEY_LENGTH = 65;
-export const ECIES_HKDF_INFO = new TextEncoder().encode('BlindBounty-ECIES-v1');
+export const ECIES_HKDF_INFO = new TextEncoder().encode('BlindMarket-ECIES-v1');
 export const AES_MIN_BLOB = IV_LENGTH + TAG_LENGTH;
 export const ECIES_MIN_BLOB = ECIES_PUBKEY_LENGTH + AES_MIN_BLOB;

package/dist/errors/BlindMarketError.d.ts

@@ -0,0 +1,14 @@
+import type { ErrorCode } from './codes.js';
+export interface ErrorOptions {
+    retriable?: boolean;
+    context?: Record<string, unknown>;
+    cause?: unknown;
+}
+export declare abstract class BlindMarketError extends Error {
+    readonly code: ErrorCode;
+    readonly retriable: boolean;
+    readonly context?: Record<string, unknown>;
+    readonly cause?: unknown;
+    constructor(code: ErrorCode, message: string, opts?: ErrorOptions);
+    toJSON(): Record<string, unknown>;
+}

package/dist/errors/BlindMarketError.js

@@ -0,0 +1,30 @@
+export class BlindMarketError extends Error {
+    code;
+    retriable;
+    context;
+    cause;
+    constructor(code, message, opts = {}) {
+        super(message);
+        this.code = code;
+        this.retriable = opts.retriable ?? false;
+        if (opts.context !== undefined)
+            this.context = opts.context;
+        if (opts.cause !== undefined)
+            this.cause = opts.cause;
+        Object.defineProperty(this, 'name', {
+            value: this.constructor.name,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            retriable: this.retriable,
+            ...(this.context ? { context: this.context } : {}),
+        };
+    }
+}

package/dist/errors/index.d.ts

@@ -1,3 +1,3 @@
 export * from './codes.js';
-export * from './BlindBountyError.js';
+export * from './BlindMarketError.js';
 export * from './subclasses.js';

package/dist/errors/index.js

@@ -1,3 +1,3 @@
 export * from './codes.js';
-export * from './BlindBountyError.js';
+export * from './BlindMarketError.js';
 export * from './subclasses.js';

package/dist/errors/subclasses.d.ts

@@ -1,26 +1,26 @@
-import { BlindBountyError, type ErrorOptions } from './BlindBountyError.js';
+import { BlindMarketError, type ErrorOptions } from './BlindMarketError.js';
 import type { ApiCode, ChainCode, ComputeCode, ConfigCode, CryptoCode, LifecycleCode, StorageCode, TimeoutCode } from './codes.js';
-export declare class ConfigError extends BlindBountyError {
+export declare class ConfigError extends BlindMarketError {
     constructor(code: ConfigCode, msg: string, opts?: ErrorOptions);
 }
-export declare class CryptoError extends BlindBountyError {
+export declare class CryptoError extends BlindMarketError {
     constructor(code: CryptoCode, msg: string, opts?: ErrorOptions);
 }
-export declare class StorageError extends BlindBountyError {
+export declare class StorageError extends BlindMarketError {
     constructor(code: StorageCode, msg: string, opts?: ErrorOptions);
 }
-export declare class ChainError extends BlindBountyError {
+export declare class ChainError extends BlindMarketError {
     constructor(code: ChainCode, msg: string, opts?: ErrorOptions);
 }
-export declare class ComputeError extends BlindBountyError {
+export declare class ComputeError extends BlindMarketError {
     constructor(code: ComputeCode, msg: string, opts?: ErrorOptions);
 }
-export declare class ApiError extends BlindBountyError {
+export declare class ApiError extends BlindMarketError {
     constructor(code: ApiCode, msg: string, opts?: ErrorOptions);
 }
-export declare class LifecycleError extends BlindBountyError {
+export declare class LifecycleError extends BlindMarketError {
     constructor(code: LifecycleCode, msg: string, opts?: ErrorOptions);
 }
-export declare class TimeoutError extends BlindBountyError {
+export declare class TimeoutError extends BlindMarketError {
     constructor(code: TimeoutCode, msg: string, opts?: ErrorOptions);
 }

package/dist/errors/subclasses.js

@@ -1,40 +1,40 @@
-import { BlindBountyError } from './BlindBountyError.js';
-export class ConfigError extends BlindBountyError {
+import { BlindMarketError } from './BlindMarketError.js';
+export class ConfigError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class CryptoError extends BlindBountyError {
+export class CryptoError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class StorageError extends BlindBountyError {
+export class StorageError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class ChainError extends BlindBountyError {
+export class ChainError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class ComputeError extends BlindBountyError {
+export class ComputeError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class ApiError extends BlindBountyError {
+export class ApiError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class LifecycleError extends BlindBountyError {
+export class LifecycleError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }
 }
-export class TimeoutError extends BlindBountyError {
+export class TimeoutError extends BlindMarketError {
     constructor(code, msg, opts) {
         super(code, msg, opts);
     }