@blindmarket/sdk 0.1.7 → 0.1.8

package/src/executor/WorkerRuntime.ts

@@ -0,0 +1,338 @@
+import { BlindMarket } from '../index.js';
+import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
+import type {
+  A2ATaskState, AgentCapability, ExecutorProfile, Message,
+} from '../types.js';
+
+// ── Config ──────────────────────────────────────────────────────────────────
+
+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;
+}
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+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 };
+
+// ── Defaults ────────────────────────────────────────────────────────────────
+
+const DEFAULTS = {
+  browseIntervalMs: 15_000,
+  watchIntervalMs: 5_000,
+  maxConcurrentTasks: 3,
+};
+
+// ── WorkerRuntime ───────────────────────────────────────────────────────────
+
+export class WorkerRuntime {
+  private bb: BlindMarket;
+  private config: WorkerRuntimeConfig & typeof DEFAULTS;
+  private wallet?: { address: string; privateKey: string; publicKey: string };
+  private profile?: ExecutorProfile;
+  private running = false;
+  private paused = false;
+  private browseTimer?: ReturnType<typeof setInterval>;
+  private watchTimers = new Map<string, ReturnType<typeof setInterval>>();
+  private executions = new Map<string, TaskExecutionInfo>();
+  private listeners = new Set<(event: WorkerRuntimeEvent) => void>();
+
+  constructor(config: WorkerRuntimeConfig) {
+    this.config = { ...DEFAULTS, ...config };
+    this.bb = new BlindMarket({ apiKey: config.apiKey, apiBase: config.apiBase });
+  }
+
+  // ── Status ──────────────────────────────────────────────────────────────
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+
+  get isPaused(): boolean {
+    return this.paused;
+  }
+
+  get activeExecutions(): TaskExecutionInfo[] {
+    return [...this.executions.values()];
+  }
+
+  /** Get own executor profile (available after start). */
+  get executorProfile(): ExecutorProfile | undefined {
+    return this.profile;
+  }
+
+  /** Get own wallet info (available after start). */
+  get executorWallet(): { address: string; publicKey: string } | undefined {
+    return this.wallet;
+  }
+
+  // ── Events ──────────────────────────────────────────────────────────────
+
+  on(listener: (event: WorkerRuntimeEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private emit(event: WorkerRuntimeEvent): void {
+    for (const l of this.listeners) l(event);
+  }
+
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+
+  async start(): Promise<ExecutorProfile> {
+    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(): void {
+    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(): void {
+    if (!this.running || this.paused) return;
+    this.paused = true;
+    this.emit({ type: 'paused' });
+  }
+
+  resume(): void {
+    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 ─────────────────────────────────────────────────────────
+
+  private startBrowseLoop(): void {
+    const ms = this.config.browseIntervalMs;
+    this.browseTimer = setInterval(() => this.browse(), ms);
+    this.browse();
+  }
+
+  private async browse(): Promise<void> {
+    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 ─────────────────────────────────────────────────
+
+  private watchForAssignment(taskId: string): void {
+    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 ──────────────────────────────────────────────────────
+
+  private async executeTask(taskId: string, a2a: A2ATaskState): Promise<void> {
+    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 ─────────────────────────────────────────────────────────────
+
+  private decodeWrappedKey(wrappedKey: Record<string, string>): Uint8Array {
+    // 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;
+  }
+
+  private hexToBytes(hex: string): Uint8Array {
+    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/src/executor/index.ts

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

package/src/index.ts

@@ -200,7 +200,7 @@ export class BlindMarket {
     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,
@@ -382,7 +382,7 @@ export class BlindMarket {
     reasoning: string;
     teeVerified?: boolean;
   }> {
-    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,
@@ -424,7 +424,7 @@ export class BlindMarket {
     return this.req<{ data: Hex }>('GET', `/api/v1/storage/${rootHash}`);
   }
 
-  // ── Messages ────────────────────────────────────────────────────────────
+  // ── Messages ─────────────────────────────────────────────────────────────
 
   /** Send a message to another user or agent. */
   async sendMessage(params: {
@@ -614,4 +614,23 @@ export {
 } from './tools/index.js';
 export type { Tool, ToolKit, ToolDefinition } from './tools/types.js';
 export type { BlindMarketTools } from './tools/index.js';
-export * from './types.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 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/src/network/presets.ts

@@ -1,16 +1,22 @@
-import type { Network } from './types.js';
+import type { Network } from '../chain/domain-types.js';
 
 /**
  * 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'       // deprecated alias → og-testnet
+  | 'og-testnet'
+  | 'og-mainnet';
+
 export const networks = {
-  testnet: {
+  // ── 0G EVM chains ─────────────────────────────────────────────────────
+
+  'og-testnet': {
     name: '0g-galileo-testnet',
-    chainId: 16602n,
+    chainType: 'evm' as const,
+    chainId: 16602,
     rpc: ['https://evmrpc-testnet.0g.ai'],
     contracts: {
       escrow: '0xFd4F93F5A7BE144c405D1D8fbEC63Fb776207681',
@@ -22,6 +28,39 @@ export const networks = {
     broker: 'https://broker.testnet.0g.ai',
     explorer: 'https://chainscan-galileo.0g.ai',
   },
-} as const satisfies Record<string, Network>;
 
-export type NetworkName = keyof typeof networks;
+  'og-mainnet': {
+    name: '0g-mainnet',
+    chainType: 'evm' as const,
+    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',
+    chainType: 'evm' as const,
+    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',
+  },
+} as const satisfies Record<NetworkName, Network>;

package/src/network/resolve.ts

@@ -1,19 +1,31 @@
 import { ConfigError } from '../errors/index.js';
 import { networks, 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 function resolveNetwork(arg: NetworkName | Network): Network {
   if (typeof arg === 'string') {
-    const preset = (networks as Record<string, Network | undefined>)[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 as unknown as Network;
   }
   return arg;
 }
+
+/**
+ * Type guard: check if a Network is an EVM network.
+ */
+export function isEVMNetwork(network: Network): network is Network & { chainType: 'evm' } {
+  return network.chainType === 'evm';
+}

package/src/network/types.ts

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

package/src/signer/index.ts

@@ -1,3 +1,3 @@
 export * from './Signer.js';
 export * from './EthersSigner.js';
-export * from './PrivateKeySigner.js';
+export * from './PrivateKeySigner.js';

package/src/types.ts

@@ -22,7 +22,8 @@ export type TaskStatus =
   | 'submitted'
   | 'verified'
   | 'completed'
-  | 'cancelled';
+  | 'cancelled'
+  | 'disputed';
 
 export interface TaskMetadata {
   category: string;

package/dist/BlindEscrowClient-CyPuKMge.d.cts

@@ -1,54 +0,0 @@
-import { ethers } from 'ethers';
-import { A as Address, H as Hex, T as TaskId, b as TxReceiptLike, e as TaskStatus } from './types-BOG5Ub1z.cjs';
-
-interface CreateTaskArgs {
-    taskHash: Hex;
-    token: Address;
-    amount: bigint;
-    category: string;
-    locationZone: string;
-    deadline: bigint;
-}
-interface OnChainTask {
-    taskId: TaskId;
-    agent: Address;
-    worker: Address;
-    token: Address;
-    amount: bigint;
-    taskHash: Hex;
-    evidenceHash: Hex;
-    status: TaskStatus;
-    createdAt: Date;
-    deadline: Date;
-}
-/**
- * Typed ethers v6 wrapper for the BlindEscrow contract. Every state-changing
- * method awaits one confirmation and returns a TxReceiptLike; every read
- * returns decoded values. Ethers errors are mapped to ChainError via
- * wrapChainError().
- */
-declare class BlindEscrowClient {
-    readonly contract: ethers.Contract;
-    readonly address: Address;
-    constructor(address: Address, runner: ethers.ContractRunner);
-    /** Create a task and return its id + receipt. Reads the TaskCreated event for the id. */
-    createTask(args: CreateTaskArgs): Promise<{
-        taskId: TaskId;
-        receipt: TxReceiptLike;
-    }>;
-    assignWorker(taskId: TaskId, worker: Address): Promise<TxReceiptLike>;
-    submitEvidence(taskId: TaskId, evidenceHash: Hex): Promise<TxReceiptLike>;
-    completeVerification(taskId: TaskId, passed: boolean): Promise<TxReceiptLike>;
-    cancelTask(taskId: TaskId): Promise<TxReceiptLike>;
-    raiseDispute(taskId: TaskId): Promise<TxReceiptLike>;
-    resolveDispute(taskId: TaskId, workerFavored: boolean): Promise<TxReceiptLike>;
-    claimTimeout(taskId: TaskId): Promise<TxReceiptLike>;
-    getTask(taskId: TaskId): Promise<OnChainTask>;
-    isTaskExpired(taskId: TaskId): Promise<boolean>;
-    nextTaskId(): Promise<TaskId>;
-    feeBps(): Promise<bigint>;
-    private sendTx;
-    private extractTaskIdFromReceipt;
-}
-
-export { BlindEscrowClient as B, type CreateTaskArgs as C, type OnChainTask as O };

package/dist/BlindEscrowClient-R7iGpE-n.d.ts

@@ -1,54 +0,0 @@
-import { ethers } from 'ethers';
-import { A as Address, H as Hex, T as TaskId, b as TxReceiptLike, e as TaskStatus } from './types-BOG5Ub1z.js';
-
-interface CreateTaskArgs {
-    taskHash: Hex;
-    token: Address;
-    amount: bigint;
-    category: string;
-    locationZone: string;
-    deadline: bigint;
-}
-interface OnChainTask {
-    taskId: TaskId;
-    agent: Address;
-    worker: Address;
-    token: Address;
-    amount: bigint;
-    taskHash: Hex;
-    evidenceHash: Hex;
-    status: TaskStatus;
-    createdAt: Date;
-    deadline: Date;
-}
-/**
- * Typed ethers v6 wrapper for the BlindEscrow contract. Every state-changing
- * method awaits one confirmation and returns a TxReceiptLike; every read
- * returns decoded values. Ethers errors are mapped to ChainError via
- * wrapChainError().
- */
-declare class BlindEscrowClient {
-    readonly contract: ethers.Contract;
-    readonly address: Address;
-    constructor(address: Address, runner: ethers.ContractRunner);
-    /** Create a task and return its id + receipt. Reads the TaskCreated event for the id. */
-    createTask(args: CreateTaskArgs): Promise<{
-        taskId: TaskId;
-        receipt: TxReceiptLike;
-    }>;
-    assignWorker(taskId: TaskId, worker: Address): Promise<TxReceiptLike>;
-    submitEvidence(taskId: TaskId, evidenceHash: Hex): Promise<TxReceiptLike>;
-    completeVerification(taskId: TaskId, passed: boolean): Promise<TxReceiptLike>;
-    cancelTask(taskId: TaskId): Promise<TxReceiptLike>;
-    raiseDispute(taskId: TaskId): Promise<TxReceiptLike>;
-    resolveDispute(taskId: TaskId, workerFavored: boolean): Promise<TxReceiptLike>;
-    claimTimeout(taskId: TaskId): Promise<TxReceiptLike>;
-    getTask(taskId: TaskId): Promise<OnChainTask>;
-    isTaskExpired(taskId: TaskId): Promise<boolean>;
-    nextTaskId(): Promise<TaskId>;
-    feeBps(): Promise<bigint>;
-    private sendTx;
-    private extractTaskIdFromReceipt;
-}
-
-export { BlindEscrowClient as B, type CreateTaskArgs as C, type OnChainTask as O };