@blindmarket/sdk 0.1.4

package/dist/errors/subclasses.js

@@ -0,0 +1,41 @@
+import { BlindBountyError } from './BlindBountyError.js';
+export class ConfigError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class CryptoError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class StorageError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class ChainError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class ComputeError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class ApiError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class LifecycleError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}
+export class TimeoutError extends BlindBountyError {
+    constructor(code, msg, opts) {
+        super(code, msg, opts);
+    }
+}

package/dist/events/EventBus.d.ts

@@ -0,0 +1,13 @@
+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 declare class EventBus<E> {
+    private handlers;
+    on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void;
+    once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void;
+    off<K extends keyof E>(event: K, fn: Handler<E[K]>): void;
+    emit<K extends keyof E>(event: K, payload: E[K]): void;
+}
+export {};

package/dist/events/EventBus.js

@@ -0,0 +1,41 @@
+/**
+ * Typed pub/sub. Listener exceptions are swallowed so one bad subscriber
+ * cannot block others — telemetry plugins can observe failures via onError.
+ */
+export class EventBus {
+    handlers = {};
+    on(event, fn) {
+        let set = this.handlers[event];
+        if (!set) {
+            set = new Set();
+            this.handlers[event] = set;
+        }
+        set.add(fn);
+        return () => {
+            this.off(event, fn);
+        };
+    }
+    once(event, fn) {
+        const wrapped = (p) => {
+            this.off(event, wrapped);
+            fn(p);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, fn) {
+        this.handlers[event]?.delete(fn);
+    }
+    emit(event, payload) {
+        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/dist/events/index.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+// src/events/EventBus.ts
+var EventBus = class {
+  handlers = {};
+  on(event, fn) {
+    let set = this.handlers[event];
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers[event] = set;
+    }
+    set.add(fn);
+    return () => {
+      this.off(event, fn);
+    };
+  }
+  once(event, fn) {
+    const wrapped = (p) => {
+      this.off(event, wrapped);
+      fn(p);
+    };
+    return this.on(event, wrapped);
+  }
+  off(event, fn) {
+    this.handlers[event]?.delete(fn);
+  }
+  emit(event, payload) {
+    const hs = this.handlers[event];
+    if (!hs) return;
+    for (const h of hs) {
+      try {
+        h(payload);
+      } catch {
+      }
+    }
+  }
+};
+
+exports.EventBus = EventBus;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/events/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/events/EventBus.ts"],"names":[],"mappings":";;;AAMO,IAAM,WAAN,MAAkB;AAAA,EACf,WAAoD,EAAC;AAAA,EAE7D,EAAA,CAAsB,OAAU,EAAA,EAA+B;AAC7D,IAAA,IAAI,GAAA,GAAM,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA;AAC7B,IAAA,IAAI,CAAC,GAAA,EAAK;AACR,MAAA,GAAA,uBAAU,GAAA,EAAmB;AAC7B,MAAA,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA,GAAI,GAAA;AAAA,IACzB;AACA,IAAA,GAAA,CAAI,IAAI,EAAE,CAAA;AACV,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,EAAE,CAAA;AAAA,IACpB,CAAA;AAAA,EACF;AAAA,EAEA,IAAA,CAAwB,OAAU,EAAA,EAA+B;AAC/D,IAAA,MAAM,OAAA,GAAyB,CAAC,CAAA,KAAM;AACpC,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,OAAO,CAAA;AACvB,MAAA,EAAA,CAAG,CAAC,CAAA;AAAA,IACN,CAAA;AACA,IAAA,OAAO,IAAA,CAAK,EAAA,CAAG,KAAA,EAAO,OAAO,CAAA;AAAA,EAC/B;AAAA,EAEA,GAAA,CAAuB,OAAU,EAAA,EAAyB;AACxD,IAAA,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA,EAAG,MAAA,CAAO,EAAE,CAAA;AAAA,EACjC;AAAA,EAEA,IAAA,CAAwB,OAAU,OAAA,EAAqB;AACrD,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA;AAC9B,IAAA,IAAI,CAAC,EAAA,EAAI;AACT,IAAA,KAAA,MAAW,KAAK,EAAA,EAAI;AAClB,MAAA,IAAI;AACF,QAAA,CAAA,CAAE,OAAO,CAAA;AAAA,MACX,CAAA,CAAA,MAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AACF","file":"index.cjs","sourcesContent":["type Handler<T> = (payload: T) => void;\n\n/**\n * Typed pub/sub. Listener exceptions are swallowed so one bad subscriber\n * cannot block others — telemetry plugins can observe failures via onError.\n */\nexport class EventBus<E> {\n  private handlers: { [K in keyof E]?: Set<Handler<E[K]>> } = {};\n\n  on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {\n    let set = this.handlers[event];\n    if (!set) {\n      set = new Set<Handler<E[K]>>();\n      this.handlers[event] = set;\n    }\n    set.add(fn);\n    return () => {\n      this.off(event, fn);\n    };\n  }\n\n  once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {\n    const wrapped: Handler<E[K]> = (p) => {\n      this.off(event, wrapped);\n      fn(p);\n    };\n    return this.on(event, wrapped);\n  }\n\n  off<K extends keyof E>(event: K, fn: Handler<E[K]>): void {\n    this.handlers[event]?.delete(fn);\n  }\n\n  emit<K extends keyof E>(event: K, payload: E[K]): void {\n    const hs = this.handlers[event];\n    if (!hs) return;\n    for (const h of hs) {\n      try {\n        h(payload);\n      } catch {\n        // Isolated per-listener — prevents one bad subscriber from blocking others.\n      }\n    }\n  }\n}\n"]}

package/dist/events/index.d.cts

@@ -0,0 +1,61 @@
+import { T as TaskId, H as Hex, d as RootHash, A as Address } from '../types-BOG5Ub1z.cjs';
+
+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.
+ */
+declare class EventBus<E> {
+    private handlers;
+    on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void;
+    once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void;
+    off<K extends keyof E>(event: K, fn: Handler<E[K]>): void;
+    emit<K extends keyof E>(event: K, payload: E[K]): void;
+}
+
+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;
+    };
+}
+
+export { EventBus, type SdkEvents };

package/dist/events/index.d.ts

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

package/dist/events/index.js

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

package/dist/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/events/EventBus.ts"],"names":[],"mappings":";AAMO,IAAM,WAAN,MAAkB;AAAA,EACf,WAAoD,EAAC;AAAA,EAE7D,EAAA,CAAsB,OAAU,EAAA,EAA+B;AAC7D,IAAA,IAAI,GAAA,GAAM,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA;AAC7B,IAAA,IAAI,CAAC,GAAA,EAAK;AACR,MAAA,GAAA,uBAAU,GAAA,EAAmB;AAC7B,MAAA,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA,GAAI,GAAA;AAAA,IACzB;AACA,IAAA,GAAA,CAAI,IAAI,EAAE,CAAA;AACV,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,EAAE,CAAA;AAAA,IACpB,CAAA;AAAA,EACF;AAAA,EAEA,IAAA,CAAwB,OAAU,EAAA,EAA+B;AAC/D,IAAA,MAAM,OAAA,GAAyB,CAAC,CAAA,KAAM;AACpC,MAAA,IAAA,CAAK,GAAA,CAAI,OAAO,OAAO,CAAA;AACvB,MAAA,EAAA,CAAG,CAAC,CAAA;AAAA,IACN,CAAA;AACA,IAAA,OAAO,IAAA,CAAK,EAAA,CAAG,KAAA,EAAO,OAAO,CAAA;AAAA,EAC/B;AAAA,EAEA,GAAA,CAAuB,OAAU,EAAA,EAAyB;AACxD,IAAA,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA,EAAG,MAAA,CAAO,EAAE,CAAA;AAAA,EACjC;AAAA,EAEA,IAAA,CAAwB,OAAU,OAAA,EAAqB;AACrD,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,QAAA,CAAS,KAAK,CAAA;AAC9B,IAAA,IAAI,CAAC,EAAA,EAAI;AACT,IAAA,KAAA,MAAW,KAAK,EAAA,EAAI;AAClB,MAAA,IAAI;AACF,QAAA,CAAA,CAAE,OAAO,CAAA;AAAA,MACX,CAAA,CAAA,MAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AACF","file":"index.js","sourcesContent":["type Handler<T> = (payload: T) => void;\n\n/**\n * Typed pub/sub. Listener exceptions are swallowed so one bad subscriber\n * cannot block others — telemetry plugins can observe failures via onError.\n */\nexport class EventBus<E> {\n  private handlers: { [K in keyof E]?: Set<Handler<E[K]>> } = {};\n\n  on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {\n    let set = this.handlers[event];\n    if (!set) {\n      set = new Set<Handler<E[K]>>();\n      this.handlers[event] = set;\n    }\n    set.add(fn);\n    return () => {\n      this.off(event, fn);\n    };\n  }\n\n  once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {\n    const wrapped: Handler<E[K]> = (p) => {\n      this.off(event, wrapped);\n      fn(p);\n    };\n    return this.on(event, wrapped);\n  }\n\n  off<K extends keyof E>(event: K, fn: Handler<E[K]>): void {\n    this.handlers[event]?.delete(fn);\n  }\n\n  emit<K extends keyof E>(event: K, payload: E[K]): void {\n    const hs = this.handlers[event];\n    if (!hs) return;\n    for (const h of hs) {\n      try {\n        h(payload);\n      } catch {\n        // Isolated per-listener — prevents one bad subscriber from blocking others.\n      }\n    }\n  }\n}\n"]}

package/dist/events/types.d.ts

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

package/dist/events/types.js

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

package/dist/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/index.d.cts

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

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+import { Wallet, ethers } from 'ethers';
+export interface BlindMarketConfig {
+    apiBase?: string;
+    apiKey: string;
+    rpcUrl?: string;
+}
+export interface DeployAgentParams {
+    name: string;
+    instructions: string;
+    provider: 'openai' | 'anthropic' | 'groq' | 'gemini';
+    model: string;
+    apiKey: string;
+    ownerAddress: string;
+    ownerPublicKey: string;
+    capabilities?: string[];
+    tools?: object[];
+}
+export interface PostTaskParams {
+    instructions: string;
+    category: string;
+    amount: string;
+    token: string;
+    locationZone?: string;
+    duration?: string;
+}
+export interface DeployedAgent {
+    id: string;
+    name: string;
+    walletAddress: string;
+    publicKey: string;
+    inftTokenId?: number;
+    status: string;
+}
+export interface PostedTask {
+    unsignedTx: object;
+    taskHash: string;
+    storageRoot: string;
+}
+export declare class BlindMarket {
+    private apiBase;
+    private apiKey;
+    constructor(config: BlindMarketConfig);
+    private req;
+    /**
+     * Deploy a new agent. Generates a wallet, mints an INFT, returns the agent.
+     *
+     * @example
+     * const agent = await bb.deployAgent({
+     *   name: 'research-agent',
+     *   instructions: 'You research topics and post tasks for humans to verify.',
+     *   provider: 'anthropic',
+     *   model: 'claude-sonnet-4-5',
+     *   apiKey: process.env.ANTHROPIC_API_KEY!,
+     *   ownerAddress: wallet.address,
+     *   ownerPublicKey: wallet.publicKey,
+     * });
+     */
+    deployAgent(params: DeployAgentParams): Promise<DeployedAgent>;
+    /**
+     * List all agents owned by an address.
+     */
+    listAgents(ownerAddress: string): Promise<DeployedAgent[]>;
+    /**
+     * Encrypt instructions and post a task. Returns an unsigned tx to sign + broadcast.
+     *
+     * @example
+     * const { unsignedTx, taskHash } = await bb.postTask({
+     *   instructions: 'Photograph the exterior of 42 Oak Street, NYC.',
+     *   category: 'photography',
+     *   amount: ethers.parseEther('30').toString(),
+     *   token: '0x317227efcA18D004E12CA8046AEf7E1597458F25',
+     *   locationZone: 'US-NY',
+     * });
+     * const receipt = await wallet.sendTransaction(unsignedTx);
+     */
+    postTask(params: PostTaskParams): Promise<PostedTask>;
+    /**
+     * Assign a worker to a task. Returns an unsigned tx.
+     */
+    assignWorker(taskId: string, worker: string): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Trigger TEE verification for a task.
+     */
+    verify(params: {
+        taskId: number;
+        requirements: string;
+        evidenceSummary: string;
+        category?: string;
+    }): Promise<{
+        passed: boolean;
+        confidence: number;
+        reasoning: string;
+    }>;
+    /**
+     * Submit evidence for an assigned task.
+     */
+    submitEvidence(params: {
+        taskId: number;
+        evidence: string;
+    }): Promise<{
+        unsignedTx: object;
+    }>;
+    /**
+     * Get task status.
+     */
+    getTask(taskId: string): Promise<{
+        status: number;
+        agent: string;
+        worker: string;
+        amount: string;
+    }>;
+    /**
+     * List open tasks.
+     */
+    listTasks(limit?: number): Promise<object[]>;
+    /**
+     * Authenticate with a wallet and return a JWT.
+     * Use this to get the apiKey for the constructor.
+     *
+     * @example
+     * const wallet = new ethers.Wallet(privateKey);
+     * const apiKey = await BlindMarket.authenticate(wallet, 'http://localhost:3001');
+     * const bb = new BlindMarket({ apiKey });
+     */
+    static authenticate(wallet: Wallet, apiBase?: string): Promise<string>;
+}
+export { ethers };

package/dist/index.js

@@ -0,0 +1,154 @@
+import { ethers } from 'ethers';
+import { createCipheriv, randomBytes, createHash } from 'crypto';
+export class BlindMarket {
+    apiBase;
+    apiKey;
+    constructor(config) {
+        this.apiBase = config.apiBase ?? 'http://localhost:3001';
+        this.apiKey = config.apiKey;
+    }
+    async req(method, path, body) {
+        const res = await fetch(`${this.apiBase}${path}`, {
+            method,
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.apiKey}` },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        if (!json.success)
+            throw new Error(json.error?.message ?? `HTTP ${res.status}`);
+        return json.data;
+    }
+    // ── Agent deployment ──────────────────────────────────────────────────────
+    /**
+     * Deploy a new agent. Generates a wallet, mints an INFT, returns the agent.
+     *
+     * @example
+     * const agent = await bb.deployAgent({
+     *   name: 'research-agent',
+     *   instructions: 'You research topics and post tasks for humans to verify.',
+     *   provider: 'anthropic',
+     *   model: 'claude-sonnet-4-5',
+     *   apiKey: process.env.ANTHROPIC_API_KEY!,
+     *   ownerAddress: wallet.address,
+     *   ownerPublicKey: wallet.publicKey,
+     * });
+     */
+    async deployAgent(params) {
+        return this.req('POST', '/api/v1/agents/deploy', params);
+    }
+    /**
+     * List all agents owned by an address.
+     */
+    async listAgents(ownerAddress) {
+        return this.req('GET', `/api/v1/agents?owner=${ownerAddress}`);
+    }
+    // ── Task lifecycle ────────────────────────────────────────────────────────
+    /**
+     * Encrypt instructions and post a task. Returns an unsigned tx to sign + broadcast.
+     *
+     * @example
+     * const { unsignedTx, taskHash } = await bb.postTask({
+     *   instructions: 'Photograph the exterior of 42 Oak Street, NYC.',
+     *   category: 'photography',
+     *   amount: ethers.parseEther('30').toString(),
+     *   token: '0x317227efcA18D004E12CA8046AEf7E1597458F25',
+     *   locationZone: 'US-NY',
+     * });
+     * const receipt = await wallet.sendTransaction(unsignedTx);
+     */
+    async postTask(params) {
+        // Encrypt instructions
+        const key = randomBytes(32);
+        const iv = randomBytes(12);
+        const cipher = createCipheriv('aes-256-gcm', key, iv);
+        const encrypted = Buffer.concat([cipher.update(params.instructions, 'utf8'), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        const blob = Buffer.concat([iv, tag, encrypted]).toString('base64');
+        // Upload to storage
+        const { rootHash } = await this.req('POST', '/api/v1/storage/upload', { data: blob });
+        // taskHash = SHA-256 of ciphertext
+        const taskHash = '0x' + createHash('sha256').update(Buffer.concat([iv, tag, encrypted])).digest('hex');
+        // Build unsigned tx
+        const { unsignedTx } = await this.req('POST', '/api/v1/tasks', {
+            taskHash,
+            token: params.token,
+            amount: params.amount,
+            category: params.category,
+            locationZone: params.locationZone ?? 'global',
+            duration: params.duration ?? '86400',
+        });
+        return { unsignedTx, taskHash, storageRoot: rootHash };
+    }
+    /**
+     * Assign a worker to a task. Returns an unsigned tx.
+     */
+    async assignWorker(taskId, worker) {
+        return this.req('POST', `/api/v1/tasks/${taskId}/assign`, { worker });
+    }
+    /**
+     * Trigger TEE verification for a task.
+     */
+    async verify(params) {
+        return this.req('POST', '/api/v1/verification/trigger', {
+            taskId: params.taskId,
+            taskCategory: params.category ?? 'general',
+            taskRequirements: params.requirements,
+            evidenceSummary: params.evidenceSummary,
+        });
+    }
+    /**
+     * Submit evidence for an assigned task.
+     */
+    async submitEvidence(params) {
+        const key = randomBytes(32);
+        const iv = randomBytes(12);
+        const cipher = createCipheriv('aes-256-gcm', key, iv);
+        const encrypted = Buffer.concat([cipher.update(params.evidence, 'utf8'), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        const blob = Buffer.concat([iv, tag, encrypted]).toString('base64');
+        await this.req('POST', '/api/v1/storage/upload', { data: blob });
+        const evidenceHash = '0x' + createHash('sha256').update(Buffer.concat([iv, tag, encrypted])).digest('hex');
+        return this.req('POST', '/api/v1/submissions/submit', { taskId: params.taskId, evidenceHash });
+    }
+    /**
+     * Get task status.
+     */
+    async getTask(taskId) {
+        return this.req('GET', `/api/v1/tasks/${taskId}`);
+    }
+    /**
+     * List open tasks.
+     */
+    async listTasks(limit = 20) {
+        const { tasks } = await this.req('GET', `/api/v1/tasks?limit=${limit}`);
+        return tasks;
+    }
+    // ── Auth helper ───────────────────────────────────────────────────────────
+    /**
+     * Authenticate with a wallet and return a JWT.
+     * Use this to get the apiKey for the constructor.
+     *
+     * @example
+     * const wallet = new ethers.Wallet(privateKey);
+     * const apiKey = await BlindMarket.authenticate(wallet, 'http://localhost:3001');
+     * const bb = new BlindMarket({ apiKey });
+     */
+    static async authenticate(wallet, apiBase = 'http://localhost:3001') {
+        const nonceRes = await fetch(`${apiBase}/api/v1/auth/nonce`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ address: wallet.address }),
+        });
+        const { data: { nonce } } = await nonceRes.json();
+        const message = `Sign this message to authenticate with BlindMarket.\n\nNonce: ${nonce}`;
+        const signature = await wallet.signMessage(message);
+        const verifyRes = await fetch(`${apiBase}/api/v1/auth/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ address: wallet.address, signature }),
+        });
+        const { data: { token } } = await verifyRes.json();
+        return token;
+    }
+}
+export { ethers };

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/keystore/InMemoryKeyStore.d.ts

@@ -0,0 +1,21 @@
+import { generateAesKey } from '../crypto/index.js';
+import type { Address, Hex, TaskId, TaskKey, TaskKeyRef } from '../types.js';
+import type { KeyStore } from './KeyStore.js';
+/**
+ * Default KeyStore. Non-persistent — keys live only for the process lifetime.
+ * Export/import is encrypted with a passphrase via HKDF-derived AES-256-GCM,
+ * so exported blobs are safe to move between processes.
+ */
+export declare class InMemoryKeyStore implements KeyStore {
+    private readonly keys;
+    private readonly peers;
+    putTaskKey(taskId: TaskId, key: TaskKey): Promise<void>;
+    getTaskKey(taskId: TaskId): Promise<TaskKey | null>;
+    putPeerPubKey(addr: Address, pubkey: Hex): Promise<void>;
+    getPeerPubKey(addr: Address): Promise<Hex | null>;
+    list(): Promise<TaskKeyRef[]>;
+    delete(taskId: TaskId): Promise<void>;
+    export(passphrase: string): Promise<string>;
+    import(data: string, passphrase: string): Promise<void>;
+}
+export { generateAesKey };