@blindmarket/sdk 0.1.4

package/test/storage.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { StorageError } from '../src/errors/index.js';
+import { MemoryStorage } from '../src/storage/index.js';
+
+describe('MemoryStorage', () => {
+  it('upload returns deterministic root hash for the same bytes', async () => {
+    const s = new MemoryStorage();
+    const bytes = new TextEncoder().encode('hello');
+    const a = await s.upload(bytes);
+    const b = await s.upload(bytes);
+    expect(a.rootHash).toBe(b.rootHash);
+    expect(a.size).toBe(5);
+    expect(s.size()).toBe(1);
+  });
+
+  it('download returns the uploaded bytes', async () => {
+    const s = new MemoryStorage();
+    const bytes = new TextEncoder().encode('payload');
+    const { rootHash } = await s.upload(bytes);
+    const got = await s.download(rootHash);
+    expect(new TextDecoder().decode(got)).toBe('payload');
+  });
+
+  it('download of unknown hash throws STORAGE/NOT_FOUND', async () => {
+    const s = new MemoryStorage();
+    await expect(s.download('0x' + '00'.repeat(32) as `0x${string}`)).rejects.toBeInstanceOf(StorageError);
+  });
+
+  it('hash is content-addressed and matches SHA-256', async () => {
+    const s = new MemoryStorage();
+    const h = await s.hash(new TextEncoder().encode('abc'));
+    // Known vector for SHA-256('abc')
+    expect(h).toBe('0xba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+  });
+
+  it('returned bytes are a copy (mutation does not affect stored blob)', async () => {
+    const s = new MemoryStorage();
+    const bytes = new TextEncoder().encode('one');
+    const { rootHash } = await s.upload(bytes);
+    const a = await s.download(rootHash);
+    // biome-ignore lint/style/noNonNullAssertion: non-empty
+    a[0] = (a[0]! ^ 0xff) & 0xff;
+    const b = await s.download(rootHash);
+    expect(b[0]).not.toBe(a[0]);
+    expect(new TextDecoder().decode(b)).toBe('one');
+  });
+
+  it('clear wipes all blobs', async () => {
+    const s = new MemoryStorage();
+    await s.upload(new Uint8Array([1]));
+    expect(s.size()).toBe(1);
+    s.clear();
+    expect(s.size()).toBe(0);
+  });
+});

package/test/worker.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  BlindEscrowClient,
+  CreateTaskArgs,
+  OnChainTask,
+  TaskRegistryClient,
+} from '../src/chain/index.js';
+import {
+  aesEncrypt,
+  eciesEncrypt,
+  generateAesKey,
+  generateKeyPair,
+  openEvidenceAsAgent,
+} from '../src/crypto/index.js';
+import { EventBus, type SdkEvents } from '../src/events/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';
+
+const WORKER_PK = '0x1000000000000000000000000000000000000000000000000000000000000001';
+const FAKE_USDC = '0x317227efcA18D004E12CA8046AEf7E1597458F25' as Address;
+const FAKE_TASK_HASH = `0x${'ab'.repeat(32)}` as Hex;
+
+class MockEscrow {
+  readonly calls: Array<{ method: string; args: unknown }> = [];
+  async submitEvidence(taskId: TaskId, evidenceHash: Hex): Promise<TxReceiptLike> {
+    this.calls.push({ method: 'submitEvidence', args: { taskId, evidenceHash } });
+    return { hash: `0x${'11'.repeat(32)}` as Hex, blockNumber: 10, gasUsed: 21000n };
+  }
+  async claimTimeout(taskId: TaskId): Promise<TxReceiptLike> {
+    this.calls.push({ method: 'claimTimeout', args: { taskId } });
+    return { hash: `0x${'22'.repeat(32)}` as Hex, blockNumber: 20, gasUsed: 21000n };
+  }
+  async getTask(_taskId: TaskId): Promise<OnChainTask> {
+    const t: OnChainTask = {
+      taskId: 1n,
+      agent: '0x0000000000000000000000000000000000000001' as Address,
+      worker: '0x0000000000000000000000000000000000000002' as Address,
+      token: FAKE_USDC,
+      amount: 5_000000n,
+      taskHash: FAKE_TASK_HASH,
+      evidenceHash: `0x${'00'.repeat(32)}` as Hex,
+      status: 'assigned',
+      createdAt: new Date(),
+      deadline: new Date(Date.now() + 3600_000),
+    };
+    return t;
+  }
+  // unused but required for shape
+  async createTask(_args: CreateTaskArgs) {
+    return { taskId: 1n, receipt: { hash: '0x' as Hex, blockNumber: 0, gasUsed: 0n } };
+  }
+}
+
+class MockRegistry {
+  async getOpenTasks(_offset: bigint, _limit: bigint): Promise<TaskId[]> {
+    return [1n, 2n, 3n];
+  }
+}
+
+function mkDeps() {
+  const storage = new MemoryStorage();
+  const signer = new PrivateKeySigner(WORKER_PK);
+  const events = new EventBus<SdkEvents>();
+  const escrow = new MockEscrow();
+  const registry = new MockRegistry();
+  return {
+    storage,
+    signer,
+    events,
+    escrow,
+    registry,
+    worker: new Worker({
+      // biome-ignore lint/suspicious/noExplicitAny: mocks match the subset used
+      escrow: escrow as any as BlindEscrowClient,
+      // biome-ignore lint/suspicious/noExplicitAny: mocks match the subset used
+      registry: registry as any as TaskRegistryClient,
+      storage,
+      signer,
+      events,
+    }),
+  };
+}
+
+describe('Worker.browse + getTaskDetail', () => {
+  it('delegates to registry.getOpenTasks', async () => {
+    const { worker } = mkDeps();
+    const ids = await worker.browse(0n, 10n);
+    expect(ids).toEqual([1n, 2n, 3n]);
+  });
+
+  it('returns task detail from escrow.getTask', async () => {
+    const { worker } = mkDeps();
+    const detail = await worker.getTaskDetail(1n);
+    expect(detail.status).toBe('assigned');
+    expect(detail.token).toBe(FAKE_USDC);
+  });
+});
+
+describe('Worker.decryptInstructions', () => {
+  it('recovers plaintext instructions end-to-end', async () => {
+    const { worker, storage, signer } = mkDeps();
+
+    // Simulate agent side: generate AES key, encrypt instructions, upload, and
+    // wrap AES key to worker pubkey.
+    const aesKey = await generateAesKey();
+    const instructions = new TextEncoder().encode('photograph the storefront at 123 Main St');
+    const ciphertext = await aesEncrypt(instructions, aesKey);
+    const { rootHash } = await storage.upload(ciphertext);
+    const workerPub = await signer.getPublicKey();
+    const wrappedKey = await eciesEncrypt(aesKey, workerPub);
+
+    const decrypted = await worker.decryptInstructions({
+      wrappedKey,
+      workerPrivKey: WORKER_PK,
+      taskHash: rootHash,
+    });
+    expect(new TextDecoder().decode(decrypted)).toBe('photograph the storefront at 123 Main St');
+  });
+});
+
+describe('Worker.submitEvidence', () => {
+  it('seals envelope + uploads + calls chain + emits event; agent can decrypt', async () => {
+    const { worker, storage, escrow, events } = mkDeps();
+
+    const agent = generateKeyPair();
+    const enclave = generateKeyPair();
+
+    const submitted: SdkEvents['evidence.submitted'][] = [];
+    events.on('evidence.submitted', (p) => submitted.push(p));
+
+    const res = await worker.submitEvidence({
+      taskId: 42n,
+      evidence: 'done: photos uploaded',
+      agentPubKey: agent.publicKey,
+      enclavePubKey: enclave.publicKey,
+    });
+
+    expect(res.rootHash).toMatch(/^0x[0-9a-f]{64}$/);
+    expect(escrow.calls.some((c) => c.method === 'submitEvidence')).toBe(true);
+
+    // Agent can download + decrypt the envelope
+    const blob = await storage.download(res.rootHash as RootHash);
+    const recovered = await openEvidenceAsAgent(blob, agent.privateKey);
+    expect(new TextDecoder().decode(recovered)).toBe('done: photos uploaded');
+
+    expect(submitted).toHaveLength(1);
+    expect(submitted[0]?.taskId).toBe(42n);
+    expect(submitted[0]?.rootHash).toBe(res.rootHash);
+  });
+
+  it('accepts Uint8Array evidence as well as strings', async () => {
+    const { worker, storage } = mkDeps();
+    const agent = generateKeyPair();
+    const enclave = generateKeyPair();
+    const res = await worker.submitEvidence({
+      taskId: 1n,
+      evidence: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
+      agentPubKey: agent.publicKey,
+      enclavePubKey: enclave.publicKey,
+    });
+    const blob = await storage.download(res.rootHash);
+    const recovered = await openEvidenceAsAgent(blob, agent.privateKey);
+    expect(Array.from(recovered)).toEqual([0xde, 0xad, 0xbe, 0xef]);
+  });
+});
+
+describe('Worker.claimTimeout', () => {
+  it('calls chain and emits payment.claimed', async () => {
+    const { worker, escrow, events } = mkDeps();
+    const claimed: SdkEvents['payment.claimed'][] = [];
+    events.on('payment.claimed', (p) => claimed.push(p));
+
+    const rec = await worker.claimTimeout(7n);
+    expect(rec.hash).toMatch(/^0x[0-9a-f]{64}$/);
+    expect(escrow.calls.some((c) => c.method === 'claimTimeout')).toBe(true);
+    expect(claimed).toHaveLength(1);
+    expect(claimed[0]?.taskId).toBe(7n);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1 @@
+{ "extends": "./tsconfig.json", "compilerOptions": { "noEmit": false }, "exclude": ["test/**/*", "node_modules", "dist"] }

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/index.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,32 @@
+import { defineConfig } from 'tsup';
+
+const entries = [
+  'src/index.ts',
+  'src/agent/index.ts',
+  'src/worker/index.ts',
+  'src/verifier/index.ts',
+  'src/chain/index.ts',
+  'src/storage/index.ts',
+  'src/compute/index.ts',
+  'src/crypto/index.ts',
+  'src/api/index.ts',
+  'src/signer/index.ts',
+  'src/keystore/index.ts',
+  'src/events/index.ts',
+  'src/errors/index.ts',
+  'src/network/index.ts',
+  'src/testing/index.ts',
+];
+
+export default defineConfig({
+  entry: entries,
+  format: ['esm', 'cjs'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  treeshake: true,
+  splitting: false,
+  target: 'es2022',
+  tsconfig: './tsconfig.build.json',
+  outDir: 'dist',
+});

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: false,
+    include: ['test/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html', 'lcov'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/index.ts', 'src/**/*.d.ts'],
+      thresholds: { lines: 90, functions: 90, branches: 85, statements: 90 },
+    },
+    testTimeout: 20_000,
+  },
+});