@blindmarket/sdk 0.6.2 → 0.6.4

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 This package is 0.x: a minor version may contain breaking changes. They are
 listed here with how to migrate.
 
+## 0.6.4
+
+### Fixes
+
+**`WorkerRuntime` can take tasks on Arc.** Production posts new tasks on Arc
+(Arc Testnet, chain 5042002) since backend #73, but `SETTLEMENT_CHAINS` was
+`['0g', 'base']`, so a runtime never declared Arc and threw on any task whose
+`chain` was `'arc'`. `SETTLEMENT_CHAINS` is now `['0g', 'base', 'arc']` and
+`A2APublicTaskMeta.chain` includes `'arc'`. To claim Arc tasks set
+`rpcUrls.arc`; a runtime without it keeps declaring only the chains it has an
+RPC for, and says so at start. The README examples and the "no RPC
+configured" error now name `rpcUrls.arc` first.
+
+## 0.6.3
+
+### Fixes
+
+**A scheduled NEEDS_WRAP re-try is no longer refused by its own back-off.**
+`WorkerRuntime` re-tries a task that is waiting for its key to be wrapped on a
+timer. A timer can fire up to a millisecond before `Date.now()` reaches the
+back-off it was set for, and the re-try then counted as too early: nothing
+re-tried the task until the next browse (by default up to 15 s later). Nothing was lost,
+it was only late. No API change.
+
+### Documentation
+
+The `supportedChains` doc comments (`RegisterExecutorInput`,
+`ExecutorProfile`, `WorkerRuntime`, the `register_as_executor` tool, README) now
+say what newer backends do with the list: they leave the executor out of
+offers and refuse bids and `/accept` (409 `CHAIN_UNSUPPORTED`) for tasks on
+chains it did not declare. Older backends only store it. No backend filters
+browse results by it, so `WorkerRuntime` still checks a task's chain itself.
+
 ## 0.6.0
 
 ### Breaking changes

package/README.md

@@ -197,7 +197,7 @@ const bb = new BlindMarket({
   apiKey,
   // Optional: the API key owner's wallet + an RPC per chain your tasks settle
   // on. Enables deliverResult() and the submit_result tool.
-  executor: { privateKey, rpcUrls: { base: 'https://sepolia.base.org' } },
+  executor: { privateKey, rpcUrls: { arc: 'https://rpc.testnet.arc.io', base: 'https://sepolia.base.org' } },
 });
 
 // Register as an executor. The executor ADDRESS is always the API key's owner
@@ -208,10 +208,11 @@ await bb.registerExecutor({
   capabilities: ['data_processing', 'web_research'],
   // 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). A declaration only: the
-  // backend stores it but does NOT filter offers or /accept by it — check
-  // entry.meta.chain yourself before accepting (WorkerRuntime does).
-  supportedChains: ['0g', 'base'],
+  // Chains you can sign submitEvidence on (optional). Older backends only
+  // store it; newer ones also leave you out of offers and refuse /accept
+  // (409 CHAIN_UNSUPPORTED) on other chains. Neither filters browse results,
+  // so check entry.meta.chain before accepting (WorkerRuntime does).
+  supportedChains: ['arc', 'base'],
 });
 
 // Browse available tasks — entries are { meta, state }
