@blindmarket/sdk 0.1.7 → 0.4.0

package/test/network.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ConfigError } from '../src/errors/index.js';
-import { networks, resolveNetwork, type Network } from '../src/network/index.js';
-
-describe('networks', () => {
-  it('testnet preset matches 0G Galileo', () => {
-    expect(networks.testnet.chainId).toBe(16602n);
-    expect(networks.testnet.contracts.escrow).toMatch(/^0x[a-fA-F0-9]{40}$/);
-    expect(networks.testnet.contracts.registry).toMatch(/^0x[a-fA-F0-9]{40}$/);
-    expect(networks.testnet.contracts.reputation).toMatch(/^0x[a-fA-F0-9]{40}$/);
-    expect(networks.testnet.contracts.usdc).toMatch(/^0x[a-fA-F0-9]{40}$/);
-    expect(networks.testnet.rpc.length).toBeGreaterThan(0);
-    expect(networks.testnet.indexer).toBeTruthy();
-    expect(networks.testnet.broker).toBeTruthy();
-  });
-
-  it('testnet addresses match contracts/deployments/0g-testnet.json', () => {
-    expect(networks.testnet.contracts.escrow).toBe('0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681');
-    expect(networks.testnet.contracts.registry).toBe('0xeE52d780A47F77E8a4a1cEb236e3C65A48FbD828');
-    expect(networks.testnet.contracts.reputation).toBe('0x4A6374Fae37E19E69ba43E7cf6994AC15F63256e');
-    expect(networks.testnet.contracts.usdc).toBe('0x317227efcA18D004E12CA8046AEf7E1597458F25');
-  });
-
-  it('resolveNetwork accepts a preset name', () => {
-    const n = resolveNetwork('testnet');
-    expect(n.chainId).toBe(16602n);
-    expect(n.name).toBe('0g-galileo-testnet');
-  });
-
-  it('resolveNetwork rejects unknown preset with ConfigError', () => {
-    // biome-ignore lint/suspicious/noExplicitAny: intentional type escape to test runtime error path
-    expect(() => resolveNetwork('nope' as any)).toThrow(ConfigError);
-  });
-
-  it('resolveNetwork passes through a custom network object', () => {
-    const custom: Network = {
-      name: 'localhost',
-      chainId: 1337n,
-      rpc: ['http://localhost:8545'],
-      contracts: {
-        escrow: '0x0000000000000000000000000000000000000001',
-        registry: '0x0000000000000000000000000000000000000002',
-        reputation: '0x0000000000000000000000000000000000000003',
-        usdc: '0x0000000000000000000000000000000000000004',
-      },
-      indexer: '',
-      broker: '',
-    };
-    const resolved = resolveNetwork(custom);
-    expect(resolved).toBe(custom);
-    expect(resolved.chainId).toBe(1337n);
-  });
-});

package/test/signer.test.ts

@@ -1,66 +0,0 @@
-import { ethers } from 'ethers';
-import { describe, expect, it } from 'vitest';
-import { eciesDecrypt, eciesEncrypt } from '../src/crypto/index.js';
-import { EthersSigner, PrivateKeySigner } from '../src/signer/index.js';
-
-const FIXED_PK = '0x0123456789012345678901234567890123456789012345678901234567890123';
-const FIXED_ADDR = '0x14791697260E4c9A71f18484C9f997B308e59325';
-
-describe('PrivateKeySigner', () => {
-  it('derives the correct address from a known private key', async () => {
-    const signer = new PrivateKeySigner(FIXED_PK);
-    expect((await signer.getAddress()).toLowerCase()).toBe(FIXED_ADDR.toLowerCase());
-  });
-
-  it('accepts the private key with or without 0x prefix', async () => {
-    const a = new PrivateKeySigner(FIXED_PK);
-    const b = new PrivateKeySigner(FIXED_PK.slice(2));
-    expect(await a.getAddress()).toBe(await b.getAddress());
-  });
-
-  it('signMessage produces a signature that recovers to the signer address', async () => {
-    const signer = new PrivateKeySigner(FIXED_PK);
-    const msg = 'hello';
-    const sig = await signer.signMessage(msg);
-    const recovered = ethers.verifyMessage(msg, sig);
-    expect(recovered.toLowerCase()).toBe(FIXED_ADDR.toLowerCase());
-  });
-
-  it('getPublicKey returns the uncompressed key (65 bytes / 130 hex + 0x)', async () => {
-    const signer = new PrivateKeySigner(FIXED_PK);
-    const pub = await signer.getPublicKey();
-    expect(pub.startsWith('0x04')).toBe(true);
-    expect(pub.length).toBe(2 + 130);
-  });
-
-  it('pubkey from signer round-trips through ECIES', async () => {
-    const signer = new PrivateKeySigner(FIXED_PK);
-    const pub = await signer.getPublicKey();
-    const plaintext = new TextEncoder().encode('direct-to-signer-pubkey');
-    const blob = await eciesEncrypt(plaintext, pub);
-    const pt = await eciesDecrypt(blob, FIXED_PK);
-    expect(new TextDecoder().decode(pt)).toBe('direct-to-signer-pubkey');
-  });
-
-  it('getPublicKey is cached (returns identical string instance)', async () => {
-    const signer = new PrivateKeySigner(FIXED_PK);
-    const a = await signer.getPublicKey();
-    const b = await signer.getPublicKey();
-    expect(a).toBe(b);
-  });
-});
-
-describe('EthersSigner wrapping an arbitrary ethers.Signer', () => {
-  it('wraps a provider-less Wallet and passes through signMessage', async () => {
-    const wallet = new ethers.Wallet(FIXED_PK);
-    const signer = new EthersSigner(wallet);
-    const sig = await signer.signMessage('x');
-    expect(ethers.verifyMessage('x', sig).toLowerCase()).toBe(FIXED_ADDR.toLowerCase());
-  });
-
-  it('chainId throws ConfigError when no provider is attached', async () => {
-    const wallet = new ethers.Wallet(FIXED_PK);
-    const signer = new EthersSigner(wallet);
-    await expect(signer.chainId()).rejects.toMatchObject({ code: 'CONFIG/BAD_CONFIG' });
-  });
-});

package/test/smoke.test.ts

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-describe('smoke', () => {
-  it('vitest runs', () => {
-    expect(1 + 1).toBe(2);
-  });
-});

package/test/storage.test.ts

@@ -1,55 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

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

package/tsconfig.json

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

package/tsup.config.ts

@@ -1,32 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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,
-  },
-});