@blindmarket/sdk 0.1.7 → 0.4.0

package/src/crypto/aes.ts

@@ -1,104 +0,0 @@
-import { CryptoError } from '../errors/index.js';
-import { AES_MIN_BLOB, IV_LENGTH, KEY_LENGTH, TAG_LENGTH } from './constants.js';
-
-function getCrypto(): Crypto {
-  const c = (globalThis as { crypto?: Crypto }).crypto;
-  if (!c?.subtle) {
-    throw new CryptoError('CRYPTO/UNSUPPORTED_CIPHER', 'Web Crypto (crypto.subtle) is not available');
-  }
-  return c;
-}
-
-function toArrayBuffer(u: Uint8Array): ArrayBuffer {
-  const ab = new ArrayBuffer(u.byteLength);
-  new Uint8Array(ab).set(u);
-  return ab;
-}
-
-/** Generate a fresh 32-byte AES-256 key. */
-export async function generateAesKey(): Promise<Uint8Array> {
-  const key = new Uint8Array(KEY_LENGTH);
-  getCrypto().getRandomValues(key);
-  return key;
-}
-
-/**
- * AES-256-GCM encrypt. Output format: [12 IV][16 tag][ciphertext].
- * This ordering matches backend/src/services/crypto.ts and frontend/src/lib/crypto.ts
- * byte-for-byte, so SDK blobs decrypt anywhere in the stack.
- */
-export async function aesEncrypt(plaintext: Uint8Array, key: Uint8Array): Promise<Uint8Array> {
-  if (key.byteLength !== KEY_LENGTH) {
-    throw new CryptoError(
-      'CRYPTO/INVALID_KEY',
-      `AES key must be ${KEY_LENGTH} bytes, got ${key.byteLength}`,
-    );
-  }
-  const c = getCrypto();
-  const iv = new Uint8Array(IV_LENGTH);
-  c.getRandomValues(iv);
-  try {
-    const ck = await c.subtle.importKey('raw', toArrayBuffer(key), 'AES-GCM', false, ['encrypt']);
-    const wcOut = new Uint8Array(
-      await c.subtle.encrypt(
-        { name: 'AES-GCM', iv: toArrayBuffer(iv), tagLength: TAG_LENGTH * 8 },
-        ck,
-        toArrayBuffer(plaintext),
-      ),
-    );
-    // WebCrypto returns [ciphertext || tag]. Rewrite to [IV || tag || ciphertext].
-    const ctLen = wcOut.length - TAG_LENGTH;
-    const ct = wcOut.subarray(0, ctLen);
-    const tag = wcOut.subarray(ctLen);
-    const blob = new Uint8Array(IV_LENGTH + TAG_LENGTH + ctLen);
-    blob.set(iv, 0);
-    blob.set(tag, IV_LENGTH);
-    blob.set(ct, IV_LENGTH + TAG_LENGTH);
-    return blob;
-  } catch (cause) {
-    throw new CryptoError('CRYPTO/DECRYPT_FAILED', 'AES-GCM encryption failed', { cause });
-  }
-}
-
-/**
- * AES-256-GCM decrypt. Input format: [12 IV][16 tag][ciphertext].
- * Throws CRYPTO/INTEGRITY_CHECK on truncation or tag mismatch.
- */
-export async function aesDecrypt(blob: Uint8Array, key: Uint8Array): Promise<Uint8Array> {
-  if (key.byteLength !== KEY_LENGTH) {
-    throw new CryptoError(
-      'CRYPTO/INVALID_KEY',
-      `AES key must be ${KEY_LENGTH} bytes, got ${key.byteLength}`,
-    );
-  }
-  if (blob.byteLength < AES_MIN_BLOB) {
-    throw new CryptoError(
-      'CRYPTO/INTEGRITY_CHECK',
-      `AES blob too short: need ≥${AES_MIN_BLOB} bytes, got ${blob.byteLength}`,
-    );
-  }
-  const iv = blob.subarray(0, IV_LENGTH);
-  const tag = blob.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
-  const ct = blob.subarray(IV_LENGTH + TAG_LENGTH);
-  const combined = new Uint8Array(ct.length + TAG_LENGTH);
-  combined.set(ct, 0);
-  combined.set(tag, ct.length);
-  try {
-    const c = getCrypto();
-    const ck = await c.subtle.importKey('raw', toArrayBuffer(key), 'AES-GCM', false, ['decrypt']);
-    const pt = await c.subtle.decrypt(
-      { name: 'AES-GCM', iv: toArrayBuffer(iv), tagLength: TAG_LENGTH * 8 },
-      ck,
-      toArrayBuffer(combined),
-    );
-    return new Uint8Array(pt);
-  } catch (cause) {
-    throw new CryptoError('CRYPTO/DECRYPT_FAILED', 'AES-GCM decryption failed (wrong key or tampered data)', { cause });
-  }
-}
-
-/** SHA-256 of arbitrary bytes. Returns 32-byte digest. */
-export async function sha256(data: Uint8Array): Promise<Uint8Array> {
-  const digest = await getCrypto().subtle.digest('SHA-256', toArrayBuffer(data));
-  return new Uint8Array(digest);
-}

