@blindmarket/sdk 0.1.8 → 0.5.0

package/src/types.ts

@@ -1,297 +0,0 @@
-export type Address = `0x${string}`;
-export type Hex = `0x${string}`;
-export type TaskId = bigint;
-export type RootHash = Hex;
-
-export type TokenSymbol = 'USDC' | 'A0GI' | string;
-
-export interface TokenRef {
-  address: Address;
-  symbol?: TokenSymbol;
-  decimals?: number;
-}
-
-export interface Reward {
-  token: Address | TokenSymbol;
-  amount: bigint;
-}
-
-export type TaskStatus =
-  | 'funded'
-  | 'assigned'
-  | 'submitted'
-  | 'verified'
-  | 'completed'
-  | 'cancelled'
-  | 'disputed';
-
-export interface TaskMetadata {
-  category: string;
-  locationZone: string;
-  reward: Reward;
-  deadline?: Date;
-  extra?: Record<string, string>;
-}
-
-export interface TaskRecord extends TaskMetadata {
-  taskId: TaskId;
-  agent: Address;
-  worker?: Address;
-  taskHash: RootHash;
-  evidenceHash?: RootHash;
-  status: TaskStatus;
-  createdAt: Date;
-}
-
-export interface TaskKey {
-  /** AES-256 symmetric key (32 bytes) used to encrypt task content. */
-  aesKey: Uint8Array;
-  createdAt: Date;
-}
-
-export interface TaskKeyRef {
-  taskId: TaskId;
-  createdAt: Date;
-}
-
-export interface UploadResult {
-  rootHash: RootHash;
-  txHash?: Hex;
-  size: number;
-}
-
-export interface VerificationResult {
-  passed: boolean;
-  confidence: number;
-  model: string;
-  attestation?: Hex;
-  completedAt: Date;
-}
-
-export interface TxReceiptLike {
-  hash: Hex;
-  blockNumber: number;
-  gasUsed: bigint;
-}
-
-export type Awaitable<T> = T | Promise<T>;
-
-// ── REST API types ──────────────────────────────────────────────────────────
-
-export interface HealthStatus {
-  status: string;
-  timestamp: string;
-}
-
-export interface PlatformStats {
-  openTasks: number;
-  activeAgents: number;
-  activeValidators: number;
-  totalAgents: number;
-  registeredUsers: number;
-  completedTasks: number;
-  activeWorkers: number;
-}
-
-export interface OpenTask {
-  id: number;
-  agent: Address;
-  worker?: Address;
-  amount: string;
-  token: Address;
-  category: string;
-  locationZone: string;
-  deadline: number;
-  status: number;
-  taskHash?: Hex;
-}
-
-export interface CreateTaskTx {
-  unsignedTx: {
-    to: Address;
-    data: Hex;
-    value?: string;
-  };
-}
-
-export interface TaskDetail extends OpenTask {
-  metadata?: Record<string, unknown>;
-  a2aState?: A2ATaskState;
-}
-
-export interface A2ATaskState {
-  taskId: string;
-  status: string;
-  executorAddress?: string;
-  acceptedAt?: string;
-  submittedAt?: string;
-  resultData?: Record<string, unknown> | null;
-  verificationResult?: {
-    passed: boolean;
-    reasons: string[];
-    score?: number;
-    breakdown?: Array<{ name: string; score: number; weight: number; reason: string; error?: string }>;
-  };
-  assignTxHash?: Hex;
-  verifyTxHash?: Hex;
-  wrappedKeys?: Record<string, string>;
-}
-
-export interface ExecutorProfile {
-  address: Address;
-  displayName: string;
-  capabilities: AgentCapability[];
-  publicKey: string;
-  reputation: number;
-  tasksCompleted: number;
-  totalEarnedRaw: string;
-  minReward?: string;
-  preferredCapabilities?: AgentCapability[];
-  registeredAt: string;
-  decayedScore?: number;
-  disputeRatio?: number;
-  avgRating?: number;
-}
-
-export interface RegisterExecutorInput {
-  address: Address;
-  displayName: string;
-  capabilities: AgentCapability[];
-  publicKey: string;
-  agentCardUrl?: string;
-  mcpEndpointUrl?: string;
-  minReward?: string;
-  preferredCapabilities?: AgentCapability[];
-}
-
-/** Params for BlindMarket.createAgent() — generates wallet + registers executor in one call. */
-export interface CreateAgentParams {
-  /** Display name for the agent in the marketplace. */
-  displayName: string;
-  /** Capabilities this agent offers. Use AgentCap.DATA_PROCESSING etc. */
-  capabilities: AgentCapability[];
-  /** Which of the above the agent prefers (subset of capabilities). */
-  preferredCapabilities?: AgentCapability[];
-  /** Minimum reward per task (wei string). */
-  minReward?: string;
-  /** Agent card URL for marketplace display. */
-  agentCardUrl?: string;
-  /** MCP endpoint URL for tool-based agents. */
-  mcpEndpointUrl?: string;
-}
-
-/** Result of BlindMarket.createAgent(). */
-export interface CreateAgentResult {
-  executor: ExecutorProfile;
-  wallet: {
-    address: Address;
-    publicKey: string;
-    privateKey: string; // hex with 0x prefix — ⚠️ store securely, shown once
-  };
-}
-
-export interface DeployedAgentInfo {
-  id: string;
-  name: string;
-  ownerAddress: Address;
-  walletAddress: Address;
-  publicKey: string;
-  status: string;
-  provider: string;
-  model: string;
-  capabilities: AgentCapability[];
-  inftTokenId?: number;
-  deployedAt: string;
-  lastActiveAt?: string;
-  minReward?: string;
-}
-
-export interface AgentWalletInfo {
-  walletAddress: Address;
-  publicKey: string;
-}
-
-export interface ReputationInfo {
-  address: Address;
-  onChainScore: number;
-  decayedScore: number;
-  totalTasks: number;
-  disputesLost: number;
-  disputeRatio: number;
-}
-
-export interface LeaderboardEntry extends ReputationInfo {
-  rank: number;
-  displayName?: string;
-}
-
-export interface StorageUploadResult {
-  rootHash: RootHash;
-  size: number;
-}
-
-export interface Message {
-  id: number;
-  taskId: string;
-  fromAddress: Address;
-  toAddress: Address;
-  content: string;
-  read: boolean;
-  createdAt: string;
-}
-
-export interface AgentSearchResult {
-  address: Address;
-  displayName: string;
-  capabilities: string[];
-  avgRating: number;
-  reviewCount: number;
-  badgeCount: number;
-  reputation: number;
-}
-
-export interface TaskTemplate {
-  id: number;
-  title: string;
-  description: string;
-  category: string;
-  instructions: string;
-  verificationCriteria: Record<string, unknown>;
-  requiredCapabilities?: string[];
-  estimatedReward?: string;
-}
-
-export interface VerifyTaskInput {
-  taskId: number;
-  taskCategory: string;
-  taskRequirements: string;
-  evidenceSummary: string;
-}
-
-// ── Agent capabilities ───────────────────────────────────────────────────────
-
-/** Dot-notation access to valid capability strings. */
-export const AgentCap = {
-  DATA_PROCESSING: 'data_processing',
-  WEB_RESEARCH: 'web_research',
-  CODE_EXECUTION: 'code_execution',
-  CONTENT_GENERATION: 'content_generation',
-  API_INTEGRATION: 'api_integration',
-  TEXT_ANALYSIS: 'text_analysis',
-  TRANSLATION: 'translation',
-  SUMMARIZATION: 'summarization',
-  IMAGE_ANALYSIS: 'image_analysis',
-  DOCUMENT_PROCESSING: 'document_processing',
-  MATH_COMPUTATION: 'math_computation',
-  DATA_EXTRACTION: 'data_extraction',
-  REPORT_GENERATION: 'report_generation',
-  CODE_REVIEW: 'code_review',
-  TESTING: 'testing',
-  SCHEDULING: 'scheduling',
-  EMAIL_DRAFTING: 'email_drafting',
-  SOCIAL_MEDIA: 'social_media',
-  MARKET_RESEARCH: 'market_research',
-  COMPETITIVE_ANALYSIS: 'competitive_analysis',
-} as const;
-
-export type AgentCapability = typeof AgentCap[keyof typeof AgentCap];