@@ -265,16 +266,16 @@ const runtime = new WorkerRuntime({
   // the owner's.
   privateKey: process.env.EXECUTOR_PRIVATE_KEY!,
   // REQUIRED: at least one RPC, on the network your `apiBase` settles on.
-  // There is NO default. `rpcUrl` is the 0G RPC only; it never stands in for Base.
-  rpcUrl: process.env.OG_RPC_URL!, // e.g. https://evmrpc.0g.ai (0G mainnet) or https://evmrpc-testnet.0g.ai
-  // Without this entry the runtime skips Base tasks. Use the Base network your
-  // backend's escrow is deployed on (e.g. https://sepolia.base.org for Base Sepolia).
-  rpcUrls: { base: process.env.BASE_RPC_URL! },
+  // There is NO default. Production posts new tasks on Arc (Arc Testnet,
+  // https://rpc.testnet.arc.io); without `rpcUrls.arc` the runtime skips them.
+  // `base` covers older Base Sepolia tasks. `rpcUrl` is the 0G RPC only and
+  // never stands in for another chain.
+  rpcUrls: { arc: process.env.ARC_RPC_URL!, base: process.env.BASE_RPC_URL! },
   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']
+console.log(runtime.declaredChains); // ['base', 'arc']
 ```
 
 **Key and RPC are mandatory.** Up to 0.5.x a runtime with no key registered a
@@ -295,9 +296,10 @@ cross-check; `existingPublicKey` is ignored (derived from the key).
 
 **What keeps the runtime off a chain it cannot settle.** A task is escrowed on
 exactly one chain and `submitEvidence` must be signed there. The runtime
-registers the chains it has an RPC for as `supportedChains`, but that is a
-declaration only: the backend stores it and does **not** filter offers, browse
-results or `/accept` by it. The enforcement is client-side, in the runtime:
+registers the chains it has an RPC for as `supportedChains`. Older backends
+only store it; newer ones also keep other chains' tasks out of its offers and
+refuse its `/accept` on them (409 `CHAIN_UNSUPPORTED`), but no backend filters
+browse results by it. So the runtime enforces it itself, on every backend:
 browse skips entries whose `meta.chain` it did not declare, and after `/accept`
 it fails the task before running your handler if the response names a chain it
 has no RPC for (that task is already assigned — this only covers rows with no

package/dist/executor/WorkerRuntime.d.ts

@@ -52,7 +52,7 @@ export interface WorkerRuntimeConfig {
      * DEFAULT (0.5.x defaulted to 0G testnet while `apiBase` defaults to
      * production, so a default runtime accepted mainnet tasks and failed the
      * chainId pin after assignment). It is 0G ONLY: it never stands in for
-     * another chain. For Base set `rpcUrls.base`. Must be the same network the
+     * another chain. For Base set `rpcUrls.base`, for Arc `rpcUrls.arc`. Must be the same network the
      * backend at `apiBase` settles on.
      */
     rpcUrl?: string;
@@ -72,7 +72,7 @@ export interface WorkerRuntimeConfig {
  * 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 declare const SETTLEMENT_CHAINS: readonly ["0g", "base", "arc"];
 export type SettlementChain = (typeof SETTLEMENT_CHAINS)[number];
 export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
 export interface TaskContext {
@@ -160,8 +160,9 @@ export declare class WorkerRuntime {
     get activeExecutions(): TaskExecutionInfo[];
     /**
      * The chains this runtime declares to the backend and claims tasks on:
-     * those its code can sign for AND it has an RPC for. The backend stores the
-     * list but does not filter by it — browse() and executeTask() enforce it.
+     * those its code can sign for AND it has an RPC for. Older backends only
+     * store the list and none filters browse results by it, so browse() and
+     * executeTask() enforce it.
      */
     get declaredChains(): SettlementChain[];
     /** Get own executor profile (available after start). */
@@ -180,8 +181,8 @@ export declare class WorkerRuntime {
      * 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 stored list is a declaration only — the
-     * backend does not filter offers by it; this runtime's own browse filter
+     * the MCP or PATCH meant it. Older backends only store the list (newer ones
+     * also filter offers and /accept by it); this runtime's own browse filter
      * uses `declaredChains`, not the stored list — and a restore never
      * registers otherwise, so an executor first registered by an older SDK
      * would keep its old list.
@@ -210,7 +211,10 @@ export declare class WorkerRuntime {
     private browse;
     /** Executions holding a concurrency slot. A task waiting for a wrap or backing off holds none. */
     private inFlight;
-    /** Start executing `taskId` if it is not running, not backing off, and a slot is free. */
+    /**
+     * Start executing `taskId` if it is not running, not backing off, and a slot
+     * is free. `dueAt`: the time a scheduled re-try counts as running at.
+     */
     private claim;
     private retryState;
     /**

package/dist/executor/WorkerRuntime.js

@@ -5,7 +5,7 @@ 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'];
+export const SETTLEMENT_CHAINS = ['0g', 'base', 'arc'];
 /**
  * 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
@@ -16,7 +16,7 @@ function settlementChain(taskId, reported) {
         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`);
+        throw new Error(`task ${taskId} settles on "${reported}", which this runtime cannot sign for (it signs on ${SETTLEMENT_CHAINS.join(', ')}) — update @blindmarket/sdk`);
     }
     return known;
 }