package/src/crypto/constants.ts

@@ -1,7 +0,0 @@
-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('BlindMarket-ECIES-v1');
-export const AES_MIN_BLOB = IV_LENGTH + TAG_LENGTH;
-export const ECIES_MIN_BLOB = ECIES_PUBKEY_LENGTH + AES_MIN_BLOB;

package/src/crypto/ecies.ts

@@ -1,60 +0,0 @@
-import { ethers } from 'ethers';
-import { CryptoError } from '../errors/index.js';
-import { aesDecrypt, aesEncrypt } from './aes.js';
-import { ECIES_MIN_BLOB, ECIES_PUBKEY_LENGTH, KEY_LENGTH } from './constants.js';
-import { hkdfSha256 } from './hkdf.js';
-import { assertUncompressedPubKey, bytesToHex, hexToBytes, strip } from './keys.js';
-
-/**
- * ECIES-secp256k1 encrypt to a recipient's uncompressed public key.
- * Wire format: [65 ephemeral pubkey][12 IV][16 tag][ciphertext].
- * Byte-compatible with backend/src/services/crypto.ts.
- */
-export async function eciesEncrypt(plaintext: Uint8Array, recipientPubKey: string): Promise<Uint8Array> {
-  assertUncompressedPubKey(recipientPubKey);
-  const ephemeral = ethers.Wallet.createRandom();
-  const shared = deriveSharedSecretX(ephemeral.privateKey, `0x${strip(recipientPubKey)}`);
-  const aesKey = await hkdfSha256(shared, KEY_LENGTH);
-  const aesBlob = await aesEncrypt(plaintext, aesKey);
-  const ephPub = hexToBytes(strip(ephemeral.signingKey.publicKey));
-  if (ephPub.byteLength !== ECIES_PUBKEY_LENGTH) {
-    throw new CryptoError('CRYPTO/INVALID_KEY', `ephemeral pubkey length ${ephPub.byteLength}`);
-  }
-  const blob = new Uint8Array(ECIES_PUBKEY_LENGTH + aesBlob.byteLength);
-  blob.set(ephPub, 0);
-  blob.set(aesBlob, ECIES_PUBKEY_LENGTH);
-  return blob;
-}
-
-/** ECIES-secp256k1 decrypt with the recipient's private key. */
-export async function eciesDecrypt(blob: Uint8Array, recipientPrivKey: string): Promise<Uint8Array> {
-  if (blob.byteLength < ECIES_MIN_BLOB) {
-    throw new CryptoError(
-      'CRYPTO/INTEGRITY_CHECK',
-      `ECIES blob too short: need ≥${ECIES_MIN_BLOB} bytes, got ${blob.byteLength}`,
-    );
-  }
-  const ephPub = blob.subarray(0, ECIES_PUBKEY_LENGTH);
-  const aesBlob = blob.subarray(ECIES_PUBKEY_LENGTH);
-  const shared = deriveSharedSecretX(`0x${strip(recipientPrivKey)}`, `0x${bytesToHex(ephPub)}`);
-  const aesKey = await hkdfSha256(shared, KEY_LENGTH);
-  return aesDecrypt(aesBlob, aesKey);
-}
-
-/**
- * Compute the ECDH shared secret X coordinate (32 bytes) between a private key
- * and a peer's public key. Matches Node createECDH.computeSecret() output used by
- * the backend — ethers v6 returns 0x04||X||Y, so we slice X.
- */
-function deriveSharedSecretX(privHex: string, pubHex: string): Uint8Array {
-  const sk = new ethers.SigningKey(privHex);
-  const shared = sk.computeSharedSecret(pubHex);
-  const bytes = hexToBytes(strip(shared));
-  if (bytes.byteLength !== 65 || bytes[0] !== 0x04) {
-    throw new CryptoError(
-      'CRYPTO/INVALID_KEY',
-      `unexpected shared secret shape (len=${bytes.byteLength}, prefix=${bytes[0]?.toString(16) ?? 'none'})`,
-    );
-  }
-  return bytes.subarray(1, 33);
-}

