@blindmarket/sdk 0.1.7 → 0.4.0

package/examples/agent-demo.ts

@@ -1,121 +0,0 @@
-/**
- * Agent → Worker end-to-end demo, using MemoryStorage + a mock escrow so the
- * script runs anywhere without an RPC or funded wallet. Shows the full flow:
- *
- *   1. Agent creates an encrypted task (AES-encrypt instructions, upload blob)
- *   2. Agent assigns a worker (ECIES-wrap the AES key to worker's pubkey)
- *   3. Worker decrypts the instructions
- *   4. Worker submits evidence (seals a dual-recipient envelope for agent + TEE)
- *   5. Agent decrypts the evidence
- *
- * Run from sdk/:  npx tsx examples/agent-demo.ts
- *
- * For the real chain, swap MockEscrow for `new ChainClient({ network, signer }).escrow`
- * and swap MemoryStorage for `new ZgStorage({ indexerUrl, rpcUrl, signer: ethersWallet })`.
- */
-import { Agent } from '../src/agent/index.js';
-import type { BlindEscrowClient, CreateTaskArgs } from '../src/chain/index.js';
-import { generateKeyPair } 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, RootHash, TaskId, TxReceiptLike } from '../src/types.js';
-import { Worker } from '../src/worker/index.js';
-
-// ── Mock escrow for offline demo (use real ChainClient in production) ──
-class MockEscrow {
-  private nextId = 1n;
-  private evidenceByTask = new Map<string, RootHash>();
-  async createTask(args: CreateTaskArgs) {
-    const taskId = this.nextId++;
-    return { taskId, receipt: r('0xa') };
-  }
-  async assignWorker(_taskId: TaskId, _worker: Address) { return r('0xb'); }
-  async cancelTask(_taskId: TaskId) { return r('0xc'); }
-  async submitEvidence(taskId: TaskId, evidenceHash: Hex) {
-    this.evidenceByTask.set(taskId.toString(), evidenceHash as RootHash);
-    return r('0xd');
-  }
-  getEvidenceHash(taskId: TaskId) { return this.evidenceByTask.get(taskId.toString()); }
-}
-function r(prefix: string): TxReceiptLike {
-  return { hash: (prefix + 'f'.repeat(63 - prefix.length + 2)).slice(0, 66) as Hex, blockNumber: 1, gasUsed: 21000n };
-}
-
-// ── Shared deps ──
-const AGENT_PK = '0x' + '1'.repeat(64);
-const WORKER_PK = '0x' + '2'.repeat(64);
-const USDC = '0x317227efcA18D004E12CA8046AEf7E1597458F25' as Address;
-
-const storage = new MemoryStorage();
-const escrow = new MockEscrow();
-const events = new EventBus<SdkEvents>();
-events.on('task.created', (p) => console.log(`  • task.created taskId=${p.taskId} rootHash=${p.rootHash.slice(0, 18)}…`));
-events.on('task.assigned', (p) => console.log(`  • task.assigned taskId=${p.taskId} worker=${p.worker.slice(0, 10)}…`));
-events.on('evidence.submitted', (p) => console.log(`  • evidence.submitted taskId=${p.taskId} rootHash=${p.rootHash.slice(0, 18)}…`));
-
-// ── Identities ──
-const agentSigner = new PrivateKeySigner(AGENT_PK);
-const workerSigner = new PrivateKeySigner(WORKER_PK);
-const agentPubKey = await agentSigner.getPublicKey();
-const workerPubKey = await workerSigner.getPublicKey();
-const workerAddr = (await workerSigner.getAddress()) as Address;
-const enclaveKeys = generateKeyPair(); // TEE pubkey — fetched from broker in production
-
-const agent = new Agent({
-  // biome-ignore lint/suspicious/noExplicitAny: demo mock
-  escrow: escrow as any as BlindEscrowClient,
-  storage,
-  keystore: new InMemoryKeyStore(),
-  signer: agentSigner,
-  events,
-});
-const worker = new Worker({
-  // biome-ignore lint/suspicious/noExplicitAny: demo mock
-  escrow: escrow as any as BlindEscrowClient,
-  // biome-ignore lint/suspicious/noExplicitAny: demo: no registry needed for this path
-  registry: null as any,
-  storage,
-  signer: workerSigner,
-  events,
-});
-
-// ── 1. Agent creates an encrypted task ──
-console.log('\n[1] Agent creates encrypted task');
-const created = await agent.createTask({
-  instructions: 'Take 3 photos of the storefront at 123 Main St, Lagos',
-  category: 'photography',
-  locationZone: 'Lagos, NG',
-  reward: { token: USDC, amount: 5_000000n },
-  deadline: new Date(Date.now() + 24 * 3600_000),
-});
-
-// ── 2. Agent assigns the worker ──
-console.log('\n[2] Agent assigns worker (wraps AES key to worker pubkey)');
-const { wrappedKey } = await agent.assignWorker(created.taskId, workerAddr, workerPubKey);
-
-// ── 3. Worker decrypts the instructions ──
-console.log('\n[3] Worker decrypts instructions');
-const instructions = await worker.decryptInstructions({
-  wrappedKey,
-  workerPrivKey: WORKER_PK,
-  taskHash: created.rootHash,
-});
-console.log(`  → "${new TextDecoder().decode(instructions)}"`);
-
-// ── 4. Worker submits evidence ──
-console.log('\n[4] Worker submits evidence (dual-recipient envelope: agent + TEE)');
-const submitted = await worker.submitEvidence({
-  taskId: created.taskId,
-  evidence: 'photo1.jpg photo2.jpg photo3.jpg (attached)',
-  agentPubKey,
-  enclavePubKey: enclaveKeys.publicKey,
-});
-
-// ── 5. Agent fetches + decrypts evidence ──
-console.log('\n[5] Agent decrypts evidence');
-const recovered = await agent.fetchAndDecryptEvidence(submitted.rootHash, AGENT_PK);
-console.log(`  → "${new TextDecoder().decode(recovered)}"`);
-
-console.log('\n✓ full lifecycle completed');

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/chain/BlindEscrowClient.ts

@@ -1,187 +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'];
-
-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;
-  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 {
-  // Tuple order from BlindEscrow.getTask(): (agent, worker, token, amount, taskHash,
-  // evidenceHash, status, createdAt, deadline) — verify against contracts/BlindEscrow.sol.
-  const arr = raw as unknown as unknown[];
-  const statusIndex = Number(arr[6]);
-  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: STATUS_BY_INDEX[statusIndex] ?? 'funded',
-    createdAt: new Date(Number(arr[7] as bigint | number) * 1000),
-    deadline: new Date(Number(arr[8] as bigint | number) * 1000),
-  };
-}

package/src/chain/BlindReputationClient.ts

@@ -1,55 +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;
-  totalScore: bigint;
-  disputes: bigint;
-  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);
-      const totalScore = BigInt(raw[1] as bigint | number);
-      const disputes = BigInt(raw[2] as bigint | number);
-      const avgScore = tasksCompleted === 0n ? 0 : Number(totalScore) / Number(tasksCompleted);
-      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,59 +0,0 @@
-import { ethers } from 'ethers';
-import type { Signer as SdkSigner } from '../signer/index.js';
-import type { Network } from '../network/index.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.
- */
-export class ChainClient {
-  readonly escrow: BlindEscrowClient;
-  readonly registry: TaskRegistryClient;
-  readonly reputation: BlindReputationClient;
-  readonly provider: ethers.Provider;
-  readonly network: Network;
-
-  constructor(opts: ChainClientOptions) {
-    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: Network): 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 });
-}