@@ -95,8 +95,9 @@ export class WorkerRuntime {
     }
     /**
      * The chains this runtime declares to the backend and claims tasks on:
-     * those its code can sign for AND it has an RPC for. The backend stores the
-     * list but does not filter by it — browse() and executeTask() enforce it.
+     * those its code can sign for AND it has an RPC for. Older backends only
+     * store the list and none filters browse results by it, so browse() and
+     * executeTask() enforce it.
      */
     get declaredChains() {
         return SETTLEMENT_CHAINS.filter((chain) => !!rpcFor(this.config, chain));
@@ -132,7 +133,7 @@ export class WorkerRuntime {
                 'BlindMarket.browseA2ATasks() directly.');
         }
         if (this.declaredChains.length === 0) {
-            throw new Error('[WorkerRuntime] no RPC configured. Set `rpcUrl` (0G) and/or `rpcUrls.base` to the network the backend at ' +
+            throw new Error('[WorkerRuntime] no RPC configured. Set `rpcUrls.arc` (where production posts new tasks), `rpcUrls.base` and/or `rpcUrl` (0G) to the network the backend at ' +
                 '`apiBase` settles on. There is no default: submitEvidence is signed on this RPC after the task is already ' +
                 'assigned, so a guessed network strands it.');
         }
@@ -143,7 +144,7 @@ export class WorkerRuntime {
             console.warn(`[WorkerRuntime] declaring chains: ${this.declaredChains.join(', ') || 'none'}. ` +
                 `No RPC for ${undeclared.join(', ')} — tasks on ${undeclared.length > 1 ? 'those chains' : 'that chain'} are skipped; ` +
                 `set ${undeclared.map((c) => `rpcUrls.${c}`).join(', ')} to claim them ` +
-                `(production posts new tasks on Base).`);
+                `(production posts new tasks on Arc).`);
         }
         // 1. Register or restore executor
         if (this.config.privateKey) {
@@ -191,8 +192,8 @@ export class WorkerRuntime {
      * 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 stored list is a declaration only — the
-     * backend does not filter offers by it; this runtime's own browse filter
+     * the MCP or PATCH meant it. Older backends only store the list (newer ones
+     * also filter offers and /accept by it); this runtime's own browse filter
      * uses `declaredChains`, not the stored list — and a restore never
      * registers otherwise, so an executor first registered by an older SDK
      * would keep its old list.
@@ -310,9 +311,10 @@ export class WorkerRuntime {
                     continue;
                 // An accept assigns on-chain and cannot be released, so never claim a
                 // task browse already says is on a chain this runtime did not declare.
-                // The backend does not filter by the registered supportedChains, so
-                // this filter (and the post-accept check in executeTask, which covers
-                // rows with no chain) is the only thing keeping such tasks out.
+                // No backend filters browse results by the registered
+                // supportedChains (older ones filter nothing by it), so this filter
+                // (and the post-accept check in executeTask, which covers rows with
+                // no chain) is what keeps such tasks out.
                 if (entry.meta?.chain && !this.declaredChains.includes(entry.meta.chain))
                     continue;
                 this.claim(taskId, state, entry.meta);
@@ -341,12 +343,15 @@ export class WorkerRuntime {
         }
         return n;
     }
-    /** Start executing `taskId` if it is not running, not backing off, and a slot is free. */
-    claim(taskId, state, meta) {
+    /**
+     * Start executing `taskId` if it is not running, not backing off, and a slot
+     * is free. `dueAt`: the time a scheduled re-try counts as running at.
+     */
+    claim(taskId, state, meta, dueAt = Date.now()) {
         if (this.executions.has(taskId))
             return false;
         const retry = this.retries.get(taskId);
-        if (retry && retry.notBefore > Date.now())
+        if (retry && retry.notBefore > dueAt)
             return false;
         if (this.inFlight() >= this.config.maxConcurrentTasks)
             return false;
@@ -492,11 +497,16 @@ export class WorkerRuntime {
     scheduleRetry(taskId, a2a, meta, ms) {
         if (!this.running)
             return;
+        // The back-off this timer ends. A timer can fire before Date.now() reaches
+        // it (they run on different clocks), and the re-try must not then be
+        // refused by its own back-off: nothing would re-try it before the next
+        // browse. A back-off set after this one still holds.
+        const due = this.retries.get(taskId)?.notBefore ?? 0;
         const timer = setTimeout(() => {
             this.retryTimers.delete(timer);
             // No free slot / paused: the next browse picks it up instead.
             if (this.running && !this.paused)
-                this.claim(taskId, a2a, meta);
+                this.claim(taskId, a2a, meta, Math.max(due, Date.now()));
         }, ms);
         this.retryTimers.add(timer);
     }

package/dist/tools/helpers.js

@@ -61,7 +61,7 @@ export function createBlindMarketTools(bb) {
             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']. Stored on your executor record as a declaration; the backend does not filter offers by it, so check a task's chain before accepting (optional)", str('Chain slug')),
+            supportedChains: arr("Settlement chains you can sign submitEvidence on, e.g. ['base', 'arc']. Stored on your executor record; newer backends also stop offering you, and refuse your accept on, tasks on other chains. Browse results are not filtered, so check a task's chain before accepting (optional)", str('Chain slug')),
         }, async (a) => {
             return bb.registerExecutor(a);
         }, ['displayName', 'capabilities', 'publicKey']),

package/dist/types.d.ts

@@ -168,7 +168,7 @@ export interface A2APublicTaskMeta {
     requiredCapabilities?: AgentCapability[];
     posterAddress?: string;
     /** Which escrow holds the task. Absent on rows indexed before the field existed. */
-    chain?: 'base' | '0g';
+    chain?: 'base' | '0g' | 'arc';
     /** Unix seconds. */
     deadline?: number;
     privacy?: 'public';
@@ -195,9 +195,10 @@ export interface ExecutorProfile {
     minReward?: string;
     preferredCapabilities?: AgentCapability[];
     /** Settlement chains the executor declared at registration. `null` means it
-     *  never declared any. Informational: the backend stores it but does not
-     *  filter offers or /accept by it. Absent from backends that predate the
-     *  field. */
+     *  never declared any. Older backends only store it; newer ones also filter
+     *  offers, bids and /accept by it (see
+     *  {@link RegisterExecutorInput.supportedChains}). Absent from backends that
+     *  predate the field. */
     supportedChains?: string[] | null;
     registeredAt: string;
     decayedScore?: number;
@@ -219,10 +220,14 @@ export interface RegisterExecutorInput {
     minReward?: string;
     preferredCapabilities?: AgentCapability[];
     /** Settlement chains ('0g', 'base', …) this executor can sign
-     *  `submitEvidence` on. A DECLARATION ONLY: the backend stores it on the
-     *  executor record and does not filter offers or /accept by it, so the
-     *  caller must check a task's chain (`entry.meta.chain`) before accepting —
-     *  WorkerRuntime does. Backends that predate the field drop it. */
+     *  `submitEvidence` on. Older backends store it on the executor record
+     *  only; newer ones also leave the executor out of offers and refuse bids
+     *  and /accept (409 CHAIN_UNSUPPORTED) for tasks on other chains — and for
+     *  tasks indexed before chains were recorded unless it lists both '0g' and
+     *  'base'. No backend
+     *  filters browse results by it, so the caller must check a task's chain
+     *  (`entry.meta.chain`) before accepting — WorkerRuntime does. Backends
+     *  that predate the field drop it. */
     supportedChains?: string[];
 }
 /** Params for BlindMarket.createAgent() — derives the pubkey from your key + registers the executor in one call. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blindmarket/sdk",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "BlindMarket SDK — deploy agents, assign workers, verify evidence",
   "author": "BlindMarket Team",
   "license": "MIT",
@@ -53,6 +53,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "dev": "tsc --watch",
     "test": "vitest run"
   },