@blindmarket/sdk 0.1.6 → 0.1.8

package/dist/chain/domain-types.d.ts

@@ -0,0 +1,77 @@
+import type { Address, Hex, TaskId, TaskStatus } from '../types.js';
+export type BlockchainType = 'evm';
+/** Base fields shared by all chain network configs. */
+export interface NetworkBase {
+    name: string;
+    chainType: BlockchainType;
+    rpc: string[];
+    explorer?: string;
+}
+/** EVM-compatible chain network config (0G, Ethereum, Polygon, etc.). */
+export interface EVMNetwork extends NetworkBase {
+    chainType: 'evm';
+    chainId: number;
+    contracts: {
+        escrow: Address;
+        registry: Address;
+        reputation: Address;
+        usdc: Address;
+    };
+    indexer?: string;
+    broker?: string;
+}
+/** Union of all supported chain network configs. */
+export type Network = EVMNetwork;
+/** Parameters for creating a task on any chain. */
+export interface CreateTaskParams {
+    taskHash: Hex;
+    token: Address | string;
+    amount: bigint;
+    category: string;
+    locationZone: string;
+    deadline: bigint;
+    /** Per-task verifier address (agent-verification mode). Optional. */
+    verifierAgent?: string;
+}
+/** Decoded on-chain task representation (chain-agnostic). */
+export interface DomainTask {
+    taskId: TaskId;
+    agent: string;
+    worker: string;
+    token: string;
+    amount: bigint;
+    taskHash: Hex;
+    evidenceHash: Hex;
+    status: TaskStatus;
+    category: string;
+    locationZone: string;
+    createdAt: Date;
+    deadline: Date;
+}
+/** Task metadata used for discovery / listing. */
+export interface DomainTaskMeta {
+    taskId: TaskId;
+    agent: string;
+    category: string;
+    locationZone: string;
+    reward: bigint;
+    createdAt: Date;
+    isOpen: boolean;
+}
+/** On-chain reputation snapshot (chain-agnostic). */
+export interface DomainReputation {
+    tasksCompleted: bigint;
+    totalScore: bigint;
+    disputes: bigint;
+    avgScore: number;
+}
+/** Transaction receipt (chain-agnostic). */
+export interface DomainTxReceipt {
+    hash: string;
+    blockNumber?: number;
+}
+/** Signer abstraction that works across chains. */
+export interface ChainSigner {
+    getAddress(): Promise<string>;
+    getChainType(): BlockchainType;
+}

package/dist/chain/domain-types.js

@@ -0,0 +1 @@
+export {};

package/dist/chain/evm/EVMChainAdapter.d.ts