package/src/verifier/index.ts

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

package/src/worker/Worker.ts

@@ -1,98 +0,0 @@
-import type { BlindEscrowClient, OnChainTask, TaskRegistryClient } from '../chain/index.js';
-import { aesDecrypt, eciesDecrypt, sealEvidence } from '../crypto/index.js';
-import type { EventBus, SdkEvents } from '../events/index.js';
-import type { Signer } from '../signer/index.js';
-import type { Storage } from '../storage/index.js';
-import type { Hex, RootHash, TaskId, TxReceiptLike } from '../types.js';
-
-export interface WorkerDeps {
-  escrow: BlindEscrowClient;
-  registry: TaskRegistryClient;
-  storage: Storage;
-  signer: Signer;
-  events?: EventBus<SdkEvents>;
-}
-
-export interface DecryptInstructionsInput {
-  /** ECIES-wrapped AES key delivered out-of-band by the agent (e.g. via the backend API). */
-  wrappedKey: Uint8Array;
-  /** Worker's private key, hex with or without 0x prefix. */
-  workerPrivKey: string;
-  /** Storage root hash from the on-chain task metadata. */
-  taskHash: RootHash;
-}
-
-export interface SubmitEvidenceInput {
-  taskId: TaskId;
-  evidence: string | Uint8Array;
-  /** Agent's uncompressed secp256k1 pubkey (retrieved via the backend or chain). */
-  agentPubKey: string;
-  /** TEE enclave pubkey for Sealed Inference (from 0G Compute broker). */
-  enclavePubKey: string;
-}
-
-export interface SubmitEvidenceResult {
-  rootHash: RootHash;
-  txHash: Hex;
-  receipt: TxReceiptLike;
-}
-
-/**
- * Worker-side flows: browse open tasks, decrypt assigned instructions, seal
- * evidence for agent + TEE, and claim payment after the deadline if
- * verification stalls. Peer pubkeys and wrapped keys are passed explicitly;
- * the SDK does not assume a specific message-passing substrate.
- */
-export class Worker {
-  constructor(private readonly deps: WorkerDeps) {}
-
-  async browse(offset: bigint, limit: bigint): Promise<TaskId[]> {
-    return this.deps.registry.getOpenTasks(offset, limit);
-  }
-
-  async getTaskDetail(taskId: TaskId): Promise<OnChainTask> {
-    return this.deps.escrow.getTask(taskId);
-  }
-
-  async decryptInstructions(input: DecryptInstructionsInput): Promise<Uint8Array> {
-    const aesKey = await eciesDecrypt(input.wrappedKey, input.workerPrivKey);
-    const ciphertext = await this.deps.storage.download(input.taskHash);
-    return aesDecrypt(ciphertext, aesKey);
-  }
-
-  async submitEvidence(input: SubmitEvidenceInput): Promise<SubmitEvidenceResult> {
-    const evidenceBytes = typeof input.evidence === 'string'
-      ? new TextEncoder().encode(input.evidence)
-      : input.evidence;
-
-    const { envelope } = await sealEvidence({
-      evidence: evidenceBytes,
-      agentPubKey: input.agentPubKey,
-      enclavePubKey: input.enclavePubKey,
-    });
-
-    const uploaded = await this.deps.storage.upload(envelope);
-    const rootHash = uploaded.rootHash;
-
-    const receipt = await this.deps.escrow.submitEvidence(input.taskId, rootHash);
-
-    this.deps.events?.emit('evidence.submitted', {
-      taskId: input.taskId,
-      rootHash,
-      txHash: receipt.hash,
-    });
-
-    return { rootHash, txHash: receipt.hash, receipt };
-  }
-
-  /**
-   * Worker escape hatch: reclaim escrow after the deadline if completeVerification
-   * was never called. Payment released per contract logic (85% worker, 15% treasury
-   * or full refund depending on submission state — see BlindEscrow.claimTimeout).
-   */
-  async claimTimeout(taskId: TaskId): Promise<TxReceiptLike> {
-    const receipt = await this.deps.escrow.claimTimeout(taskId);
-    this.deps.events?.emit('payment.claimed', { taskId, txHash: receipt.hash, amount: 0n });
-    return receipt;
-  }
-}

