@blindmarket/sdk 0.1.8 → 0.5.0

package/scripts/gen-crypto-fixtures.mjs

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-/**
- * Generates cross-compat crypto fixtures using Node's built-in crypto, matching
- * backend/src/services/crypto.ts byte-for-byte. The SDK's test/crypto.compat.test.ts
- * loads these and verifies WebCrypto-based decryption produces the same plaintext.
- *
- * Run:  node scripts/gen-crypto-fixtures.mjs
- * Output: test/fixtures/crypto.json (committed to the repo; regenerate only on
- *         intentional wire-format changes).
- */
-import { createCipheriv, createECDH, hkdfSync, randomBytes } from 'node:crypto';
-import { writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const IV_LENGTH = 12;
-const TAG_LENGTH = 16;
-const KEY_LENGTH = 32;
-const ECIES_HKDF_INFO = 'BlindMarket-ECIES-v1';
-
-function aesEncrypt(plaintext, key) {
-  const iv = randomBytes(IV_LENGTH);
-  const cipher = createCipheriv('aes-256-gcm', key, iv, { authTagLength: TAG_LENGTH });
-  const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  // [IV][tag][ciphertext] — matches backend/src/services/crypto.ts
-  return Buffer.concat([iv, tag, encrypted]);
-}
-
-function eciesEncrypt(plaintext, recipientPubKeyBuf) {
-  const ephemeral = createECDH('secp256k1');
-  ephemeral.generateKeys();
-  const shared = ephemeral.computeSecret(recipientPubKeyBuf);
-  const aesKey = Buffer.from(hkdfSync('sha256', shared, '', ECIES_HKDF_INFO, KEY_LENGTH));
-  const aesBlob = aesEncrypt(plaintext, aesKey);
-  return Buffer.concat([ephemeral.getPublicKey(), aesBlob]);
-}
-
-const recipient = createECDH('secp256k1');
-recipient.generateKeys();
-const privateKey = recipient.getPrivateKey('hex');
-const publicKey = recipient.getPublicKey('hex', 'uncompressed');
-
-const plaintext = 'hello cross-compat';
-const ptBuf = Buffer.from(plaintext, 'utf-8');
-
-// AES fixture
-const aesKey = randomBytes(KEY_LENGTH);
-const aesBlob = aesEncrypt(ptBuf, aesKey);
-
-// ECIES fixture (recipient's pubkey is encoded as Buffer for computeSecret)
-const eciesBlob = eciesEncrypt(ptBuf, Buffer.from(publicKey, 'hex'));
-
-const fixture = {
-  _note:
-    'Generated by scripts/gen-crypto-fixtures.mjs using Node built-in crypto, matching backend/src/services/crypto.ts. If the SDK decrypts these back to the expected plaintext, wire-format compatibility is proven. Regenerate only on intentional format changes.',
-  hkdf_info: ECIES_HKDF_INFO,
-  keypair: { privateKey, publicKey },
-  plaintext,
-  aes: {
-    key: aesKey.toString('hex'),
-    blob: aesBlob.toString('hex'),
-  },
-  ecies: {
-    blob: eciesBlob.toString('hex'),
-  },
-};
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const out = resolve(__dirname, '..', 'test', 'fixtures', 'crypto.json');
-writeFileSync(out, `${JSON.stringify(fixture, null, 2)}\n`);
-console.log(`wrote ${out}`);

package/src/agent/Agent.ts

@@ -1,122 +0,0 @@
-import type { BlindEscrowClient } from '../chain/index.js';
-import {
-  aesEncrypt,
-  eciesEncrypt,
-  generateAesKey,
-  openEvidenceAsAgent,
-} from '../crypto/index.js';
-import { LifecycleError } from '../errors/index.js';
-import type { EventBus, SdkEvents } from '../events/index.js';
-import type { KeyStore } from '../keystore/index.js';
-import type { Signer } from '../signer/index.js';
-import type { Storage } from '../storage/index.js';
-import type { Address, Hex, Reward, TaskId, TaskKey, TxReceiptLike } from '../types.js';
-
-export interface AgentDeps {
-  escrow: BlindEscrowClient;
-  storage: Storage;
-  keystore: KeyStore;
-  signer: Signer;
-  events?: EventBus<SdkEvents>;
-}
-
-export interface CreateTaskInput {
-  instructions: string | Uint8Array;
-  category: string;
-  locationZone: string;
-  reward: Reward & { token: Address };
-  deadline: Date | bigint;
-}
-
-export interface CreateTaskResult {
-  taskId: TaskId;
-  taskKey: TaskKey;
-  rootHash: Hex;
-  txHash: Hex;
-  receipt: TxReceiptLike;
-}
-
-export interface AssignWorkerResult {
-  wrappedKey: Uint8Array;
-  receipt: TxReceiptLike;
-}
-
-/**
- * End-to-end agent flows. Composes storage + crypto + chain + keystore so a
- * caller can post an encrypted bounty in one call. Key exchange with the
- * worker is intentionally out-of-band: assignWorker() returns the wrapped
- * AES key as bytes, and the caller is responsible for delivering it (backend
- * API, DM, whatever). This keeps the SDK pluggable across different
- * message-passing substrates.
- */
-export class Agent {
-  constructor(private readonly deps: AgentDeps) {}
-
-  async createTask(input: CreateTaskInput): Promise<CreateTaskResult> {
-    const { storage, escrow, keystore, events } = this.deps;
-
-    const aesKey = await generateAesKey();
-    const plaintext = toBytes(input.instructions);
-    const ciphertext = await aesEncrypt(plaintext, aesKey);
-
-    const uploaded = await storage.upload(ciphertext);
-    const rootHash = uploaded.rootHash;
-
-    const deadline = typeof input.deadline === 'bigint' ? input.deadline : BigInt(Math.floor(input.deadline.getTime() / 1000));
-
-    const { taskId, receipt } = await escrow.createTask({
-      taskHash: rootHash,
-      token: input.reward.token as Address,
-      amount: input.reward.amount,
-      category: input.category,
-      locationZone: input.locationZone,
-      deadline,
-    });
-
-    const taskKey: TaskKey = { aesKey, createdAt: new Date() };
-    await keystore.putTaskKey(taskId, taskKey);
-
-    events?.emit('task.created', { taskId, txHash: receipt.hash, rootHash });
-    return { taskId, taskKey, rootHash, txHash: receipt.hash, receipt };
-  }
-
-  /**
-   * Wrap the stored AES key for the chosen worker and record the assignment
-   * on-chain. The caller must deliver `wrappedKey` to the worker separately
-   * (backend API, DM, etc.). Returns the wrapped bytes and the tx receipt.
-   */
-  async assignWorker(taskId: TaskId, worker: Address, workerPubKey: string): Promise<AssignWorkerResult> {
-    const { keystore, escrow, events } = this.deps;
-    const stored = await keystore.getTaskKey(taskId);
-    if (!stored) {
-      throw new LifecycleError('LIFECYCLE/TASK_NOT_FOUND', `no task key in keystore for task ${taskId}`);
-    }
-    const wrappedKey = await eciesEncrypt(stored.aesKey, workerPubKey);
-    const receipt = await escrow.assignWorker(taskId, worker);
-    events?.emit('task.assigned', { taskId, worker, txHash: receipt.hash });
-    return { wrappedKey, receipt };
-  }
-
-  async cancelTask(taskId: TaskId): Promise<TxReceiptLike> {
-    const { escrow, keystore, events } = this.deps;
-    const receipt = await this.deps.escrow.cancelTask(taskId);
-    void escrow;
-    await keystore.delete(taskId);
-    events?.emit('task.cancelled', { taskId, txHash: receipt.hash });
-    return receipt;
-  }
-
-  /**
-   * Fetch evidence by root hash, unwrap the AES key with the agent's private
-   * key (signer's key material is not accessible, so a raw private key is
-   * required), and return the decrypted evidence plaintext.
-   */
-  async fetchAndDecryptEvidence(evidenceHash: Hex, agentPrivKey: string): Promise<Uint8Array> {
-    const envelope = await this.deps.storage.download(evidenceHash);
-    return openEvidenceAsAgent(envelope, agentPrivKey);
-  }
-}
-
-function toBytes(x: string | Uint8Array): Uint8Array {
-  return typeof x === 'string' ? new TextEncoder().encode(x) : x;
-}

package/src/agent/index.ts

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

package/src/api/index.ts

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

package/src/chain/BlindEscrowClient.ts

@@ -1,196 +0,0 @@
-import { ethers } from 'ethers';
-import type { Address, Hex, TaskId, TaskStatus, TxReceiptLike } from '../types.js';
-import { BlindEscrowAbi } from './abi/index.js';
-import { wrapChainError } from './errors.js';
-
-const STATUS_BY_INDEX: TaskStatus[] = ['funded', 'assigned', 'submitted', 'verified', 'completed', 'cancelled', 'disputed'];
-
-export interface CreateTaskArgs {
-  taskHash: Hex;
-  token: Address;
-  amount: bigint;
-  category: string;
-  locationZone: string;
-  deadline: bigint;
-}
-
-export interface OnChainTask {
-  taskId: TaskId;
-  agent: Address;
-  worker: Address;
-  token: Address;
-  amount: bigint;
-  taskHash: Hex;
-  evidenceHash: Hex;
-  status: TaskStatus;
-  category: string;
-  locationZone: string;
-  createdAt: Date;
-  deadline: Date;
-}
-
-/**
- * Typed ethers v6 wrapper for the BlindEscrow contract. Every state-changing
- * method awaits one confirmation and returns a TxReceiptLike; every read
- * returns decoded values. Ethers errors are mapped to ChainError via
- * wrapChainError().
- */
-export class BlindEscrowClient {
-  readonly contract: ethers.Contract;
-  readonly address: Address;
-
-  constructor(address: Address, runner: ethers.ContractRunner) {
-    this.address = address;
-    this.contract = new ethers.Contract(address, BlindEscrowAbi, runner);
-  }
-
-  /** Create a task and return its id + receipt. Reads the TaskCreated event for the id. */
-  async createTask(args: CreateTaskArgs): Promise<{ taskId: TaskId; receipt: TxReceiptLike }> {
-    try {
-      const overrides: ethers.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) };
-    } catch (err) {
-      throw wrapChainError(err, 'createTask');
-    }
-  }
-
-  async assignWorker(taskId: TaskId, worker: Address): Promise<TxReceiptLike> {
-    return this.sendTx('assignWorker', [taskId, worker]);
-  }
-
-  async submitEvidence(taskId: TaskId, evidenceHash: Hex): Promise<TxReceiptLike> {
-    return this.sendTx('submitEvidence', [taskId, evidenceHash]);
-  }
-
-  async completeVerification(taskId: TaskId, passed: boolean): Promise<TxReceiptLike> {
-    return this.sendTx('completeVerification', [taskId, passed]);
-  }
-
-  async cancelTask(taskId: TaskId): Promise<TxReceiptLike> {
-    return this.sendTx('cancelTask', [taskId]);
-  }
-
-  async raiseDispute(taskId: TaskId): Promise<TxReceiptLike> {
-    return this.sendTx('raiseDispute', [taskId]);
-  }
-
-  async resolveDispute(taskId: TaskId, workerFavored: boolean): Promise<TxReceiptLike> {
-    return this.sendTx('resolveDispute', [taskId, workerFavored]);
-  }
-
-  async claimTimeout(taskId: TaskId): Promise<TxReceiptLike> {
-    return this.sendTx('claimTimeout', [taskId]);
-  }
-
-  async getTask(taskId: TaskId): Promise<OnChainTask> {
-    try {
-      const raw = await this.contract.getTask!(taskId);
-      return decodeTask(taskId, raw);
-    } catch (err) {
-      throw wrapChainError(err, 'getTask');
-    }
-  }
-
-  async isTaskExpired(taskId: TaskId): Promise<boolean> {
-    try {
-      return Boolean(await this.contract.isTaskExpired!(taskId));
-    } catch (err) {
-      throw wrapChainError(err, 'isTaskExpired');
-    }
-  }
-
-  async nextTaskId(): Promise<TaskId> {
-    try {
-      return BigInt(await this.contract.nextTaskId!());
-    } catch (err) {
-      throw wrapChainError(err, 'nextTaskId');
-    }
-  }
-
-  async feeBps(): Promise<bigint> {
-    try {
-      return BigInt(await this.contract.feeBps!());
-    } catch (err) {
-      throw wrapChainError(err, 'feeBps');
-    }
-  }
-
-  private async sendTx(method: string, args: unknown[]): Promise<TxReceiptLike> {
-    try {
-      const fn = this.contract[method];
-      if (typeof fn !== 'function') {
-        throw new Error(`unknown contract method: ${method}`);
-      }
-      const tx = await fn(...args);
-      const rec = await tx.wait(1);
-      return toReceipt(rec);
-    } catch (err) {
-      throw wrapChainError(err, method);
-    }
-  }
-
-  private extractTaskIdFromReceipt(receipt: ethers.ContractTransactionReceipt | null): TaskId {
-    if (!receipt) throw new Error('no receipt');
-    const iface = this.contract.interface;
-    for (const log of receipt.logs) {
-      try {
-        const parsed = iface.parseLog({ topics: log.topics as string[], data: log.data });
-        if (parsed?.name === 'TaskCreated') {
-          return BigInt(parsed.args.getValue('taskId'));
-        }
-      } catch {
-        // not our event, skip
-      }
-    }
-    throw new Error('TaskCreated event not found in receipt logs');
-  }
-}
-
-function toReceipt(rec: ethers.ContractTransactionReceipt | null): TxReceiptLike {
-  if (!rec) throw new Error('no receipt');
-  return {
-    hash: rec.hash as Hex,
-    blockNumber: rec.blockNumber,
-    gasUsed: rec.gasUsed,
-  };
-}
-
-function decodeTask(taskId: TaskId, raw: ethers.Result): OnChainTask {
-  // Live Task struct (12 fields) from BlindEscrow.getTask(): agent, worker,
-  // token, amount, taskHash, evidenceHash, status, category, locationZone,
-  // createdAt, deadline, submissionAttempts. The old decode read createdAt from
-  // arr[7] (actually category) and deadline from arr[8] (actually locationZone),
-  // yielding Invalid Date and discarding category/locationZone.
-  const arr = raw as unknown as unknown[];
-  const statusIndex = Number(arr[6]);
-  const status = STATUS_BY_INDEX[statusIndex];
-  if (!status) throw new Error(`BlindEscrow.getTask returned unknown status index ${statusIndex}`);
-  return {
-    taskId,
-    agent: arr[0] as Address,
-    worker: arr[1] as Address,
-    token: arr[2] as Address,
-    amount: BigInt(arr[3] as bigint | number),
-    taskHash: arr[4] as Hex,
-    evidenceHash: arr[5] as Hex,
-    status,
-    category: arr[7] as string,
-    locationZone: arr[8] as string,
-    createdAt: new Date(Number(arr[9] as bigint | number) * 1000),
-    deadline: new Date(Number(arr[10] as bigint | number) * 1000),
-  };
-}

