@blindmarket/sdk 0.1.8 → 0.5.0

package/src/chain/domain-types.ts

@@ -1,92 +0,0 @@
-import type { Address, Hex, TaskId, TaskStatus } from '../types.js';
-
-// ── Chain-agnostic domain types ───────────────────────────────────────────
-// These types are the BlindMarket domain model, independent of any specific
-// blockchain. Each chain adapter translates between these and its native
-// contract types.
-
-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/src/chain/errors.ts

@@ -1,43 +0,0 @@
-import { ChainError } from '../errors/index.js';
-
-interface EthersLikeError {
-  code?: string;
-  shortMessage?: string;
-  message?: string;
-  reason?: string;
-  data?: unknown;
-  info?: unknown;
-}
-
-/**
- * Map an ethers-thrown error to a typed ChainError. Best-effort: walks the
- * ethers error shape for a revert reason, maps common codes (INSUFFICIENT_FUNDS,
- * NETWORK_ERROR, TIMEOUT), and falls back to TX_REVERTED with the original
- * message in context.
- */
-export function wrapChainError(err: unknown, hint?: string): ChainError {
-  const e = (err ?? {}) as EthersLikeError;
-  const msg = e.shortMessage ?? e.reason ?? e.message ?? 'unknown chain error';
-  const withHint = hint ? `${hint}: ${msg}` : msg;
-
-  switch (e.code) {
-    case 'INSUFFICIENT_FUNDS':
-      return new ChainError('CHAIN/INSUFFICIENT_BALANCE', withHint, { cause: err, retriable: false });
-    case 'NONCE_EXPIRED':
-    case 'REPLACEMENT_UNDERPRICED':
-      return new ChainError('CHAIN/NONCE_CONFLICT', withHint, { cause: err, retriable: true });
-    case 'NETWORK_ERROR':
-    case 'SERVER_ERROR':
-    case 'TIMEOUT':
-      return new ChainError('CHAIN/TX_TIMED_OUT', withHint, { cause: err, retriable: true });
-    case 'UNSUPPORTED_OPERATION':
-    case 'UNKNOWN_ERROR':
-    case 'CALL_EXCEPTION':
-      return new ChainError('CHAIN/TX_REVERTED', withHint, {
-        cause: err,
-        ...(e.data !== undefined ? { context: { data: e.data } } : {}),
-      });
-    default:
-      return new ChainError('CHAIN/TX_REVERTED', withHint, { cause: err });
-  }
-}

package/src/chain/evm/EVMChainAdapter.ts