@@ -0,0 +1,56 @@
+import { ethers } from 'ethers';
+import { type ChainClientOptions } from '../ChainClient.js';
+import type { CreateTaskParams, DomainReputation, DomainTask, DomainTaskMeta, DomainTxReceipt, EVMNetwork } from '../domain-types.js';
+import type { IBlindMarketChain } from '../IBlindMarketChain.js';
+/**
+ * EVM-compatible implementation of IBlindMarketChain.
+ *
+ * Wraps the existing ChainClient (which bundles BlindEscrowClient,
+ * TaskRegistryClient, and BlindReputationClient) and translates domain
+ * operations into ethers v6 contract calls on EVM chains (0G, Ethereum, etc.).
+ */
+export declare class EVMChainAdapter implements IBlindMarketChain {
+    readonly network: EVMNetwork;
+    private client;
+    private signer;
+    constructor(opts: ChainClientOptions);
+    getAddress(): Promise<string>;
+    createTask(params: CreateTaskParams): Promise<{
+        taskId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    assignWorker(taskId: bigint, worker: string): Promise<DomainTxReceipt>;
+    submitEvidence(taskId: bigint, evidenceHash: string): Promise<DomainTxReceipt>;
+    completeVerification(taskId: bigint, passed: boolean): Promise<DomainTxReceipt>;
+    cancelTask(taskId: bigint): Promise<DomainTxReceipt>;
+    claimTimeout(taskId: bigint): Promise<DomainTxReceipt>;
+    raiseDispute(taskId: bigint): Promise<DomainTxReceipt>;
+    resolveDispute(taskId: bigint, workerFavored: boolean): Promise<DomainTxReceipt>;
+    getTask(taskId: bigint): Promise<DomainTask>;
+    isTaskExpired(taskId: bigint): Promise<boolean>;
+    publishTask(taskId: bigint, _meta: Omit<DomainTaskMeta, 'taskId'> & {
+        taskId?: bigint;
+    }): Promise<DomainTxReceipt>;
+    closeTask(taskId: bigint): Promise<DomainTxReceipt>;
+    getOpenTasks(offset: bigint, limit: bigint): Promise<DomainTaskMeta[]>;
+    openTaskCount(): Promise<bigint>;
+    totalTasks(): Promise<bigint>;
+    rateWorker(worker: string, score: number, taskId: bigint): Promise<DomainTxReceipt>;
+    recordDispute(worker: string, taskId: bigint): Promise<DomainTxReceipt>;
+    getReputation(worker: string): Promise<DomainReputation>;
+    hasBeenRated(worker: string, taskId: bigint): Promise<boolean>;
+    mintAgent(params: {
+        to: string;
+        encryptedURI: string;
+        metadataHash: string;
+    }): Promise<{
+        tokenId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    getEncryptedURI(_tokenId: bigint): Promise<string>;
+    getBalance(address: string): Promise<bigint>;
+    /** Get the underlying ethers Provider for raw queries. */
+    getProvider(): ethers.Provider;
+    /** Get the underlying ethers Signer (if configured). */
+    getEthersSigner(): ethers.Signer | undefined;
+}

package/dist/chain/evm/EVMChainAdapter.js

@@ -0,0 +1,161 @@
+import { ChainClient } from '../ChainClient.js';
+import { resolveNetwork } from '../../network/resolve.js';
+/**
+ * EVM-compatible implementation of IBlindMarketChain.
+ *
+ * Wraps the existing ChainClient (which bundles BlindEscrowClient,
+ * TaskRegistryClient, and BlindReputationClient) and translates domain
+ * operations into ethers v6 contract calls on EVM chains (0G, Ethereum, etc.).
+ */
+export class EVMChainAdapter {
+    network;
+    client;
+    signer;
+    constructor(opts) {
+        const resolved = resolveNetwork(opts.network);
+        if (resolved.chainType !== 'evm') {
+            throw new Error(`EVMChainAdapter requires an EVM network, got ${resolved.chainType}`);
+        }
+        this.network = resolved;
+        this.client = new ChainClient(opts);
+        this.signer = opts.signer;
+    }
+    async getAddress() {
+        if (!this.signer)
+            throw new Error('No signer configured');
+        return this.signer.getAddress();
+    }
+    // ── Task lifecycle ──────────────────────────────────────────────────────
+    async createTask(params) {
+        const result = await this.client.escrow.createTask({
+            taskHash: params.taskHash,
+            token: params.token,
+            amount: params.amount,
+            category: params.category,
+            locationZone: params.locationZone,
+            deadline: params.deadline,
+        });
+        return {
+            taskId: result.taskId,
+            receipt: {
+                hash: result.receipt.hash,
+                blockNumber: result.receipt.blockNumber,
+            },
+        };
+    }
+    async assignWorker(taskId, worker) {
+        const receipt = await this.client.escrow.assignWorker(taskId, worker);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async submitEvidence(taskId, evidenceHash) {
+        const receipt = await this.client.escrow.submitEvidence(taskId, evidenceHash);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async completeVerification(taskId, passed) {
+        const receipt = await this.client.escrow.completeVerification(taskId, passed);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async cancelTask(taskId) {
+        const receipt = await this.client.escrow.cancelTask(taskId);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async claimTimeout(taskId) {
+        const receipt = await this.client.escrow.claimTimeout(taskId);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async raiseDispute(taskId) {
+        const receipt = await this.client.escrow.raiseDispute(taskId);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async resolveDispute(taskId, workerFavored) {
+        const receipt = await this.client.escrow.resolveDispute(taskId, workerFavored);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async getTask(taskId) {
+        const onChain = await this.client.escrow.getTask(taskId);
+        return {
+            ...onChain,
+            category: '', // OnChainTask doesn't decode these contract fields;
+            locationZone: '', // they are present in the Solidity Task struct.
+        };
+    }
+    async isTaskExpired(taskId) {
+        return this.client.escrow.isTaskExpired(taskId);
+    }
+    // ── Task discovery ──────────────────────────────────────────────────────
+    async publishTask(taskId, _meta) {
+        // The EVM contracts publish tasks via the escrow's TaskCreated event
+        // (handled by the backend indexer). This is a no-op at the adapter level
+        // for EVM — the registry is updated by the escrow contract internally.
+        // Return a stub receipt for interface compatibility.
+        return { hash: '0x0', blockNumber: 0 };
+    }
+    async closeTask(taskId) {
+        const receipt = await this.client.registry.closeTask(taskId);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async getOpenTasks(offset, limit) {
+        const taskIds = await this.client.registry.getOpenTasks(offset, limit);
+        const metas = await Promise.all(taskIds.map(async (tid) => {
+            const meta = await this.client.registry.getTaskMeta(tid);
+            return {
+                taskId: tid,
+                agent: '', // EVM TaskRegistry stores agent; use meta directly
+                category: meta.category,
+                locationZone: meta.locationZone,
+                reward: meta.reward,
+                createdAt: meta.createdAt,
+                isOpen: true,
+            };
+        }));
+        return metas;
+    }
+    async openTaskCount() {
+        return this.client.registry.openTaskCount();
+    }
+    async totalTasks() {
+        return this.client.registry.totalTasks();
+    }
+    // ── Reputation ──────────────────────────────────────────────────────────
+    async rateWorker(worker, score, taskId) {
+        const receipt = await this.client.reputation.rate(worker, score, taskId);
+        return { hash: receipt.hash, blockNumber: receipt.blockNumber };
+    }
+    async recordDispute(worker, taskId) {
+        // EVM BlindReputation doesn't expose recordDispute as a standalone client
+        // method in the SDK — the escrow calls it internally. For external callers
+        // we throw. The escrow contract handles dispute recording via its own path.
+        throw new Error('recordDispute is handled internally by BlindEscrow on EVM chains');
+    }
+    async getReputation(worker) {
+        return this.client.reputation.getReputation(worker);
+    }
+    async hasBeenRated(worker, taskId) {
+        return this.client.reputation.hasBeenRated(worker, taskId);
+    }
+    // ── Agent identity ──────────────────────────────────────────────────────
+    async mintAgent(params) {
+        // INFT minting is handled by the backend (services/chain.ts → inft.mint()).
+        // The SDK doesn't expose a direct INFT client. For direct EVM calls,
+        // consumers can use the raw ethers.Contract via the unwrapped signer.
+        throw new Error('INFT minting is backend-managed on EVM chains. Use the REST API or raw ethers.Contract.');
+    }
+    async getEncryptedURI(_tokenId) {
+        throw new Error('INFT URI reading is backend-managed on EVM chains. Use the REST API or raw ethers.Contract.');
+    }
+    // ── Queries ─────────────────────────────────────────────────────────────
+    async getBalance(address) {
+        return this.client.provider.getBalance(address);
+    }
+    // ── Accessors for direct ethers access (advanced use) ───────────────────
+    /** Get the underlying ethers Provider for raw queries. */
+    getProvider() {
+        return this.client.provider;
+    }
+    /** Get the underlying ethers Signer (if configured). */
+    getEthersSigner() {
+        if (!this.signer)
+            return undefined;
+        return this.signer.inner;
+    }
+}

package/dist/chain/evm/index.d.ts

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

package/dist/chain/evm/index.js

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

package/dist/chain/index.d.ts

@@ -4,3 +4,7 @@ export * from './BlindEscrowClient.js';
 export * from './TaskRegistryClient.js';
 export * from './BlindReputationClient.js';
 export * from './ChainClient.js';
+export * from './IBlindMarketChain.js';
+export * from './domain-types.js';
+export * from './createChainAdapter.js';
+export * from './evm/index.js';

package/dist/chain/index.js

@@ -4,3 +4,8 @@ export * from './BlindEscrowClient.js';
 export * from './TaskRegistryClient.js';
 export * from './BlindReputationClient.js';
 export * from './ChainClient.js';
+// Chain-agnostic domain interface (EVM only — 0G Chain)
+export * from './IBlindMarketChain.js';
+export * from './domain-types.js';
+export * from './createChainAdapter.js';
+export * from './evm/index.js';

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/{BlindBountyError.d.ts → BlindMarketError.d.ts}

@@ -4,7 +4,7 @@ export interface ErrorOptions {
     context?: Record<string, unknown>;
     cause?: unknown;
 }
-export declare abstract class BlindBountyError extends Error {
+export declare abstract class BlindMarketError extends Error {
     readonly code: ErrorCode;
     readonly retriable: boolean;
     readonly context?: Record<string, unknown>;

package/dist/errors/{BlindBountyError.js → BlindMarketError.js}

@@ -1,4 +1,4 @@
-export class BlindBountyError extends Error {
+export class BlindMarketError extends Error {
     code;
     retriable;
     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);
     }

package/dist/executor/WorkerRuntime.d.ts

@@ -0,0 +1,113 @@
+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;
+}
+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_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;
+    private decodeWrappedKey;
+    private hexToBytes;
+}