package/src/crypto/envelope.ts

@@ -1,131 +0,0 @@
-import { CryptoError } from '../errors/index.js';
-import { aesDecrypt, aesEncrypt, generateAesKey } from './aes.js';
-import { eciesEncrypt } from './ecies.js';
-
-/**
- * Evidence envelope — the single blob a worker uploads to Storage containing:
- *   1. The AES key wrapped to the agent's pubkey (so agent can decrypt later)
- *   2. The AES key wrapped to the TEE enclave's pubkey (so Sealed Inference can decrypt)
- *   3. The evidence ciphertext under that AES key
- *
- * Wire format (big-endian):
- *   bytes 0..1    magic         = 0x42 0x42  ("BB")
- *   byte  2       version       = 0x01
- *   bytes 3..6    wrappedAgentLen (uint32)
- *   bytes 7..     wrappedAgent  (ECIES blob)
- *   4-byte uint32 wrappedEnclaveLen
- *   bytes         wrappedEnclave (ECIES blob)
- *   bytes         aesCiphertext  (rest of the blob — AES blob [IV||tag||ct])
- *
- * The layout is versioned so we can rev it without breaking old blobs.
- */
-
-const MAGIC_0 = 0x42;
-const MAGIC_1 = 0x42;
-const VERSION = 0x01;
-const HEADER_LEN = 3;
-
-export interface EvidenceEnvelope {
-  wrappedForAgent: Uint8Array;
-  wrappedForEnclave: Uint8Array;
-  aesCiphertext: Uint8Array;
-}
-
-export interface SealEvidenceInput {
-  evidence: Uint8Array;
-  agentPubKey: string;
-  enclavePubKey: string;
-}
-
-export interface SealEvidenceOutput {
-  envelope: Uint8Array;
-  aesKey: Uint8Array;
-}
-
-/**
- * Seal evidence for the agent + TEE enclave. Generates a fresh AES key,
- * encrypts the evidence, ECIES-wraps the key twice, and concatenates the
- * result as an EvidenceEnvelope. Returns both the on-wire envelope and
- * the raw AES key (for audit / diagnostic use — do NOT persist beyond
- * the submission).
- */
-export async function sealEvidence(input: SealEvidenceInput): Promise<SealEvidenceOutput> {
-  const aesKey = await generateAesKey();
-  const aesCiphertext = await aesEncrypt(input.evidence, aesKey);
-  const wrappedForAgent = await eciesEncrypt(aesKey, input.agentPubKey);
-  const wrappedForEnclave = await eciesEncrypt(aesKey, input.enclavePubKey);
-  const envelope = pack({ wrappedForAgent, wrappedForEnclave, aesCiphertext });
-  return { envelope, aesKey };
-}
-
-/**
- * Open an evidence envelope as the agent — extracts the AES key wrapped
- * to the agent's pubkey, decrypts the ciphertext, and returns the plaintext
- * evidence. The enclave-wrapped key is ignored by agents (TEE-only).
- */
-export async function openEvidenceAsAgent(
-  envelope: Uint8Array,
-  agentPrivKey: string,
-): Promise<Uint8Array> {
-  const parsed = parse(envelope);
-  const { eciesDecrypt } = await import('./ecies.js');
-  const aesKey = await eciesDecrypt(parsed.wrappedForAgent, agentPrivKey);
-  return aesDecrypt(parsed.aesCiphertext, aesKey);
-}
-
-function pack(parts: EvidenceEnvelope): Uint8Array {
-  const { wrappedForAgent, wrappedForEnclave, aesCiphertext } = parts;
-  const total =
-    HEADER_LEN +
-    4 + wrappedForAgent.byteLength +
-    4 + wrappedForEnclave.byteLength +
-    aesCiphertext.byteLength;
-  const out = new Uint8Array(total);
-  const view = new DataView(out.buffer);
-  let off = 0;
-  out[off++] = MAGIC_0;
-  out[off++] = MAGIC_1;
-  out[off++] = VERSION;
-  view.setUint32(off, wrappedForAgent.byteLength, false);
-  off += 4;
-  out.set(wrappedForAgent, off);
-  off += wrappedForAgent.byteLength;
-  view.setUint32(off, wrappedForEnclave.byteLength, false);
-  off += 4;
-  out.set(wrappedForEnclave, off);
-  off += wrappedForEnclave.byteLength;
-  out.set(aesCiphertext, off);
-  return out;
-}
-
-function parse(blob: Uint8Array): EvidenceEnvelope {
-  if (blob.byteLength < HEADER_LEN + 4 + 4) {
-    throw new CryptoError('CRYPTO/INTEGRITY_CHECK', `envelope too short: ${blob.byteLength}`);
-  }
-  if (blob[0] !== MAGIC_0 || blob[1] !== MAGIC_1) {
-    throw new CryptoError('CRYPTO/INTEGRITY_CHECK', 'bad envelope magic');
-  }
-  if (blob[2] !== VERSION) {
-    throw new CryptoError('CRYPTO/UNSUPPORTED_CIPHER', `unknown envelope version ${blob[2]}`);
-  }
-  const view = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
-  let off = HEADER_LEN;
-  const agentLen = view.getUint32(off, false);
-  off += 4;
-  if (off + agentLen + 4 > blob.byteLength) {
-    throw new CryptoError('CRYPTO/INTEGRITY_CHECK', 'envelope truncated (agent)');
-  }
-  const wrappedForAgent = blob.slice(off, off + agentLen);
-  off += agentLen;
-  const enclaveLen = view.getUint32(off, false);
-  off += 4;
-  if (off + enclaveLen > blob.byteLength) {
-    throw new CryptoError('CRYPTO/INTEGRITY_CHECK', 'envelope truncated (enclave)');
-  }
-  const wrappedForEnclave = blob.slice(off, off + enclaveLen);
-  off += enclaveLen;
-  const aesCiphertext = blob.slice(off);
-  return { wrappedForAgent, wrappedForEnclave, aesCiphertext };
-}
-
-export const __internals = { pack, parse };