@@ -1,212 +0,0 @@
-import { ethers } from 'ethers';
-import type { Address, Hex } from '../../types.js';
-import { ChainClient, type ChainClientOptions } from '../ChainClient.js';
-import { resolveNetwork } from '../../network/resolve.js';
-import type { EthersSigner } from '../../signer/EthersSigner.js';
-import type { Signer } from '../../signer/Signer.js';
-import type {
-  CreateTaskParams,
-  DomainReputation,
-  DomainTask,
-  DomainTaskMeta,
-  DomainTxReceipt,
-  EVMNetwork,
-} from '../domain-types.js';
-import type { IBlindMarketChain } from '../IBlindMarketChain.js';
-import type { OpenTaskMeta } from '../TaskRegistryClient.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 implements IBlindMarketChain {
-  readonly network: EVMNetwork;
-  private client: ChainClient;
-  private signer: EthersSigner | undefined;
-
-  constructor(opts: ChainClientOptions) {
-    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 as EthersSigner | undefined;
-  }
-
-  async getAddress(): Promise<string> {
-    if (!this.signer) throw new Error('No signer configured');
-    return this.signer.getAddress();
-  }
-
-  // ── Task lifecycle ──────────────────────────────────────────────────────
-
-  async createTask(params: CreateTaskParams): Promise<{ taskId: bigint; receipt: DomainTxReceipt }> {
-    const result = await this.client.escrow.createTask({
-      taskHash: params.taskHash,
-      token: params.token as Address,
-      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: bigint, worker: string): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.assignWorker(taskId, worker as Address);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async submitEvidence(taskId: bigint, evidenceHash: string): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.submitEvidence(taskId, evidenceHash as Hex);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async completeVerification(taskId: bigint, passed: boolean): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.completeVerification(taskId, passed);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async cancelTask(taskId: bigint): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.cancelTask(taskId);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async claimTimeout(taskId: bigint): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.claimTimeout(taskId);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async raiseDispute(taskId: bigint): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.raiseDispute(taskId);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async resolveDispute(taskId: bigint, workerFavored: boolean): Promise<DomainTxReceipt> {
-    const receipt = await this.client.escrow.resolveDispute(taskId, workerFavored);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async getTask(taskId: bigint): Promise<DomainTask> {
-    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: bigint): Promise<boolean> {
-    return this.client.escrow.isTaskExpired(taskId);
-  }
-
-  // ── Task discovery ──────────────────────────────────────────────────────
-
-  async publishTask(taskId: bigint, _meta: Omit<DomainTaskMeta, 'taskId'> & { taskId?: bigint }): Promise<DomainTxReceipt> {
-    // 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: bigint): Promise<DomainTxReceipt> {
-    const receipt = await this.client.registry.closeTask(taskId);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async getOpenTasks(offset: bigint, limit: bigint): Promise<DomainTaskMeta[]> {
-    const taskIds = await this.client.registry.getOpenTasks(offset, limit);
-    const metas = await Promise.all(
-      taskIds.map(async (tid: bigint) => {
-        const meta = await this.client.registry.getTaskMeta(tid);
-        return {
-          taskId: tid,
-          agent: '' as Address, // EVM TaskRegistry stores agent; use meta directly
-          category: meta.category,
-          locationZone: meta.locationZone,
-          reward: meta.reward,
-          createdAt: meta.createdAt,
-          isOpen: true,
-        } as DomainTaskMeta;
-      }),
-    );
-    return metas;
-  }
-
-  async openTaskCount(): Promise<bigint> {
-    return this.client.registry.openTaskCount();
-  }
-
-  async totalTasks(): Promise<bigint> {
-    return this.client.registry.totalTasks();
-  }
-
-  // ── Reputation ──────────────────────────────────────────────────────────
-
-  async rateWorker(worker: string, score: number, taskId: bigint): Promise<DomainTxReceipt> {
-    const receipt = await this.client.reputation.rate(worker as Address, score, taskId);
-    return { hash: receipt.hash, blockNumber: receipt.blockNumber };
-  }
-
-  async recordDispute(worker: string, taskId: bigint): Promise<DomainTxReceipt> {
-    // 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: string): Promise<DomainReputation> {
-    return this.client.reputation.getReputation(worker as Address);
-  }
-
-  async hasBeenRated(worker: string, taskId: bigint): Promise<boolean> {
-    return this.client.reputation.hasBeenRated(worker as Address, taskId);
-  }
-
-  // ── Agent identity ──────────────────────────────────────────────────────
-
-  async mintAgent(params: {
-    to: string;
-    encryptedURI: string;
-    metadataHash: string;
-  }): Promise<{ tokenId: bigint; receipt: DomainTxReceipt }> {
-    // 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: bigint): Promise<string> {
-    throw new Error('INFT URI reading is backend-managed on EVM chains. Use the REST API or raw ethers.Contract.');
-  }
-
-  // ── Queries ─────────────────────────────────────────────────────────────
-
-  async getBalance(address: string): Promise<bigint> {
-    return this.client.provider.getBalance(address);
-  }
-
-  // ── Accessors for direct ethers access (advanced use) ───────────────────
-
-  /** Get the underlying ethers Provider for raw queries. */
-  getProvider(): ethers.Provider {
-    return this.client.provider;
-  }
-
-  /** Get the underlying ethers Signer (if configured). */
-  getEthersSigner(): ethers.Signer | undefined {
-    if (!this.signer) return undefined;
-    return (this.signer as unknown as { inner?: ethers.Signer }).inner;
-  }
-}

package/src/chain/evm/index.ts

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

package/src/chain/index.ts

@@ -1,12 +0,0 @@
-export * from './abi/index.js';
-export * from './errors.js';
-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/src/compute/index.ts

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

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 };