package/src/chain/BlindReputationClient.ts

@@ -1,60 +0,0 @@
-import { ethers } from 'ethers';
-import type { Address, Hex, TaskId, TxReceiptLike } from '../types.js';
-import { BlindReputationAbi } from './abi/index.js';
-import { wrapChainError } from './errors.js';
-
-export interface ReputationSnapshot {
-  tasksCompleted: bigint;
-  /** Raw on-chain value. NOTE: despite the name, the contract returns the
-   *  average rating already scaled ×100 (450 = 4.50), NOT a cumulative sum. */
-  totalScore: bigint;
-  disputes: bigint;
-  /** 0–5 average rating. */
-  avgScore: number;
-}
-
-export class BlindReputationClient {
-  readonly contract: ethers.Contract;
-  readonly address: Address;
-
-  constructor(address: Address, runner: ethers.ContractRunner) {
-    this.address = address;
-    this.contract = new ethers.Contract(address, BlindReputationAbi, runner);
-  }
-
-  async getReputation(worker: Address): Promise<ReputationSnapshot> {
-    try {
-      const raw = (await this.contract.getReputation!(worker)) as unknown as unknown[];
-      const tasksCompleted = BigInt(raw[0] as bigint | number);
-      // raw[1] is already avgScore × 100 (contract getReputation returns the
-      // average scaled ×100, "450 = 4.50") — divide by 100 only, NOT by tasks.
-      const totalScore = BigInt(raw[1] as bigint | number);
-      const disputes = BigInt(raw[2] as bigint | number);
-      const avgScore = Number(totalScore) / 100;
-      return { tasksCompleted, totalScore, disputes, avgScore };
-    } catch (err) {
-      throw wrapChainError(err, 'getReputation');
-    }
-  }
-
-  async rate(worker: Address, score: number, taskId: TaskId): Promise<TxReceiptLike> {
-    if (!Number.isInteger(score) || score < 1 || score > 5) {
-      throw wrapChainError(new Error(`score must be integer 1..5, got ${score}`), 'rate');
-    }
-    try {
-      const tx = await this.contract.rate!(worker, score, taskId);
-      const rec = await tx.wait(1);
-      return { hash: rec.hash as Hex, blockNumber: rec.blockNumber, gasUsed: rec.gasUsed };
-    } catch (err) {
-      throw wrapChainError(err, 'rate');
-    }
-  }
-
-  async hasBeenRated(worker: Address, taskId: TaskId): Promise<boolean> {
-    try {
-      return Boolean(await this.contract.hasBeenRated!(worker, taskId));
-    } catch (err) {
-      throw wrapChainError(err, 'hasBeenRated');
-    }
-  }
-}

