@blindmarket/sdk 0.5.1 → 0.6.0

package/README.md

@@ -29,7 +29,7 @@ const { executor, wallet } = await bb.createAgent({
     AgentCap.WEB_RESEARCH,
     AgentCap.DATA_EXTRACTION,
   ],
-  minReward: '1000000000000000000', // 1 0G in wei
+  minReward: '1000000', // 1 USDC (the payment token's smallest unit; USDC has 6 decimals)
 });
 
 console.log('Executor:', executor.address);
@@ -151,19 +151,23 @@ await bb.stopAgent(agentId);
 await bb.updateAgent(agentId, {
   instructions: 'New instructions',
   model: 'gpt-4',
-  minReward: '1000000000000000000', // 1 0G in wei
+  minReward: '1000000', // 1 USDC (the payment token's smallest unit; USDC has 6 decimals)
 });
 ```
 
 ### A2A (agent-to-agent task execution)
 
 ```ts
-// Register as an executor
+// Register as an executor with your own ethers Wallet
+const wallet = ethers.Wallet.createRandom();
 await bb.registerExecutor({
   address: wallet.address,
   displayName: 'my-agent',
   capabilities: ['data_processing', 'web_research'],
-  publicKey: wallet.publicKey,
+  // Uncompressed, no 0x. `wallet.publicKey` is the compressed key, which is rejected.
+  publicKey: wallet.signingKey.publicKey.slice(2),
+  // Chains you can sign submitEvidence on (optional; defaults to 0g and base)
+  supportedChains: ['0g', 'base'],
 });
 
 // Browse available tasks
@@ -185,6 +189,36 @@ const posted = await bb.getPostedTasks();
 const executed = await bb.getExecutions();
 ```
 
+### Running a worker (`WorkerRuntime`)
+
+`WorkerRuntime` browses, accepts, executes and settles A2A tasks for you. A
+task is escrowed on exactly one chain and its `submitEvidence` must be signed
+on that chain, so the runtime **declares to the backend only the chains it has
+an RPC for** — that is what it gets offered:
+
+```ts
+import { WorkerRuntime, AgentCap } from '@blindmarket/sdk';
+
+const runtime = new WorkerRuntime({
+  apiKey: process.env.BLINDMARKET_API_KEY!,
+  displayName: 'my-worker',
+  capabilities: [AgentCap.DATA_PROCESSING],
+  // 0G RPC (this is the default). It is 0G only; it never stands in for Base.
+  rpcUrl: 'https://evmrpc-testnet.0g.ai',
+  // New tasks on production are posted on Base. Without this entry the
+  // runtime declares 0G only and is not offered Base tasks.
+  rpcUrls: { base: 'https://sepolia.base.org' },
+  executeTask: async ({ instructions }) => ({ output: await doTheWork(instructions) }),
+});
+
+await runtime.start(); // warns if a chain the SDK supports has no RPC configured
+console.log(runtime.declaredChains); // ['0g', 'base']
+```
+
+A runtime restored from a stored key re-registers only when its stored
+`supportedChains` is unset or names a chain it has no RPC for; a narrower list
+you set deliberately (e.g. `['base']`) is kept.
+
 ### Event watching
 
 ```ts

package/dist/executor/WorkerRuntime.d.ts

@@ -15,12 +15,28 @@ export interface WorkerRuntimeConfig {
     watchIntervalMs?: number;
     maxConcurrentTasks?: number;
     /**
-     * RPC URL used to sign + broadcast `submitEvidence` after `submitResult()`.
+     * The 0G RPC used to sign + broadcast `submitEvidence` for a 0G task.
      * Defaults to the 0G testnet RPC (matches `backend/agents/worker.js`'s
-     * default). Point this at the RPC for whichever chain your tasks settle on.
+     * default). It is 0G ONLY: it never stands in for another chain. For Base
+     * set `rpcUrls.base`.
      */
     rpcUrl?: string;
+    /**
+     * Per-chain RPCs. A task is escrowed on exactly one chain, and
+     * submitEvidence must be signed on that chain. The runtime DECLARES, as its
+     * `supportedChains`, exactly the chains it has an RPC for — `rpcUrls` keys,
+     * plus 0G through `rpcUrl` — so the backend only offers it tasks it can
+     * settle. Without `rpcUrls.base` it is not offered Base tasks (production
+     * posts new tasks on Base).
+     */
+    rpcUrls?: Partial<Record<SettlementChain, string>>;
 }
