@blindmarket/sdk 0.1.7 → 0.1.8

package/dist/executor/WorkerRuntime.d.ts

@@ -0,0 +1,113 @@
+import type { A2ATaskState, AgentCapability, ExecutorProfile, Message } from '../types.js';
+export interface WorkerRuntimeConfig {
+    apiKey: string;
+    apiBase?: string;
+    displayName: string;
+    capabilities: AgentCapability[];
+    executeTask: ExecuteTaskHandler;
+    existingPrivateKey?: string;
+    existingAddress?: string;
+    existingPublicKey?: string;
+    minReward?: string;
+    preferredCapabilities?: AgentCapability[];
+    browseIntervalMs?: number;
+    watchIntervalMs?: number;
+    maxConcurrentTasks?: number;
+}
+export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
+export interface TaskContext {
+    taskId: string;
+    task: A2ATaskState;
+    instructions: string;
+}
+export interface TaskExecutionInfo {
+    taskId: string;
+    status: 'bidding' | 'assigned' | 'working' | 'submitted' | 'completed' | 'failed';
+    task?: A2ATaskState;
+    error?: string;
+    startedAt: number;
+}
+export type WorkerRuntimeEvent = {
+    type: 'started';
+} | {
+    type: 'stopped';
+} | {
+    type: 'paused';
+} | {
+    type: 'resumed';
+} | {
+    type: 'registered';
+    profile: ExecutorProfile;
+} | {
+    type: 'task_found';
+    taskId: string;
+    task: A2ATaskState;
+} | {
+    type: 'task_bidded';
+    taskId: string;
+} | {
+    type: 'task_assigned';
+    taskId: string;
+} | {
+    type: 'task_accepted';
+    taskId: string;
+} | {
+    type: 'task_working';
+    taskId: string;
+} | {
+    type: 'task_executed';
+    taskId: string;
+} | {
+    type: 'task_submitted';
+    taskId: string;
+    result: Record<string, unknown>;
+} | {
+    type: 'task_failed';
+    taskId: string;
+    error: string;
+} | {
+    type: 'message_received';
+    message: Message;
+    count: number;
+} | {
+    type: 'browse_done';
+    found: number;
+} | {
+    type: 'error';
+    error: string;
+};
+export declare class WorkerRuntime {
+    private bb;
+    private config;
+    private wallet?;
+    private profile?;
+    private running;
+    private paused;
+    private browseTimer?;
+    private watchTimers;
+    private executions;
+    private listeners;
+    constructor(config: WorkerRuntimeConfig);
+    get isRunning(): boolean;
+    get isPaused(): boolean;
+    get activeExecutions(): TaskExecutionInfo[];
+    /** Get own executor profile (available after start). */
+    get executorProfile(): ExecutorProfile | undefined;
+    /** Get own wallet info (available after start). */
+    get executorWallet(): {
+        address: string;
+        publicKey: string;
+    } | undefined;
+    on(listener: (event: WorkerRuntimeEvent) => void): () => void;
+    private emit;
+    start(): Promise<ExecutorProfile>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    private startBrowseLoop;
+    private browse;
+    private watchForAssignment;
+    private executeTask;
+    private decodeWrappedKey;
+    private hexToBytes;
+}

package/dist/executor/WorkerRuntime.js