package/src/crypto/hkdf.ts

@@ -1,45 +0,0 @@
-import { CryptoError } from '../errors/index.js';
-import { ECIES_HKDF_INFO } from './constants.js';
-
-function getSubtle(): SubtleCrypto {
-  const c = (globalThis as { crypto?: Crypto }).crypto;
-  if (!c?.subtle) {
-    throw new CryptoError('CRYPTO/UNSUPPORTED_CIPHER', 'Web Crypto (crypto.subtle) is not available');
-  }
-  return c.subtle;
-}
-
-function toArrayBuffer(u: Uint8Array): ArrayBuffer {
-  const ab = new ArrayBuffer(u.byteLength);
-  new Uint8Array(ab).set(u);
-  return ab;
-}
-
-/**
- * HKDF-SHA256. Defaults match backend: empty salt, the ECIES domain separation info,
- * 32-byte output length. Pass custom values for other uses.
- */
-export async function hkdfSha256(
-  ikm: Uint8Array,
-  length = 32,
-  info: Uint8Array = ECIES_HKDF_INFO,
-  salt: Uint8Array = new Uint8Array(0),
-): Promise<Uint8Array> {
-  try {
-    const subtle = getSubtle();
-    const baseKey = await subtle.importKey('raw', toArrayBuffer(ikm), 'HKDF', false, ['deriveBits']);
-    const derived = await subtle.deriveBits(
-      {
-        name: 'HKDF',
-        hash: 'SHA-256',
-        info: toArrayBuffer(info),
-        salt: toArrayBuffer(salt),
-      },
-      baseKey,
-      length * 8,
-    );
-    return new Uint8Array(derived);
-  } catch (cause) {
-    throw new CryptoError('CRYPTO/INVALID_KEY', 'HKDF derivation failed', { cause });
-  }
-}

package/src/crypto/index.ts

