@blindmarket/sdk 0.1.7 → 0.1.8

package/dist/chain/BlindEscrowClient.d.ts

@@ -17,6 +17,8 @@ export interface OnChainTask {
     taskHash: Hex;
     evidenceHash: Hex;
     status: TaskStatus;
+    category: string;
+    locationZone: string;
     createdAt: Date;
     deadline: Date;
 }

package/dist/chain/BlindEscrowClient.js

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers';
 import { BlindEscrowAbi } from './abi/index.js';
 import { wrapChainError } from './errors.js';
-const STATUS_BY_INDEX = ['funded', 'assigned', 'submitted', 'verified', 'completed', 'cancelled'];
+const STATUS_BY_INDEX = ['funded', 'assigned', 'submitted', 'verified', 'completed', 'cancelled', 'disputed'];
 /**
  * Typed ethers v6 wrapper for the BlindEscrow contract. Every state-changing
  * method awaits one confirmation and returns a TxReceiptLike; every read
@@ -127,10 +127,16 @@ function toReceipt(rec) {
     };
 }
 function decodeTask(taskId, raw) {
-    // 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;
     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],
@@ -139,8 +145,10 @@ function decodeTask(taskId, raw) {
         amount: BigInt(arr[3]),
         taskHash: arr[4],
         evidenceHash: arr[5],
-        status: STATUS_BY_INDEX[statusIndex] ?? 'funded',
-        createdAt: new Date(Number(arr[7]) * 1000),
-        deadline: new Date(Number(arr[8]) * 1000),
+        status,
+        category: arr[7],
+        locationZone: arr[8],
+        createdAt: new Date(Number(arr[9]) * 1000),
+        deadline: new Date(Number(arr[10]) * 1000),
     };
 }

package/dist/chain/BlindReputationClient.d.ts

@@ -2,8 +2,11 @@ import { ethers } from 'ethers';
 import type { Address, TaskId, TxReceiptLike } from '../types.js';
 export interface ReputationSnapshot {
     tasksCompleted: bigint;
+    /** Raw on-chain value. NOTE: despite the name, the contract returns the
+     *  average rating already scaled ×100 (450 = 4.50), NOT a cumulative sum. */
     totalScore: bigint;
     disputes: bigint;