@@ -0,0 +1,248 @@
+import { BlindMarket } from '../index.js';
+import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
+// ── Defaults ────────────────────────────────────────────────────────────────
+const DEFAULTS = {
+    browseIntervalMs: 15_000,
+    watchIntervalMs: 5_000,
+    maxConcurrentTasks: 3,
+};
+// ── WorkerRuntime ───────────────────────────────────────────────────────────
+export class WorkerRuntime {
+    bb;
+    config;
+    wallet;
+    profile;
+    running = false;
+    paused = false;
+    browseTimer;
+    watchTimers = new Map();
+    executions = new Map();
+    listeners = new Set();
+    constructor(config) {
+        this.config = { ...DEFAULTS, ...config };
+        this.bb = new BlindMarket({ apiKey: config.apiKey, apiBase: config.apiBase });
+    }
+    // ── Status ──────────────────────────────────────────────────────────────
+    get isRunning() {
+        return this.running;
+    }
+    get isPaused() {
+        return this.paused;
+    }
+    get activeExecutions() {
+        return [...this.executions.values()];
+    }
+    /** Get own executor profile (available after start). */
+    get executorProfile() {
+        return this.profile;
+    }
+    /** Get own wallet info (available after start). */
+    get executorWallet() {
+        return this.wallet;
+    }
+    // ── Events ──────────────────────────────────────────────────────────────
+    on(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(event) {
+        for (const l of this.listeners)
+            l(event);
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async start() {
+        if (this.running)
+            return this.profile;
+        // 1. Register or restore executor
+        if (this.config.existingPrivateKey && this.config.existingAddress && this.config.existingPublicKey) {
+            this.wallet = {
+                address: this.config.existingAddress,
+                privateKey: this.config.existingPrivateKey,
+                publicKey: this.config.existingPublicKey,
+            };
+            // Fetch existing profile — backend identifies by API key
+            const result = await this.bb.getExecutorProfile();
+            this.profile = result.agent;
+        }
+        else {
+            const result = await this.bb.createAgent({
+                displayName: this.config.displayName,
+                capabilities: this.config.capabilities,
+                minReward: this.config.minReward,
+                preferredCapabilities: this.config.preferredCapabilities,
+            });
+            this.wallet = {
+                address: result.wallet.address,
+                privateKey: result.wallet.privateKey,
+                publicKey: result.wallet.publicKey,
+            };
+            this.profile = result.executor;
+        }
+        this.emit({ type: 'registered', profile: this.profile });
+        // 2. Start the browse loop
+        this.running = true;
+        this.startBrowseLoop();
+        this.emit({ type: 'started' });
+        return this.profile;
+    }
+    stop() {
+        this.running = false;
+        if (this.browseTimer) {
+            clearInterval(this.browseTimer);
+            this.browseTimer = undefined;
+        }
+        for (const t of this.watchTimers.values())
+            clearInterval(t);
+        this.watchTimers.clear();
+        this.emit({ type: 'stopped' });
+    }
+    pause() {
+        if (!this.running || this.paused)
+            return;
+        this.paused = true;
+        this.emit({ type: 'paused' });
+    }
+    resume() {
+        if (!this.running || !this.paused)
+            return;
+        this.paused = false;
+        this.emit({ type: 'resumed' });
+        // Immediately browse instead of waiting for next interval
+        this.browse();
+    }
+    // ── Browse loop ─────────────────────────────────────────────────────────
+    startBrowseLoop() {
+        const ms = this.config.browseIntervalMs;
+        this.browseTimer = setInterval(() => this.browse(), ms);
+        this.browse();
+    }
+    async browse() {
+        if (this.paused)
+            return;
+        try {
+            const active = this.activeExecutions;
+            const inFlight = active.filter(e => e.status === 'bidding' || e.status === 'working').length;
+            if (inFlight >= this.config.maxConcurrentTasks)
+                return;
+            const result = await this.bb.browseA2ATasks({
+                capabilities: this.config.capabilities,
+            });
+            this.emit({ type: 'browse_done', found: result.tasks.length });
+            for (const task of result.tasks) {
+                if (this.executions.has(task.taskId))
+                    continue;
+                if (task.status !== 'open' && task.status !== 'bidding')
+                    continue;
+                if (task.executorAddress && task.executorAddress !== this.wallet?.address)
+                    continue;
+                this.executions.set(task.taskId, {
+                    taskId: task.taskId,
+                    status: 'bidding',
+                    task,
+                    startedAt: Date.now(),
+                });
+                this.emit({ type: 'task_found', taskId: task.taskId, task });
+                await this.bb.bidOnTask(task.taskId);
+                this.emit({ type: 'task_bidded', taskId: task.taskId });
+                this.watchForAssignment(task.taskId);
+            }
+        }
+        catch (err) {
+            this.emit({ type: 'error', error: `Browse failed: ${err}` });
+        }
+    }
+    // ── Assignment watching ─────────────────────────────────────────────────
+    watchForAssignment(taskId) {
+        if (!this.running)
+            return;
+        const ms = this.config.watchIntervalMs;
+        const timer = setInterval(async () => {
+            if (!this.running || this.paused)
+                return;
+            try {
+                const detail = await this.bb.getTask(taskId);
+                const a2a = detail.a2aState;
+                if (!a2a)
+                    return;
+                if (a2a.status === 'assigned') {
+                    clearInterval(timer);
+                    this.watchTimers.delete(taskId);
+                    this.emit({ type: 'task_assigned', taskId });
+                    await this.executeTask(taskId, a2a);
+                }
+            }
+            catch {
+                // Retry next tick
+            }
+        }, ms);
+        this.watchTimers.set(taskId, timer);
+    }
+    // ── Task execution ──────────────────────────────────────────────────────
+    async executeTask(taskId, a2a) {
+        const exec = this.executions.get(taskId);
+        if (!exec)
+            return;
+        try {
+            exec.status = 'assigned';
+            // Accept task — get the ECIES-wrapped AES key
+            const acceptResult = await this.bb.acceptTask(taskId);
+            exec.task = acceptResult.task;
+            this.emit({ type: 'task_accepted', taskId });
+            // Get full task detail for the storage root hash
+            const detail = await this.bb.getTask(taskId);
+            const taskHash = detail.taskHash;
+            // Decrypt the wrapped key with the worker's private key
+            let instructions = '';
+            if (acceptResult.wrappedKey && taskHash) {
+                const wrappedBytes = this.decodeWrappedKey(acceptResult.wrappedKey);
+                const aesKey = await eciesDecrypt(wrappedBytes, this.wallet.privateKey);
+                // Download ciphertext from storage via REST API
+                const storageResult = await this.bb.downloadBlob(taskHash);
+                const ciphertext = this.hexToBytes(storageResult.data);
+                // AES decrypt to get plaintext instructions
+                const plaintext = await aesDecrypt(ciphertext, aesKey);
+                instructions = new TextDecoder().decode(plaintext);
+            }
+            exec.status = 'working';
+            this.emit({ type: 'task_working', taskId });
+            // Call the user-provided execution handler with decrypted instructions
+            const result = await this.config.executeTask({
+                taskId,
+                task: acceptResult.task,
+                instructions,
+            });
+            exec.status = 'submitted';
+            this.emit({ type: 'task_executed', taskId });
+            // Submit result
+            const submitResult = await this.bb.submitResult(taskId, result);
+            exec.status = 'completed';
+            this.emit({ type: 'task_submitted', taskId, result: submitResult });
+        }
+        catch (err) {
+            exec.status = 'failed';
+            exec.error = String(err);
+            this.emit({ type: 'task_failed', taskId, error: String(err) });
+        }
+    }
+    // ── Helpers ─────────────────────────────────────────────────────────────
+    decodeWrappedKey(wrappedKey) {
+        // Backend returns wrapped key as hex or base64 in a record
+        const hex = Object.values(wrappedKey)[0];
+        if (!hex)
+            throw new Error('Empty wrapped key');
+        const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+        const bytes = new Uint8Array(clean.length / 2);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+    hexToBytes(hex) {
+        const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+        const bytes = new Uint8Array(clean.length / 2);
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+}

package/dist/executor/index.d.ts

@@ -0,0 +1 @@
+export { WorkerRuntime, type WorkerRuntimeConfig, type ExecuteTaskHandler, type TaskContext, type TaskExecutionInfo, type WorkerRuntimeEvent, } from './WorkerRuntime.js';

package/dist/executor/index.js

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

package/dist/index.d.ts

@@ -343,4 +343,11 @@ export { ApiError };
 export { tools, createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './tools/index.js';
 export type { Tool, ToolKit, ToolDefinition } from './tools/types.js';
 export type { BlindMarketTools } from './tools/index.js';
+export * from './executor/index.js';
 export * from './types.js';
+export { EVMChainAdapter } from './chain/evm/index.js';
+export { createChainAdapter } from './chain/createChainAdapter.js';
+export type { CreateChainAdapterOptions } from './chain/createChainAdapter.js';
+export type { IBlindMarketChain } from './chain/IBlindMarketChain.js';
+export type { Network, EVMNetwork, BlockchainType, CreateTaskParams, DomainTask, DomainTaskMeta, DomainReputation, DomainTxReceipt, ChainSigner, } from './chain/domain-types.js';
+export { isEVMNetwork } from './network/resolve.js';

package/dist/index.js

@@ -130,7 +130,7 @@ export class BlindMarket {
     async submitEvidence(params) {
         return this.req('POST', '/api/v1/submissions/submit', params);
     }
-    // ── Agent deployment & management ────────────────────────────────────────
+    // ── Agent deployment & management ─────────────────────────────────────────
     /**
      * Deploy a new agent. The backend generates a wallet, mints an INFT,
      * and returns the agent descriptor.
@@ -274,7 +274,7 @@ export class BlindMarket {
      * Trigger TEE / AI verification for a task.
      */
     async verify(params) {
-        return this.req('POST', '/api/v1/verification/trigger', {
+        return this.req('POST', '/api/v1/verification/verify', {
             taskId: params.taskId,
             taskCategory: params.taskCategory,
             taskRequirements: params.taskRequirements,
@@ -307,7 +307,7 @@ export class BlindMarket {
     async downloadBlob(rootHash) {
         return this.req('GET', `/api/v1/storage/${rootHash}`);
     }
-    // ── Messages ────────────────────────────────────────────────────────────
+    // ── Messages ─────────────────────────────────────────────────────────────
     /** Send a message to another user or agent. */
     async sendMessage(params) {
         return this.req('POST', '/api/v1/messages/send', params);
@@ -458,4 +458,9 @@ export class BlindMarket {
 export { ethers };
 export { ApiError };
 export { tools, createBlindMarketTools, createTaskTools, createAgentManagementTools, createA2ATools, toLangChainTools, toVercelTools, toOpenAITools, toClaudeTools, } from './tools/index.js';
+export * from './executor/index.js';
 export * from './types.js';
+// Chain abstraction layer
+export { EVMChainAdapter } from './chain/evm/index.js';
+export { createChainAdapter } from './chain/createChainAdapter.js';
+export { isEVMNetwork } from './network/resolve.js';

package/dist/network/presets.d.ts

@@ -1,14 +1,43 @@
 /**
  * Known-good network presets. Addresses pinned per SDK version so upgrading
  * the SDK cannot silently move contracts under a consumer.
- *
- * testnet = 0G Galileo (chainId 16602) — addresses from
- * contracts/deployments/0g-testnet.json (deployed 2026-04-15).
  */
+export type NetworkName = 'testnet' | 'og-testnet' | 'og-mainnet';
 export declare const networks: {
+    readonly 'og-testnet': {
+        readonly name: "0g-galileo-testnet";
+        readonly chainType: "evm";
+        readonly chainId: 16602;
+        readonly rpc: ["https://evmrpc-testnet.0g.ai"];
+        readonly contracts: {
+            readonly escrow: "0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681";
+            readonly registry: "0xeE52d780A47F77E8a4a1cEb236e3C65A48FbD828";
+            readonly reputation: "0x4A6374Fae37E19E69ba43E7cf6994AC15F63256e";
+            readonly usdc: "0x317227efcA18D004E12CA8046AEf7E1597458F25";
+        };
+        readonly indexer: "https://indexer-storage-testnet-turbo.0g.ai";
+        readonly broker: "https://broker.testnet.0g.ai";
+        readonly explorer: "https://chainscan-galileo.0g.ai";
+    };
+    readonly 'og-mainnet': {
+        readonly name: "0g-mainnet";
+        readonly chainType: "evm";
+        readonly chainId: 16661;
+        readonly rpc: ["https://evmrpc.0g.ai"];
+        readonly contracts: {
+            readonly escrow: "0x3d0374963DaaD43e31d42373eb11156A8e8ce2Ff";
+            readonly registry: "0x9CCF9c196006B573FaA9C9c9CebDd1296dbd5cE0";
+            readonly reputation: "0x3af9232009C5da30AdA366B6E09849A040162A1a";
+            readonly usdc: "0x0000000000000000000000000000000000000000";
+        };
+        readonly indexer: "https://indexer-storage-turbo.0g.ai";
+        readonly broker: "https://broker.0g.ai";
+        readonly explorer: "https://chainscan.0g.ai";
+    };
     readonly testnet: {
         readonly name: "0g-galileo-testnet";
-        readonly chainId: 16602n;
+        readonly chainType: "evm";
+        readonly chainId: 16602;
         readonly rpc: ["https://evmrpc-testnet.0g.ai"];
         readonly contracts: {
             readonly escrow: "0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681";
@@ -21,4 +50,3 @@ export declare const networks: {
         readonly explorer: "https://chainscan-galileo.0g.ai";
     };
 };
-export type NetworkName = keyof typeof networks;

package/dist/network/presets.js

@@ -1,14 +1,41 @@
-/**
- * Known-good network presets. Addresses pinned per SDK version so upgrading
- * the SDK cannot silently move contracts under a consumer.
- *
- * testnet = 0G Galileo (chainId 16602) — addresses from
- * contracts/deployments/0g-testnet.json (deployed 2026-04-15).
- */
 export const networks = {
+    // ── 0G EVM chains ─────────────────────────────────────────────────────
+    'og-testnet': {
+        name: '0g-galileo-testnet',
+        chainType: 'evm',
+        chainId: 16602,
+        rpc: ['https://evmrpc-testnet.0g.ai'],
+        contracts: {
+            escrow: '0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681',
+            registry: '0xeE52d780A47F77E8a4a1cEb236e3C65A48FbD828',
+            reputation: '0x4A6374Fae37E19E69ba43E7cf6994AC15F63256e',
+            usdc: '0x317227efcA18D004E12CA8046AEf7E1597458F25',
+        },
+        indexer: 'https://indexer-storage-testnet-turbo.0g.ai',
+        broker: 'https://broker.testnet.0g.ai',
+        explorer: 'https://chainscan-galileo.0g.ai',
+    },
+    'og-mainnet': {
+        name: '0g-mainnet',
+        chainType: 'evm',
+        chainId: 16661,
+        rpc: ['https://evmrpc.0g.ai'],
+        contracts: {
+            escrow: '0x3d0374963DaaD43e31d42373eb11156A8e8ce2Ff',
+            registry: '0x9CCF9c196006B573FaA9C9c9CebDd1296dbd5cE0',
+            reputation: '0x3af9232009C5da30AdA366B6E09849A040162A1a',
+            usdc: '0x0000000000000000000000000000000000000000',
+        },
+        indexer: 'https://indexer-storage-turbo.0g.ai',
+        broker: 'https://broker.0g.ai',
+        explorer: 'https://chainscan.0g.ai',
+    },
+    // ── Backward-compat alias ──────────────────────────────────────────────
+    // Kept so existing code referencing 'testnet' doesn't break.
     testnet: {
         name: '0g-galileo-testnet',
-        chainId: 16602n,
+        chainType: 'evm',
+        chainId: 16602,
         rpc: ['https://evmrpc-testnet.0g.ai'],
         contracts: {
             escrow: '0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681',

package/dist/network/resolve.d.ts

@@ -1,7 +1,16 @@
 import { type NetworkName } from './presets.js';
-import type { Network } from './types.js';
+import type { Network } from '../chain/domain-types.js';
 /**
- * Resolve a preset name or a literal Network object into the canonical
- * Network used throughout the SDK. Throws ConfigError for unknown names.
+ * Resolve a network preset name or a Network object to a canonical Network.
+ *
+ * When given a string, looks up the preset. When given a Network object,
+ * returns it as-is (pass-through for callers that already have a resolved
+ * network config).
  */
 export declare function resolveNetwork(arg: NetworkName | Network): Network;
+/**
+ * Type guard: check if a Network is an EVM network.
+ */
+export declare function isEVMNetwork(network: Network): network is Network & {
+    chainType: 'evm';
+};

package/dist/network/resolve.js

@@ -1,17 +1,25 @@
 import { ConfigError } from '../errors/index.js';
 import { networks } from './presets.js';
 /**
- * Resolve a preset name or a literal Network object into the canonical
- * Network used throughout the SDK. Throws ConfigError for unknown names.
+ * Resolve a network preset name or a Network object to a canonical Network.
+ *
+ * When given a string, looks up the preset. When given a Network object,
+ * returns it as-is (pass-through for callers that already have a resolved
+ * network config).
  */
 export function resolveNetwork(arg) {
     if (typeof arg === 'string') {
-        const preset = networks[arg];
-        if (!preset) {
-            const known = Object.keys(networks).join(', ');
-            throw new ConfigError('CONFIG/INVALID_NETWORK', `unknown network '${arg}' (known: ${known})`);
+        const net = networks[arg];
+        if (!net) {
+            throw new ConfigError('CONFIG/INVALID_NETWORK', `Unknown network: "${arg}". Known presets: ${Object.keys(networks).join(', ')}`);
         }
-        return preset;
+        return net;
     }
     return arg;
 }
+/**
+ * Type guard: check if a Network is an EVM network.
+ */
+export function isEVMNetwork(network) {
+    return network.chainType === 'evm';
+}

package/dist/network/types.d.ts

@@ -1,16 +1,3 @@
-import type { Address } from '../types.js';
-export interface NetworkContracts {
-    escrow: Address;
-    registry: Address;
-    reputation: Address;
-    usdc: Address;
-}
-export interface Network {
-    name: string;
-    chainId: bigint;
-    rpc: string[];
-    contracts: NetworkContracts;
-    indexer: string;
-    broker: string;
-    explorer?: string;
-}
+import type { NetworkName } from './presets.js';
+export type { Network, EVMNetwork, NetworkBase, BlockchainType, CreateTaskParams, DomainTask, DomainTaskMeta, DomainReputation, DomainTxReceipt, ChainSigner, } from '../chain/domain-types.js';
+export type { NetworkName };

package/dist/types.d.ts

@@ -12,7 +12,7 @@ export interface Reward {
     token: Address | TokenSymbol;
     amount: bigint;
 }
-export type TaskStatus = 'funded' | 'assigned' | 'submitted' | 'verified' | 'completed' | 'cancelled';
+export type TaskStatus = 'funded' | 'assigned' | 'submitted' | 'verified' | 'completed' | 'cancelled' | 'disputed';
 export interface TaskMetadata {
     category: string;
     locationZone: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blindmarket/sdk",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "BlindMarket SDK — deploy agents, assign workers, verify evidence",
   "author": "BlindMarket Team",
   "license": "MIT",

package/src/chain/BlindEscrowClient.ts

@@ -3,7 +3,7 @@ import type { Address, Hex, TaskId, TaskStatus, TxReceiptLike } from '../types.j
 import { BlindEscrowAbi } from './abi/index.js';
 import { wrapChainError } from './errors.js';
 
-const STATUS_BY_INDEX: TaskStatus[] = ['funded', 'assigned', 'submitted', 'verified', 'completed', 'cancelled'];
+const STATUS_BY_INDEX: TaskStatus[] = ['funded', 'assigned', 'submitted', 'verified', 'completed', 'cancelled', 'disputed'];
 
 export interface CreateTaskArgs {
   taskHash: Hex;
@@ -23,6 +23,8 @@ export interface OnChainTask {
   taskHash: Hex;
   evidenceHash: Hex;
   status: TaskStatus;
+  category: string;
+  locationZone: string;
   createdAt: Date;
   deadline: Date;
 }
@@ -168,10 +170,15 @@ function toReceipt(rec: ethers.ContractTransactionReceipt | null): TxReceiptLike
 }
 
 function decodeTask(taskId: TaskId, raw: ethers.Result): OnChainTask {
-  // Tuple order from BlindEscrow.getTask(): (agent, worker, token, amount, taskHash,
-  // evidenceHash, status, createdAt, deadline) — verify against contracts/BlindEscrow.sol.
+  // Live Task struct (12 fields) from BlindEscrow.getTask(): agent, worker,
+  // token, amount, taskHash, evidenceHash, status, category, locationZone,
+  // createdAt, deadline, submissionAttempts. The old decode read createdAt from
+  // arr[7] (actually category) and deadline from arr[8] (actually locationZone),
+  // yielding Invalid Date and discarding category/locationZone.
   const arr = raw as unknown as unknown[];
   const statusIndex = Number(arr[6]);
+  const status = STATUS_BY_INDEX[statusIndex];
+  if (!status) throw new Error(`BlindEscrow.getTask returned unknown status index ${statusIndex}`);
   return {
     taskId,
     agent: arr[0] as Address,
@@ -180,8 +187,10 @@ function decodeTask(taskId: TaskId, raw: ethers.Result): OnChainTask {
     amount: BigInt(arr[3] as bigint | number),
     taskHash: arr[4] as Hex,
     evidenceHash: arr[5] as Hex,
-    status: STATUS_BY_INDEX[statusIndex] ?? 'funded',
-    createdAt: new Date(Number(arr[7] as bigint | number) * 1000),
-    deadline: new Date(Number(arr[8] as bigint | number) * 1000),
+    status,
+    category: arr[7] as string,
+    locationZone: arr[8] as string,
+    createdAt: new Date(Number(arr[9] as bigint | number) * 1000),
+    deadline: new Date(Number(arr[10] as bigint | number) * 1000),
   };
 }