@@ -1,6 +0,0 @@
-export * from './constants.js';
-export * from './aes.js';
-export * from './ecies.js';
-export * from './keys.js';
-export * from './envelope.js';
-export { hkdfSha256 } from './hkdf.js';

package/src/crypto/keys.ts

@@ -1,56 +0,0 @@
-import { ethers } from 'ethers';
-import { CryptoError } from '../errors/index.js';
-
-export interface KeyPair {
-  privateKey: string;
-  publicKey: string;
-}
-
-/** Fresh secp256k1 keypair. Hex strings returned un-prefixed (no 0x). */
-export function generateKeyPair(): KeyPair {
-  const w = ethers.Wallet.createRandom();
-  return {
-    privateKey: w.privateKey.slice(2),
-    publicKey: w.signingKey.publicKey.slice(2),
-  };
-}
-
-/** Recover the uncompressed public key (un-prefixed hex) from a private key. */
-export function derivePublicKey(privateKey: string): string {
-  const sk = new ethers.SigningKey(`0x${strip(privateKey)}`);
-  return sk.publicKey.slice(2);
-}
-
-export function strip(hex: string): string {
-  return hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
-}
-
-export function assertUncompressedPubKey(pub: string): void {
-  const s = strip(pub);
-  if (s.length !== 130 || !/^04/i.test(s)) {
-    throw new CryptoError(
-      'CRYPTO/INVALID_KEY',
-      'expected uncompressed secp256k1 pubkey (65 bytes hex, starts with 04)',
-    );
-  }
-}
-
-export function hexToBytes(hex: string): Uint8Array {
-  const s = strip(hex);
-  if (s.length % 2 !== 0) {
-    throw new CryptoError('CRYPTO/INVALID_KEY', 'hex string has odd length');
-  }
-  const out = new Uint8Array(s.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    const byte = Number.parseInt(s.substring(i * 2, i * 2 + 2), 16);
-    if (Number.isNaN(byte)) {
-      throw new CryptoError('CRYPTO/INVALID_KEY', `invalid hex byte at position ${i * 2}`);
-    }
-    out[i] = byte;
-  }
-  return out;
-}
-
-export function bytesToHex(u: Uint8Array): string {
-  return Array.from(u, (b) => b.toString(16).padStart(2, '0')).join('');
-}

package/src/errors/BlindMarketError.ts

@@ -1,38 +0,0 @@
-import type { ErrorCode } from './codes.js';
-
-export interface ErrorOptions {
-  retriable?: boolean;
-  context?: Record<string, unknown>;
-  cause?: unknown;
-}
-
-export abstract class BlindMarketError extends Error {
-  readonly code: ErrorCode;
-  readonly retriable: boolean;
-  readonly context?: Record<string, unknown>;
-  override readonly cause?: unknown;
-
-  constructor(code: ErrorCode, message: string, opts: ErrorOptions = {}) {
-    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(): Record<string, unknown> {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      retriable: this.retriable,
-      ...(this.context ? { context: this.context } : {}),
-    };
-  }
-}

package/src/errors/codes.ts