package/src/worker/index.ts

@@ -1 +0,0 @@
-export * from './Worker.js';

package/test/agent.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Agent } from '../src/agent/index.js';
-import type { BlindEscrowClient, CreateTaskArgs } from '../src/chain/index.js';
-import { aesDecrypt, eciesDecrypt, generateKeyPair, sealEvidence } 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, TaskId, TxReceiptLike } from '../src/types.js';
-
-const AGENT_PK = '0x0123456789012345678901234567890123456789012345678901234567890123';
-const WORKER_PK = '0x1000000000000000000000000000000000000000000000000000000000000001';
-const FAKE_USDC = '0x317227efcA18D004E12CA8046AEf7E1597458F25' as Address;
-const FAKE_WORKER = '0x2000000000000000000000000000000000000002' as Address;
-
-interface EscrowCall<M extends string> {
-  method: M;
-  args: unknown;
-}
-
-/**
- * In-memory BlindEscrow mock. Records every call for assertions and hands back
- * deterministic task ids / receipts so the Agent flow can be exercised without
- * a real chain.
- */
-class MockEscrow {
-  readonly calls: EscrowCall<'createTask' | 'assignWorker' | 'cancelTask'>[] = [];
-  private nextId = 1n;
-
-  async createTask(args: CreateTaskArgs) {
-    this.calls.push({ method: 'createTask', args });
-    const taskId = this.nextId++;
-    const receipt: TxReceiptLike = { hash: `0x${'a'.repeat(64)}` as Hex, blockNumber: 1, gasUsed: 21000n };
-    return { taskId, receipt };
-  }
-
-  async assignWorker(taskId: TaskId, worker: Address): Promise<TxReceiptLike> {
-    this.calls.push({ method: 'assignWorker', args: { taskId, worker } });
-    return { hash: `0x${'b'.repeat(64)}` as Hex, blockNumber: 2, gasUsed: 21000n };
-  }
-
-  async cancelTask(taskId: TaskId): Promise<TxReceiptLike> {
-    this.calls.push({ method: 'cancelTask', args: { taskId } });
-    return { hash: `0x${'c'.repeat(64)}` as Hex, blockNumber: 3, gasUsed: 21000n };
-  }
-}
-
-function mkDeps() {
-  const storage = new MemoryStorage();
-  const keystore = new InMemoryKeyStore();
-  const signer = new PrivateKeySigner(AGENT_PK);
-  const events = new EventBus<SdkEvents>();
-  const escrow = new MockEscrow();
-  return {
-    storage,
-    keystore,
-    signer,
-    events,
-    escrow,
-    agent: new Agent({
-      // biome-ignore lint/suspicious/noExplicitAny: MockEscrow matches the subset the Agent uses
-      escrow: escrow as any as BlindEscrowClient,
-      storage,
-      keystore,
-      signer,
-      events,
-    }),
-  };
-}
-
-describe('Agent.createTask', () => {
-  it('encrypts + uploads + calls chain + stashes key + emits event', async () => {
-    const { agent, escrow, storage, keystore, events } = mkDeps();
-
-    const emitted: SdkEvents['task.created'][] = [];
-    events.on('task.created', (p) => {
-      emitted.push(p);
-    });
-
-    const deadline = new Date(Date.now() + 3600_000);
-    const res = await agent.createTask({
-      instructions: 'Take 3 photos of the storefront',
-      category: 'photography',
-      locationZone: 'Lagos, NG',
-      reward: { token: FAKE_USDC, amount: 5_000000n },
-      deadline,
-    });
-
-    expect(res.taskId).toBe(1n);
-    expect(res.rootHash).toMatch(/^0x[0-9a-f]{64}$/);
-    expect(escrow.calls).toHaveLength(1);
-    expect(escrow.calls[0]?.method).toBe('createTask');
-
-    // Keystore now holds the task key for this id
-    const stored = await keystore.getTaskKey(1n);
-    expect(stored).not.toBeNull();
-    expect(stored?.aesKey).toEqual(res.taskKey.aesKey);
-
-    // The uploaded blob decrypts back to the original instructions
-    const blob = await storage.download(res.rootHash);
-    const pt = await aesDecrypt(blob, res.taskKey.aesKey);
-    expect(new TextDecoder().decode(pt)).toBe('Take 3 photos of the storefront');
-
-    // Event fired
-    expect(emitted).toHaveLength(1);
-    expect(emitted[0]?.taskId).toBe(1n);
-    expect(emitted[0]?.rootHash).toBe(res.rootHash);
-  });
-
-  it('accepts Uint8Array instructions as well as strings', async () => {
-    const { agent, storage } = mkDeps();
-    const res = await agent.createTask({
-      instructions: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
-      category: 'x',
-      locationZone: 'y',
-      reward: { token: FAKE_USDC, amount: 1n },
-      deadline: new Date(Date.now() + 3600_000),
-    });
-    const blob = await storage.download(res.rootHash);
-    const pt = await aesDecrypt(blob, res.taskKey.aesKey);
-    expect(Array.from(pt)).toEqual([0xde, 0xad, 0xbe, 0xef]);
-  });
-});
-
-describe('Agent.assignWorker', () => {
-  it('wraps the task AES key to the worker pubkey and calls chain', async () => {
-    const { agent } = mkDeps();
-    const created = await agent.createTask({
-      instructions: 'hello',
-      category: 'c',
-      locationZone: 'z',
-      reward: { token: FAKE_USDC, amount: 1n },
-      deadline: new Date(Date.now() + 3600_000),
-    });
-    const worker = generateKeyPair();
-    const result = await agent.assignWorker(created.taskId, FAKE_WORKER, worker.publicKey);
-
-    // Worker can recover the AES key from the wrapped blob
-    const recoveredKey = await eciesDecrypt(result.wrappedKey, worker.privateKey);
-    expect(recoveredKey).toEqual(created.taskKey.aesKey);
-  });
-
-  it('throws LIFECYCLE/TASK_NOT_FOUND when task key is missing', async () => {
-    const { agent } = mkDeps();
-    const worker = generateKeyPair();
-    await expect(agent.assignWorker(999n, FAKE_WORKER, worker.publicKey)).rejects.toMatchObject({
-      code: 'LIFECYCLE/TASK_NOT_FOUND',
-    });
-  });
-});
-
-describe('Agent.cancelTask', () => {
-  it('calls chain and removes the task key from keystore', async () => {
-    const { agent, keystore, events } = mkDeps();
-    const created = await agent.createTask({
-      instructions: 'hello',
-      category: 'c',
-      locationZone: 'z',
-      reward: { token: FAKE_USDC, amount: 1n },
-      deadline: new Date(Date.now() + 3600_000),
-    });
-    expect(await keystore.getTaskKey(created.taskId)).not.toBeNull();
-
-    const cancelled: SdkEvents['task.cancelled'][] = [];
-    events.on('task.cancelled', (p) => cancelled.push(p));
-
-    await agent.cancelTask(created.taskId);
-    expect(await keystore.getTaskKey(created.taskId)).toBeNull();
-    expect(cancelled).toHaveLength(1);
-  });
-});
-
-describe('Agent.fetchAndDecryptEvidence', () => {
-  it('downloads the envelope from storage and unwraps with agent privkey', async () => {
-    const { agent, storage, signer } = mkDeps();
-    const agentPub = await signer.getPublicKey();
-    const enclave = generateKeyPair();
-
-    const evidence = new TextEncoder().encode('photos + timestamps');
-    const sealed = await sealEvidence({
-      evidence,
-      agentPubKey: agentPub,
-      enclavePubKey: enclave.publicKey,
-    });
-    const { rootHash } = await storage.upload(sealed.envelope);
-
-    const recovered = await agent.fetchAndDecryptEvidence(rootHash, AGENT_PK);
-    expect(new TextDecoder().decode(recovered)).toBe('photos + timestamps');
-  });
-});
-
-// silence unused-import warning for the imported pk
-void WORKER_PK;