+    /** 0–5 average rating. */
     avgScore: number;
 }
 export declare class BlindReputationClient {

package/dist/chain/BlindReputationClient.js

@@ -12,9 +12,11 @@ export class BlindReputationClient {
         try {
             const raw = (await this.contract.getReputation(worker));
             const tasksCompleted = BigInt(raw[0]);
+            // raw[1] is already avgScore × 100 (contract getReputation returns the
+            // average scaled ×100, "450 = 4.50") — divide by 100 only, NOT by tasks.
             const totalScore = BigInt(raw[1]);
             const disputes = BigInt(raw[2]);
-            const avgScore = tasksCompleted === 0n ? 0 : Number(totalScore) / Number(tasksCompleted);
+            const avgScore = Number(totalScore) / 100;
             return { tasksCompleted, totalScore, disputes, avgScore };
         }
         catch (err) {

package/dist/chain/ChainClient.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import type { Signer as SdkSigner } from '../signer/index.js';
-import type { Network } from '../network/index.js';
+import type { EVMNetwork } from './domain-types.js';
+import type { Network } from './domain-types.js';
 import { BlindEscrowClient } from './BlindEscrowClient.js';
 import { BlindReputationClient } from './BlindReputationClient.js';
 import { TaskRegistryClient } from './TaskRegistryClient.js';
@@ -15,12 +16,14 @@ export interface ChainClientOptions {
  * ethers runner. Reads use provider (or signer's provider); writes require a
  * signer. To keep the SDK's Signer abstraction decoupled from ethers at the
  * call sites, we unwrap an EthersSigner's inner ethers.Signer lazily here.
+ *
+ * Only supports EVM networks.
  */
 export declare class ChainClient {
     readonly escrow: BlindEscrowClient;
     readonly registry: TaskRegistryClient;
     readonly reputation: BlindReputationClient;
     readonly provider: ethers.Provider;
-    readonly network: Network;
+    readonly network: EVMNetwork;
     constructor(opts: ChainClientOptions);
 }

package/dist/chain/ChainClient.js

@@ -7,6 +7,8 @@ import { TaskRegistryClient } from './TaskRegistryClient.js';
  * ethers runner. Reads use provider (or signer's provider); writes require a
  * signer. To keep the SDK's Signer abstraction decoupled from ethers at the
  * call sites, we unwrap an EthersSigner's inner ethers.Signer lazily here.
+ *
+ * Only supports EVM networks.
  */
 export class ChainClient {
     escrow;
@@ -15,6 +17,9 @@ export class ChainClient {
     provider;
     network;
     constructor(opts) {
+        if (opts.network.chainType !== 'evm') {
+            throw new Error(`ChainClient requires an EVM network, got ${opts.network.chainType}`);
+        }
         this.network = opts.network;
         const provider = opts.provider ??
             (opts.signer && unwrapEthersSigner(opts.signer)?.provider) ??

package/dist/chain/IBlindMarketChain.d.ts

@@ -0,0 +1,74 @@
+import type { CreateTaskParams, DomainReputation, DomainTask, DomainTaskMeta, DomainTxReceipt, Network } from './domain-types.js';
+/**
+ * Chain-agnostic interface for BlindMarket on-chain operations.
+ *
+ * Every supported blockchain provides an adapter that implements this interface,
+ * translating domain operations into chain-native contract calls. Consumers
+ * (backend, agents, CLI) work against this interface and never need to know
+ * which chain they're talking to.
+ */
+export interface IBlindMarketChain {
+    /** The resolved network config this adapter is connected to. */
+    readonly network: Network;
+    /** The address of the active signer. */
+    getAddress(): Promise<string>;
+    /**
+     * Create a new task with escrowed funds.
+     * Returns the assigned task ID and receipt.
+     */
+    createTask(params: CreateTaskParams): Promise<{
+        taskId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    /** Assign a worker to a funded task. Caller must be the task agent. */
+    assignWorker(taskId: bigint, worker: string): Promise<DomainTxReceipt>;
+    /** Submit an evidence hash for an assigned task. Caller must be the worker. */
+    submitEvidence(taskId: bigint, evidenceHash: string): Promise<DomainTxReceipt>;
+    /** Complete verification for a submitted task (called by the verifier). */
+    completeVerification(taskId: bigint, passed: boolean): Promise<DomainTxReceipt>;
+    /** Cancel a funded/assigned task and return escrow to the agent. */
+    cancelTask(taskId: bigint): Promise<DomainTxReceipt>;
+    /** Claim escrow after timeout expiry (agent-side). */
+    claimTimeout(taskId: bigint): Promise<DomainTxReceipt>;
+    /** Raise a dispute on a task. */
+    raiseDispute(taskId: bigint): Promise<DomainTxReceipt>;
+    /** Resolve a dispute (admin only). */
+    resolveDispute(taskId: bigint, workerFavored: boolean): Promise<DomainTxReceipt>;
+    /** Read full on-chain task state. */
+    getTask(taskId: bigint): Promise<DomainTask>;
+    /** Check whether a task's deadline has passed. */
+    isTaskExpired(taskId: bigint): Promise<boolean>;
+    /** Publish task metadata to the on-chain discovery index. */
+    publishTask(taskId: bigint, meta: Omit<DomainTaskMeta, 'taskId'> & {
+        taskId?: bigint;
+    }): Promise<DomainTxReceipt>;
+    /** Remove a task from the discovery index (called on assignment/completion). */
+    closeTask(taskId: bigint): Promise<DomainTxReceipt>;
+    /** Get a page of open task IDs from the discovery index. */
+    getOpenTasks(offset: bigint, limit: bigint): Promise<DomainTaskMeta[]>;
+    /** Count of currently open tasks. */
+    openTaskCount(): Promise<bigint>;
+    /** Total tasks ever published. */
+    totalTasks(): Promise<bigint>;
+    /** Rate a worker after task completion (score 1-5). */
+    rateWorker(worker: string, score: number, taskId: bigint): Promise<DomainTxReceipt>;
+    /** Record a dispute against a worker. */
+    recordDispute(worker: string, taskId: bigint): Promise<DomainTxReceipt>;
+    /** Fetch on-chain reputation for a worker. */
+    getReputation(worker: string): Promise<DomainReputation>;
+    /** Check if a worker has already been rated for a given task. */
+    hasBeenRated(worker: string, taskId: bigint): Promise<boolean>;
+    /** Mint an agent identity token. Returns the token ID and receipt. */
+    mintAgent(params: {
+        to: string;
+        encryptedURI: string;
+        metadataHash: string;
+    }): Promise<{
+        tokenId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    /** Read the encrypted metadata URI for an agent token. */
+    getEncryptedURI(tokenId: bigint): Promise<string>;
+    /** Get native balance for an address. */
+    getBalance(address: string): Promise<bigint>;
+}

package/dist/chain/IBlindMarketChain.js

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

package/dist/chain/TaskRegistryClient.d.ts

@@ -2,11 +2,12 @@ import { ethers } from 'ethers';
 import type { Address, TaskId, TxReceiptLike } from '../types.js';
 export interface OpenTaskMeta {
     taskId: TaskId;
-    token: Address;
+    agent: Address;
     category: string;
     locationZone: string;
     reward: bigint;
     createdAt: Date;
+    isOpen: boolean;
 }
 export declare class TaskRegistryClient {
     readonly contract: ethers.Contract;

package/dist/chain/TaskRegistryClient.js

@@ -10,14 +10,19 @@ export class TaskRegistryClient {
     }
     async getTaskMeta(taskId) {
         try {
+            // Live TaskMeta struct order: taskId, agent, category, locationZone,
+            // reward, createdAt, isOpen (7 fields). The old decode was off by one
+            // field from the start (token/agent/category/locationZone), so BigInt() on
+            // the locationZone string threw on every real task.
             const raw = (await this.contract.getTaskMeta(taskId));
             return {
                 taskId,
-                token: raw[0],
-                category: raw[1],
-                locationZone: raw[2],
-                reward: BigInt(raw[3]),
-                createdAt: new Date(Number(raw[4]) * 1000),
+                agent: raw[1],
+                category: raw[2],
+                locationZone: raw[3],
+                reward: BigInt(raw[4]),
+                createdAt: new Date(Number(raw[5]) * 1000),
+                isOpen: Boolean(raw[6]),
             };
         }
         catch (err) {
@@ -26,8 +31,11 @@ export class TaskRegistryClient {
     }
     async getOpenTasks(offset, limit) {
         try {
-            const ids = (await this.contract.getOpenTasks(offset, limit));
-            return ids.map((x) => BigInt(x));
+            // getOpenTasks returns TaskMeta[] structs, NOT raw ids — extract .taskId
+            // (field 0) from each. BigInt()-ing the whole struct tuple threw on any
+            // non-empty page.
+            const metas = (await this.contract.getOpenTasks(offset, limit));
+            return metas.map((m) => BigInt((m?.taskId ?? m?.[0])));
         }
         catch (err) {
             throw wrapChainError(err, 'getOpenTasks');

package/dist/chain/createChainAdapter.d.ts

@@ -0,0 +1,25 @@
+import type { IBlindMarketChain } from './IBlindMarketChain.js';
+import type { Network, NetworkName as PresetName } from '../network/index.js';
+import type { EthersSigner } from '../signer/EthersSigner.js';
+/**
+ * Options for creating a chain adapter via the factory.
+ *
+ * The factory chooses the correct adapter based on `network.chainType`.
+ */
+export interface CreateChainAdapterOptions {
+    network: Network | PresetName;
+    signer?: EthersSigner;
+}
+/**
+ * Factory: create the correct IBlindMarketChain adapter for the given network.
+ *
+ * @example
+ * ```ts
+ * // EVM (0G)
+ * const chain = createChainAdapter({
+ *   network: 'og-testnet',
+ *   signer: new PrivateKeySigner(privkey, provider),
+ * });
+ * ```
+ */
+export declare function createChainAdapter(opts: CreateChainAdapterOptions): IBlindMarketChain;

package/dist/chain/createChainAdapter.js

@@ -0,0 +1,24 @@
+import { EVMChainAdapter } from './evm/EVMChainAdapter.js';
+import { resolveNetwork } from '../network/resolve.js';
+/**
+ * Factory: create the correct IBlindMarketChain adapter for the given network.
+ *
+ * @example
+ * ```ts
+ * // EVM (0G)
+ * const chain = createChainAdapter({
+ *   network: 'og-testnet',
+ *   signer: new PrivateKeySigner(privkey, provider),
+ * });
+ * ```
+ */
+export function createChainAdapter(opts) {
+    const network = resolveNetwork(opts.network);
+    if (network.chainType !== 'evm') {
+        throw new Error(`Unsupported chain type: ${network.chainType}. Only EVM (0G) is supported.`);
+    }
+    return new EVMChainAdapter({
+        network,
+        signer: opts.signer,
+    });
+}

package/dist/chain/domain-types.d.ts

@@ -0,0 +1,77 @@
+import type { Address, Hex, TaskId, TaskStatus } from '../types.js';
+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/dist/chain/domain-types.js

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

package/dist/chain/evm/EVMChainAdapter.d.ts

@@ -0,0 +1,56 @@
+import { ethers } from 'ethers';
+import { type ChainClientOptions } from '../ChainClient.js';
+import type { CreateTaskParams, DomainReputation, DomainTask, DomainTaskMeta, DomainTxReceipt, EVMNetwork } from '../domain-types.js';
+import type { IBlindMarketChain } from '../IBlindMarketChain.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 declare class EVMChainAdapter implements IBlindMarketChain {
+    readonly network: EVMNetwork;
+    private client;
+    private signer;
+    constructor(opts: ChainClientOptions);
+    getAddress(): Promise<string>;
+    createTask(params: CreateTaskParams): Promise<{
+        taskId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    assignWorker(taskId: bigint, worker: string): Promise<DomainTxReceipt>;
+    submitEvidence(taskId: bigint, evidenceHash: string): Promise<DomainTxReceipt>;
+    completeVerification(taskId: bigint, passed: boolean): Promise<DomainTxReceipt>;
+    cancelTask(taskId: bigint): Promise<DomainTxReceipt>;
+    claimTimeout(taskId: bigint): Promise<DomainTxReceipt>;
+    raiseDispute(taskId: bigint): Promise<DomainTxReceipt>;
+    resolveDispute(taskId: bigint, workerFavored: boolean): Promise<DomainTxReceipt>;
+    getTask(taskId: bigint): Promise<DomainTask>;
+    isTaskExpired(taskId: bigint): Promise<boolean>;
+    publishTask(taskId: bigint, _meta: Omit<DomainTaskMeta, 'taskId'> & {
+        taskId?: bigint;
+    }): Promise<DomainTxReceipt>;
+    closeTask(taskId: bigint): Promise<DomainTxReceipt>;
+    getOpenTasks(offset: bigint, limit: bigint): Promise<DomainTaskMeta[]>;
+    openTaskCount(): Promise<bigint>;
+    totalTasks(): Promise<bigint>;
+    rateWorker(worker: string, score: number, taskId: bigint): Promise<DomainTxReceipt>;
+    recordDispute(worker: string, taskId: bigint): Promise<DomainTxReceipt>;
+    getReputation(worker: string): Promise<DomainReputation>;
+    hasBeenRated(worker: string, taskId: bigint): Promise<boolean>;
+    mintAgent(params: {
+        to: string;
+        encryptedURI: string;
+        metadataHash: string;
+    }): Promise<{
+        tokenId: bigint;
+        receipt: DomainTxReceipt;
+    }>;
+    getEncryptedURI(_tokenId: bigint): Promise<string>;
+    getBalance(address: string): Promise<bigint>;
+    /** Get the underlying ethers Provider for raw queries. */
+    getProvider(): ethers.Provider;
+    /** Get the underlying ethers Signer (if configured). */
+    getEthersSigner(): ethers.Signer | undefined;
+}

package/dist/chain/evm/EVMChainAdapter.js

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

package/dist/chain/evm/index.d.ts

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

package/dist/chain/evm/index.js

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

package/dist/chain/index.d.ts

@@ -4,3 +4,7 @@ export * from './BlindEscrowClient.js';
 export * from './TaskRegistryClient.js';
 export * from './BlindReputationClient.js';
 export * from './ChainClient.js';
+export * from './IBlindMarketChain.js';
+export * from './domain-types.js';
+export * from './createChainAdapter.js';
+export * from './evm/index.js';

package/dist/chain/index.js

@@ -4,3 +4,8 @@ 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';