@@ -1,67 +0,0 @@
-export const ErrorCodes = {
-  Config: ['CONFIG/INVALID_NETWORK', 'CONFIG/MISSING_SIGNER', 'CONFIG/BAD_CONFIG'] as const,
-  Crypto: [
-    'CRYPTO/INVALID_KEY',
-    'CRYPTO/DECRYPT_FAILED',
-    'CRYPTO/INTEGRITY_CHECK',
-    'CRYPTO/UNSUPPORTED_CIPHER',
-  ] as const,
-  Storage: [
-    'STORAGE/UPLOAD_FAILED',
-    'STORAGE/DOWNLOAD_FAILED',
-    'STORAGE/MERKLE_MISMATCH',
-    'STORAGE/NOT_FOUND',
-    'STORAGE/INDEXER_UNREACHABLE',
-  ] as const,
-  Chain: [
-    'CHAIN/TX_REVERTED',
-    'CHAIN/TX_TIMED_OUT',
-    'CHAIN/NONCE_CONFLICT',
-    'CHAIN/INSUFFICIENT_BALANCE',
-    'CHAIN/NETWORK_MISMATCH',
-    'CHAIN/CONTRACT_NOT_DEPLOYED',
-  ] as const,
-  Compute: [
-    'COMPUTE/BROKER_UNREACHABLE',
-    'COMPUTE/NO_PROVIDERS',
-    'COMPUTE/LEDGER_INSUFFICIENT',
-    'COMPUTE/TEE_ATTESTATION_INVALID',
-    'COMPUTE/VERIFICATION_TIMEOUT',
-  ] as const,
-  Api: [
-    'API/AUTH_REQUIRED',
-    'API/AUTH_EXPIRED',
-    'API/FORBIDDEN',
-    'API/RATE_LIMITED',
-    'API/VALIDATION',
-    'API/SERVER',
-    'API/NOT_FOUND',
-  ] as const,
-  Lifecycle: [
-    'LIFECYCLE/ILLEGAL_TRANSITION',
-    'LIFECYCLE/TASK_NOT_FOUND',
-    'LIFECYCLE/NOT_ASSIGNED',
-    'LIFECYCLE/ALREADY_SUBMITTED',
-    'LIFECYCLE/CLAIM_NOT_READY',
-  ] as const,
-  Timeout: ['TIMEOUT'] as const,
-} as const;
-
-export type ConfigCode = (typeof ErrorCodes.Config)[number];
-export type CryptoCode = (typeof ErrorCodes.Crypto)[number];
-export type StorageCode = (typeof ErrorCodes.Storage)[number];
-export type ChainCode = (typeof ErrorCodes.Chain)[number];
-export type ComputeCode = (typeof ErrorCodes.Compute)[number];
-export type ApiCode = (typeof ErrorCodes.Api)[number];
-export type LifecycleCode = (typeof ErrorCodes.Lifecycle)[number];
-export type TimeoutCode = (typeof ErrorCodes.Timeout)[number];
-
-export type ErrorCode =
-  | ConfigCode
-  | CryptoCode
-  | StorageCode
-  | ChainCode
-  | ComputeCode
-  | ApiCode
-  | LifecycleCode
-  | TimeoutCode;

package/src/errors/index.ts

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

package/src/errors/subclasses.ts

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

package/src/events/EventBus.ts

@@ -1,45 +0,0 @@
-type Handler<T> = (payload: T) => void;
-
-/**
- * Typed pub/sub. Listener exceptions are swallowed so one bad subscriber
- * cannot block others — telemetry plugins can observe failures via onError.
- */
-export class EventBus<E> {
-  private handlers: { [K in keyof E]?: Set<Handler<E[K]>> } = {};
-
-  on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {
-    let set = this.handlers[event];
-    if (!set) {
-      set = new Set<Handler<E[K]>>();
-      this.handlers[event] = set;
-    }
-    set.add(fn);
-    return () => {
-      this.off(event, fn);
-    };
-  }
-
-  once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {
-    const wrapped: Handler<E[K]> = (p) => {
-      this.off(event, wrapped);
-      fn(p);
-    };
-    return this.on(event, wrapped);
-  }
-
-  off<K extends keyof E>(event: K, fn: Handler<E[K]>): void {
-    this.handlers[event]?.delete(fn);
-  }
-
-  emit<K extends keyof E>(event: K, payload: E[K]): void {
-    const hs = this.handlers[event];
-    if (!hs) return;
-    for (const h of hs) {
-      try {
-        h(payload);
-      } catch {
-        // Isolated per-listener — prevents one bad subscriber from blocking others.
-      }
-    }
-  }
-}

package/src/events/index.ts

@@ -1,2 +0,0 @@
-export * from './EventBus.js';
-export * from './types.js';

package/src/events/types.ts

@@ -1,13 +0,0 @@
-import type { Address, Hex, RootHash, TaskId } from '../types.js';
-
-export interface SdkEvents {
-  'task.created': { taskId: TaskId; txHash: Hex; rootHash: RootHash };
-  'task.assigned': { taskId: TaskId; worker: Address; txHash: Hex };
-  'task.cancelled': { taskId: TaskId; txHash: Hex };
-  'evidence.submitted': { taskId: TaskId; rootHash: RootHash; txHash: Hex };
-  'verification.done': { taskId: TaskId; passed: boolean; confidence: number };
-  'payment.claimed': { taskId: TaskId; txHash: Hex; amount: bigint };
-  'tx.sent': { hash: Hex; from: Address; to: Address };
-  'tx.confirmed': { hash: Hex; blockNumber: number };
-  'tx.failed': { hash: Hex; reason: string };
-}