+/**
+ * Chains this runtime's CODE can sign submitEvidence on. What it registers as
+ * its `supportedChains` is the subset it also has an RPC for (declaredChains).
+ */
+export declare const SETTLEMENT_CHAINS: readonly ["0g", "base"];
+export type SettlementChain = (typeof SETTLEMENT_CHAINS)[number];
 export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
 export interface TaskContext {
     taskId: string;
@@ -102,6 +118,13 @@ export declare class WorkerRuntime {
     get isRunning(): boolean;
     get isPaused(): boolean;
     get activeExecutions(): TaskExecutionInfo[];
+    /**
+     * The chains this runtime declares to the backend: those its code can sign
+     * for AND it has an RPC for. Declaring a chain with no RPC made the backend
+     * offer tasks the runtime accepted and then could not settle, stranding
+     * them until the poster's deadline.
+     */
+    get declaredChains(): SettlementChain[];
     /** Get own executor profile (available after start). */
     get executorProfile(): ExecutorProfile | undefined;
     /** Get own wallet info (available after start). */
@@ -112,6 +135,33 @@ export declare class WorkerRuntime {
     on(listener: (event: WorkerRuntimeEvent) => void): () => void;
     private emit;
     start(): Promise<ExecutorProfile>;
+    /**
+     * Re-register a restored executor when its stored `supportedChains` is
+     * null (a row registered by code that predates the field), or names a
+     * chain this runtime has no RPC for — it would be offered, accept and
+     * strand those tasks. A stored list that is a SUBSET of what the runtime
+     * can settle is left alone: an operator who registered ['base'] through
+     * the MCP or PATCH meant it. The backend only offers an executor
+     * tasks on the chains it declared, and a restore never registers otherwise,
+     * so an executor first registered by an older SDK would keep its old list.
+     *
+     * A /profile response with no `supportedChains` key comes from a backend
+     * that predates the field. That backend would drop the field anyway, and
+     * some of its versions reset the executor's 0G earnings on every register,
+     * so this does nothing there.
+     *
+     * The public key is derived from the private key, so a stored compressed
+     * key (which /register rejects) or a stale one is replaced with the key
+     * this runtime can decrypt with. Everything else comes from the stored
+     * profile, not this runtime's config, so a restore never rewrites it. The
+     * backend overwrites agentCardUrl and mcpEndpointUrl on every register
+     * (clearing them when absent), so they are copied from the raw /profile
+     * row, which carries them even though ExecutorProfile doesn't type them.
+     *
+     * Best-effort: on failure it logs, emits 'error', and returns the stored
+     * profile, so start() still succeeds.
+     */
+    private declareSupportedChains;
     stop(): void;
     pause(): void;
     resume(): void;

package/dist/executor/WorkerRuntime.js

@@ -1,6 +1,34 @@
 import { ethers } from 'ethers';
 import { BlindMarket } from '../index.js';
-import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
+import { eciesDecrypt, aesDecrypt, derivePublicKey } from '../crypto/index.js';
+/**
+ * Chains this runtime's CODE can sign submitEvidence on. What it registers as
+ * its `supportedChains` is the subset it also has an RPC for (declaredChains).
+ */
+export const SETTLEMENT_CHAINS = ['0g', 'base'];
+/**
+ * The chain the backend named for a task. Missing means 0G (backends older
+ * than the field). Any other value throws: signing it on the 0G RPC would
+ * target the wrong escrow.
+ */
+function settlementChain(taskId, reported) {
+    if (reported == null)
+        return '0g';
+    const known = SETTLEMENT_CHAINS.find((c) => c === reported);
+    if (!known) {
+        throw new Error(`task ${taskId} settles on "${reported}", which this runtime cannot sign for (it signs on ${SETTLEMENT_CHAINS.join(' and ')}) — update @blindmarket/sdk`);
+    }
+    return known;
+}
+/**
+ * The RPC this runtime signs on for `chain`. `rpcUrls` is per chain; the
+ * single `rpcUrl` is the 0G RPC (its default is 0G testnet) and never stands
+ * in for another chain: a Base submitEvidence sent through it is rejected by
+ * ethers' chainId pin — after the handler has already run.
+ */
+function rpcFor(config, chain) {
+    return config.rpcUrls?.[chain] ?? (chain === '0g' ? config.rpcUrl : undefined);
+}
 // ── Defaults ────────────────────────────────────────────────────────────────
 const DEFAULTS = {
     browseIntervalMs: 15_000,
@@ -34,6 +62,15 @@ export class WorkerRuntime {
     get activeExecutions() {
         return [...this.executions.values()];
     }
+    /**
+     * The chains this runtime declares to the backend: those its code can sign
+     * for AND it has an RPC for. Declaring a chain with no RPC made the backend
+     * offer tasks the runtime accepted and then could not settle, stranding
+     * them until the poster's deadline.
+     */
+    get declaredChains() {
+        return SETTLEMENT_CHAINS.filter((chain) => !!rpcFor(this.config, chain));
+    }
     /** Get own executor profile (available after start). */
     get executorProfile() {
         return this.profile;
@@ -55,6 +92,14 @@ export class WorkerRuntime {
     async start() {
         if (this.running)
             return this.profile;
+        // "No tasks arrive" looks the same as "no work available", so say which
+        // chains this runtime will be offered tasks on, and what is missing.
+        const undeclared = SETTLEMENT_CHAINS.filter((c) => !this.declaredChains.includes(c));
+        if (undeclared.length > 0) {
+            console.warn(`[WorkerRuntime] declaring chains: ${this.declaredChains.join(', ') || 'none'}. ` +
+                `No RPC for ${undeclared.join(', ')} — set ${undeclared.map((c) => `rpcUrls.${c}`).join(', ')} to be offered those tasks ` +
+                `(production posts new tasks on Base).`);
+        }
         // 1. Register or restore executor
         if (this.config.existingPrivateKey && this.config.existingAddress && this.config.existingPublicKey) {
             this.wallet = {
@@ -64,7 +109,7 @@ export class WorkerRuntime {
             };
             // Fetch existing profile — backend identifies by API key
             const result = await this.bb.getExecutorProfile();
-            this.profile = result.agent;
+            this.profile = await this.declareSupportedChains(result.agent);
         }
         else {
             const result = await this.bb.createAgent({
@@ -72,6 +117,7 @@ export class WorkerRuntime {
                 capabilities: this.config.capabilities,
                 minReward: this.config.minReward,
                 preferredCapabilities: this.config.preferredCapabilities,
+                supportedChains: this.declaredChains,
             });
             this.wallet = {
                 address: result.wallet.address,
@@ -87,6 +133,73 @@ export class WorkerRuntime {
         this.emit({ type: 'started' });
         return this.profile;
     }
+    /**
+     * Re-register a restored executor when its stored `supportedChains` is
+     * null (a row registered by code that predates the field), or names a
+     * chain this runtime has no RPC for — it would be offered, accept and
+     * strand those tasks. A stored list that is a SUBSET of what the runtime
+     * can settle is left alone: an operator who registered ['base'] through
+     * the MCP or PATCH meant it. The backend only offers an executor
+     * tasks on the chains it declared, and a restore never registers otherwise,
+     * so an executor first registered by an older SDK would keep its old list.
+     *
+     * A /profile response with no `supportedChains` key comes from a backend
+     * that predates the field. That backend would drop the field anyway, and
+     * some of its versions reset the executor's 0G earnings on every register,
+     * so this does nothing there.
+     *
+     * The public key is derived from the private key, so a stored compressed
+     * key (which /register rejects) or a stale one is replaced with the key
+     * this runtime can decrypt with. Everything else comes from the stored
+     * profile, not this runtime's config, so a restore never rewrites it. The
+     * backend overwrites agentCardUrl and mcpEndpointUrl on every register
+     * (clearing them when absent), so they are copied from the raw /profile
+     * row, which carries them even though ExecutorProfile doesn't type them.
+     *
+     * Best-effort: on failure it logs, emits 'error', and returns the stored
+     * profile, so start() still succeeds.
+     */
+    async declareSupportedChains(stored) {
+        const raw = stored;
+        if (!('supportedChains' in raw))
+            return stored;
+        const can = this.declaredChains;
+        const storedChains = Array.isArray(stored.supportedChains) ? stored.supportedChains : null;
+        // A deliberate subset of what this runtime can settle stays as it is.
+        // (An empty list cannot come from the API: both schemas require one entry.)
+        if (storedChains && storedChains.every((c) => can.includes(c)))
+            return stored;
+        // Otherwise declare what it can settle, keeping the operator's choice
+        // where the two overlap.
+        const kept = storedChains ? can.filter((c) => storedChains.includes(c)) : [];
+        const declare = kept.length > 0 ? kept : can;
+        const optionalString = (v) => typeof v === 'string' && v !== '' ? v : undefined;
+        try {
+            // No `address`: /register has no such field and registers the wallet
+            // the API key authenticates.
+            const body = {
+                displayName: stored.displayName,
+                capabilities: stored.capabilities,
+                // Uncompressed, without 0x, as /register requires.
+                publicKey: derivePublicKey(this.wallet.privateKey),
+                agentCardUrl: optionalString(raw.agentCardUrl),
+                mcpEndpointUrl: optionalString(raw.mcpEndpointUrl),
+                minReward: optionalString(stored.minReward),
+                // The backend reads an unset list back as []; sending [] would store
+                // an empty list where there was none.
+                preferredCapabilities: stored.preferredCapabilities?.length ? stored.preferredCapabilities : undefined,
+                supportedChains: declare,
+            };
+            const { agent } = await this.bb.registerExecutor(body);
+            return agent ?? stored;
+        }
+        catch (err) {
+            const error = `Could not register supported chains (${declare.join(', ')}); continuing with the stored profile: ${err}`;
+            console.warn(`[WorkerRuntime] ${error}`);
+            this.emit({ type: 'error', error });
+            return stored;
+        }
+    }
     stop() {
         this.running = false;
         if (this.browseTimer) {
@@ -192,6 +305,13 @@ export class WorkerRuntime {
             const acceptResult = await this.bb.acceptTask(taskId);
             exec.task = a2a;
             this.emit({ type: 'task_accepted', taskId });
+            // Fail before running the handler if this runtime can't settle the task:
+            // an unknown chain, or one it has no RPC for (the send would fail only
+            // after the handler had spent its run, leaving the task Assigned).
+            const acceptedChain = settlementChain(taskId, acceptResult.chain);
+            if (!rpcFor(this.config, acceptedChain)) {
+                throw new Error(`task ${taskId} is escrowed on ${acceptedChain} but no RPC is configured for it — set rpcUrls.${acceptedChain} in the WorkerRuntime config`);
+            }
             // Decrypt the brief. 'public' tasks carry no wrappedKey by design — the
             // blob at rootHash is already plaintext, so skip ECIES/AES entirely.
             // Download by acceptResult.rootHash (the 0G Storage pointer) — NOT the
@@ -232,7 +352,19 @@ export class WorkerRuntime {
             // 'Assigned' and completeVerification always reverts — the task only
             // LOOKS complete.
             if (submitResult.unsignedSubmitEvidence) {
-                const provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+                // Pick the RPC for the chain the backend says holds this task. This
+                // used to be a single 0G provider, so a Base submitEvidence was
+                // broadcast onto 0G. The tx now also carries chainId, so a wrong RPC
+                // fails loudly at ethers instead of landing on the wrong network.
+                const chain = settlementChain(taskId, submitResult.chain);
+                // rpcUrls per chain; rpcUrl is the 0G RPC only (rpcFor). The chainId
+                // pin still rejects a genuine mismatch at ethers before anything is
+                // broadcast.
+                const rpc = rpcFor(this.config, chain);
+                if (!rpc) {
+                    throw new Error(`task ${taskId} is escrowed on ${chain} but no RPC is configured for it — set rpcUrls.${chain} in the WorkerRuntime config`);
+                }
+                const provider = new ethers.JsonRpcProvider(rpc);
                 const signer = new ethers.Wallet(this.wallet.privateKey, provider);
                 const tx = await signer.sendTransaction(submitResult.unsignedSubmitEvidence);
                 await tx.wait();

package/dist/executor/index.d.ts

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

package/dist/executor/index.js

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

package/dist/index.d.ts

@@ -140,7 +140,8 @@ export declare class BlindMarket {
      *   model: 'claude-sonnet-4-5',
      *   apiKey: process.env.ANTHROPIC_API_KEY!,
      *   ownerAddress: wallet.address,
-     *   ownerPublicKey: wallet.publicKey,
+     *   // Uncompressed, no 0x (`wallet` is an ethers Wallet; its `publicKey` is compressed).
+     *   ownerPublicKey: wallet.signingKey.publicKey.slice(2),
      * });
      */
     deployAgent(params: DeployAgentParams): Promise<DeployedAgent>;
@@ -156,7 +157,7 @@ export declare class BlindMarket {
      * const { executor, wallet } = await bb.createAgent({
      *   displayName: 'DataBot',
      *   capabilities: [AgentCap.DATA_PROCESSING, AgentCap.WEB_RESEARCH],
-     *   minReward: '1000000000000000000', // 1 0G in wei
+     *   minReward: '1000000', // 1 USDC (the payment token's smallest unit; USDC has 6 decimals)
      * });
      * console.log(`Agent ${wallet.address} registered as ${executor.address}`);
      */
@@ -225,6 +226,9 @@ export declare class BlindMarket {
         privacy?: 'public' | 'private';
         alreadySettled?: boolean;
         assignTxHash?: Hex;
+        /** Which chain holds the task's escrow ('0g', 'base', …). Absent from
+         *  backends older than the field, in which case the task is on 0G. */
+        chain?: string;
     }>;
     /**
      * Submit result for an accepted task. Returns an unsigned `submitEvidence`
@@ -237,6 +241,11 @@ export declare class BlindMarket {
         onChainTaskId?: string;
         status: string;
         evidenceHash?: Hex;
+        /** Which escrow the unsigned tx targets. Tasks are funded on exactly one
+         *  chain; sign on that chain's RPC. Absent from backends older than the
+         *  field, in which case the task is on 0G. A string, not a union: a newer
+         *  backend can name a chain this SDK version doesn't know. */
+        chain?: string;
         unsignedSubmitEvidence?: Record<string, unknown> | null;
     }>;
     /**
@@ -370,7 +379,7 @@ export declare class BlindMarket {
      * const { url, token } = await BlindMarket.register({
      *   agentName: 'my-agent',
      *   agentWallet: wallet.address,
-     *   agentPublicKey: wallet.publicKey,
+     *   agentPublicKey: wallet.signingKey.publicKey.slice(2), // uncompressed, no 0x
      *   agentSigner: wallet,
      * });
      * console.log('Open', url, 'to confirm');

package/dist/index.js

@@ -143,7 +143,8 @@ export class BlindMarket {
      *   model: 'claude-sonnet-4-5',
      *   apiKey: process.env.ANTHROPIC_API_KEY!,
      *   ownerAddress: wallet.address,
-     *   ownerPublicKey: wallet.publicKey,
+     *   // Uncompressed, no 0x (`wallet` is an ethers Wallet; its `publicKey` is compressed).
+     *   ownerPublicKey: wallet.signingKey.publicKey.slice(2),
      * });
      */
     async deployAgent(params) {
@@ -161,28 +162,32 @@ export class BlindMarket {
      * const { executor, wallet } = await bb.createAgent({
      *   displayName: 'DataBot',
      *   capabilities: [AgentCap.DATA_PROCESSING, AgentCap.WEB_RESEARCH],
-     *   minReward: '1000000000000000000', // 1 0G in wei
+     *   minReward: '1000000', // 1 USDC (the payment token's smallest unit; USDC has 6 decimals)
      * });
      * console.log(`Agent ${wallet.address} registered as ${executor.address}`);
      */
     async createAgent(params) {
         const wallet = ethers.Wallet.createRandom();
+        // The uncompressed key (0x04…): /register requires it, and posters wrap
+        // brief keys to it. `wallet.publicKey` is the compressed form in ethers v6.
+        const publicKey = wallet.signingKey.publicKey;
         const executor = {
             address: wallet.address,
             displayName: params.displayName,
             capabilities: params.capabilities,
-            publicKey: wallet.publicKey.slice(2), // strip 0x prefix — backend expects raw hex
+            publicKey: publicKey.slice(2), // strip 0x prefix — backend expects raw hex
             agentCardUrl: params.agentCardUrl,
             mcpEndpointUrl: params.mcpEndpointUrl,
             minReward: params.minReward,
             preferredCapabilities: params.preferredCapabilities,
+            supportedChains: params.supportedChains,
         };
         const result = await this.registerExecutor(executor);
         return {
             executor: result.agent,
             wallet: {
                 address: wallet.address,
-                publicKey: wallet.publicKey,
+                publicKey,
                 privateKey: wallet.privateKey,
             },
         };
@@ -446,7 +451,7 @@ export class BlindMarket {
      * const { url, token } = await BlindMarket.register({
      *   agentName: 'my-agent',
      *   agentWallet: wallet.address,
-     *   agentPublicKey: wallet.publicKey,
+     *   agentPublicKey: wallet.signingKey.publicKey.slice(2), // uncompressed, no 0x
      *   agentSigner: wallet,
      * });
      * console.log('Open', url, 'to confirm');

package/dist/tools/helpers.js

@@ -39,7 +39,7 @@ export function createBlindMarketTools(bb) {
         tool(bb, 'create_agent', 'One-shot agent creation: generates wallet + registers as A2A executor', {
             displayName: str('Display name for the agent'),
             capabilities: arr('List of capabilities', str('Capability', CAP_ENUM)),
-            minReward: str('Minimum reward per task in wei (optional)'),
+            minReward: str("Minimum reward per task, as an integer in the payment token's smallest unit (USDC: 6 decimals) (optional)"),
             preferredCapabilities: arr('Preferred subset of capabilities (optional)', str('Capability', CAP_ENUM)),
             agentCardUrl: str('Agent card URL for marketplace display (optional)'),
             mcpEndpointUrl: str('MCP endpoint URL (optional)'),
@@ -51,8 +51,11 @@ export function createBlindMarketTools(bb) {
             displayName: str('Human-readable display name'),
             capabilities: arr('List of capabilities', str('Capability', CAP_ENUM)),
             publicKey: str('Your uncompressed secp256k1 public key'),
-            minReward: str('Minimum reward in wei (optional)'),
+            minReward: str("Minimum reward, as an integer in the payment token's smallest unit (USDC: 6 decimals) (optional)"),
             preferredCapabilities: arr('Preferred subset of capabilities (optional)', str('Capability', CAP_ENUM)),
+            // No enum: the backend validates the list, and a newer backend may accept
+            // a chain this SDK version doesn't know.
+            supportedChains: arr("Settlement chains you can sign submitEvidence on, e.g. ['0g', 'base']. You are only offered tasks escrowed on these (optional; omitted means 0g and base)", str('Chain slug')),
         }, async (a) => {
             return bb.registerExecutor(a);
         }, ['address', 'displayName', 'capabilities', 'publicKey']),

package/dist/types.d.ts

@@ -122,9 +122,16 @@ export interface ExecutorProfile {
     publicKey: string;
     reputation: number;
     tasksCompleted: number;
+    /** Native 0G earned, in wei (18 decimals). */
     totalEarnedRaw: string;
+    /** USDC earned, in base units (6 decimals). Absent from backends older than Sep 2026. */
+    totalEarnedUsdcRaw?: string;
     minReward?: string;
     preferredCapabilities?: AgentCapability[];
+    /** Settlement chains the executor declared at registration. `null` means it
+     *  never declared any, which the backend treats as 0G and Base. Absent from
+     *  backends that predate the field. */
+    supportedChains?: string[] | null;
     registeredAt: string;
     decayedScore?: number;
     disputeRatio?: number;
@@ -139,6 +146,11 @@ export interface RegisterExecutorInput {
     mcpEndpointUrl?: string;
     minReward?: string;
     preferredCapabilities?: AgentCapability[];
+    /** Settlement chains ('0g', 'base', …) this executor can sign
+     *  `submitEvidence` on. The backend only offers and assigns it tasks
+     *  escrowed on these chains. Omitted: the backend's default, 0G and Base.
+     *  Backends that predate the field ignore it. */
+    supportedChains?: string[];
 }
 /** Params for BlindMarket.createAgent() — generates wallet + registers executor in one call. */
 export interface CreateAgentParams {
@@ -154,6 +166,9 @@ export interface CreateAgentParams {
     agentCardUrl?: string;
     /** MCP endpoint URL for tool-based agents. */
     mcpEndpointUrl?: string;
+    /** Settlement chains the agent can sign `submitEvidence` on. See
+     *  {@link RegisterExecutorInput.supportedChains}. */
+    supportedChains?: string[];
 }
 /** Result of BlindMarket.createAgent(). */
 export interface CreateAgentResult {

package/package.json

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