package/src/chain/ChainClient.ts

@@ -1,65 +0,0 @@
-import { ethers } from 'ethers';
-import type { Signer as SdkSigner } from '../signer/index.js';
-import type { EVMNetwork } from './domain-types.js';
-import type { Network } from './domain-types.js';
-import { BlindEscrowClient } from './BlindEscrowClient.js';
-import { BlindReputationClient } from './BlindReputationClient.js';
-import { TaskRegistryClient } from './TaskRegistryClient.js';
-
-export interface ChainClientOptions {
-  network: Network;
-  signer?: SdkSigner;
-  /** If provided, used for reads even when signer is absent. Useful for public queries. */
-  provider?: ethers.Provider;
-}
-
-/**
- * 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.
- *
- * Only supports EVM networks.
- */
-export class ChainClient {
-  readonly escrow: BlindEscrowClient;
-  readonly registry: TaskRegistryClient;
-  readonly reputation: BlindReputationClient;
-  readonly provider: ethers.Provider;
-  readonly network: EVMNetwork;
-
-  constructor(opts: ChainClientOptions) {
-    if (opts.network.chainType !== 'evm') {
-      throw new Error(`ChainClient requires an EVM network, got ${opts.network.chainType}`);
-    }
-    this.network = opts.network;
-    const provider =
-      opts.provider ??
-      (opts.signer && unwrapEthersSigner(opts.signer)?.provider) ??
-      defaultProvider(opts.network);
-    this.provider = provider;
-
-    const runner: ethers.ContractRunner = unwrapEthersSigner(opts.signer) ?? provider;
-    this.escrow = new BlindEscrowClient(opts.network.contracts.escrow, runner);
-    this.registry = new TaskRegistryClient(opts.network.contracts.registry, runner);
-    this.reputation = new BlindReputationClient(opts.network.contracts.reputation, runner);
-  }
-}
-
-/**
- * If the SDK Signer is an EthersSigner, pull out the inner ethers.Signer
- * (so ethers.Contract treats it as the transaction runner). Otherwise
- * returns undefined — writes will fail at the contract layer with a clear
- * signer-required error, as intended.
- */
-function unwrapEthersSigner(signer: SdkSigner | undefined): ethers.Signer | undefined {
-  if (!signer) return undefined;
-  const maybe = signer as unknown as { inner?: ethers.Signer };
-  return maybe.inner;
-}
-
-function defaultProvider(network: EVMNetwork): ethers.Provider {
-  const url = network.rpc[0];
-  if (!url) throw new Error(`network ${network.name} has no RPC endpoint configured`);
-  return new ethers.JsonRpcProvider(url, { chainId: Number(network.chainId), name: network.name });
-}

package/src/chain/IBlindMarketChain.ts

@@ -1,109 +0,0 @@
-import type {
-  CreateTaskParams,
-  DomainReputation,
-  DomainTask,
-  DomainTaskMeta,
-  DomainTxReceipt,
-  Network,
-} from './domain-types.js';
-
-/**
- * Chain-agnostic interface for BlindMarket on-chain operations.
- *
- * Every supported blockchain provides an adapter that implements this interface,
- * translating domain operations into chain-native contract calls. Consumers
- * (backend, agents, CLI) work against this interface and never need to know
- * which chain they're talking to.
- */
-export interface IBlindMarketChain {
-  // ── Chain identity ──────────────────────────────────────────────────────
-
-  /** The resolved network config this adapter is connected to. */
-  readonly network: Network;
-
-  /** The address of the active signer. */
-  getAddress(): Promise<string>;
-
-  // ── Task lifecycle (BlindEscrow equivalent) ─────────────────────────────
-
-  /**
-   * Create a new task with escrowed funds.
-   * Returns the assigned task ID and receipt.
-   */
-  createTask(params: CreateTaskParams): Promise<{ taskId: bigint; receipt: DomainTxReceipt }>;
-
-  /** Assign a worker to a funded task. Caller must be the task agent. */
-  assignWorker(taskId: bigint, worker: string): Promise<DomainTxReceipt>;
-
-  /** Submit an evidence hash for an assigned task. Caller must be the worker. */
-  submitEvidence(taskId: bigint, evidenceHash: string): Promise<DomainTxReceipt>;
-
-  /** Complete verification for a submitted task (called by the verifier). */
-  completeVerification(taskId: bigint, passed: boolean): Promise<DomainTxReceipt>;
-
-  /** Cancel a funded/assigned task and return escrow to the agent. */
-  cancelTask(taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Claim escrow after timeout expiry (agent-side). */
-  claimTimeout(taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Raise a dispute on a task. */
-  raiseDispute(taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Resolve a dispute (admin only). */
-  resolveDispute(taskId: bigint, workerFavored: boolean): Promise<DomainTxReceipt>;
-
-  /** Read full on-chain task state. */
-  getTask(taskId: bigint): Promise<DomainTask>;
-
-  /** Check whether a task's deadline has passed. */
-  isTaskExpired(taskId: bigint): Promise<boolean>;
-
-  // ── Task discovery (TaskRegistry equivalent) ────────────────────────────
-
-  /** Publish task metadata to the on-chain discovery index. */
-  publishTask(taskId: bigint, meta: Omit<DomainTaskMeta, 'taskId'> & { taskId?: bigint }): Promise<DomainTxReceipt>;
-
-  /** Remove a task from the discovery index (called on assignment/completion). */
-  closeTask(taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Get a page of open task IDs from the discovery index. */
-  getOpenTasks(offset: bigint, limit: bigint): Promise<DomainTaskMeta[]>;
-
-  /** Count of currently open tasks. */
-  openTaskCount(): Promise<bigint>;
-
-  /** Total tasks ever published. */
-  totalTasks(): Promise<bigint>;
-
-  // ── Reputation (BlindReputation equivalent) ─────────────────────────────
-
-  /** Rate a worker after task completion (score 1-5). */
-  rateWorker(worker: string, score: number, taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Record a dispute against a worker. */
-  recordDispute(worker: string, taskId: bigint): Promise<DomainTxReceipt>;
-
-  /** Fetch on-chain reputation for a worker. */
-  getReputation(worker: string): Promise<DomainReputation>;
-
-  /** Check if a worker has already been rated for a given task. */
-  hasBeenRated(worker: string, taskId: bigint): Promise<boolean>;
-
-  // ── Agent identity (INFT equivalent) ────────────────────────────────────
-
-  /** Mint an agent identity token. Returns the token ID and receipt. */
-  mintAgent(params: {
-    to: string;
-    encryptedURI: string;
-    metadataHash: string;
-  }): Promise<{ tokenId: bigint; receipt: DomainTxReceipt }>;
-
-  /** Read the encrypted metadata URI for an agent token. */
-  getEncryptedURI(tokenId: bigint): Promise<string>;
-
-  // ── Queries ──────────────────────────────────────────────────────────────
-
-  /** Get native balance for an address. */
-  getBalance(address: string): Promise<bigint>;
-}