@varun-ai07/covenant-mcp 2.0.2 → 2.0.3

package/dist/sdk/chunk-Y3YIH5K3.mjs

@@ -0,0 +1,816 @@
+// src/config.ts
+var DEFAULT_ADDRESSES = {
+  // Base Sepolia Testnet
+  84532: {
+    // Core Protocol
+    AgentRegistry: "0xB215589dA259A98eEE8BF39739F6255131ac33A1",
+    TaskEscrow: "0xFD081B5cB8bAE37DC878078bE3165932b0bC0BB3",
+    ReceiptVerifier: "0xa47D15099be6aC516B53a6859D468E9004eEf76b",
+    // Market & Batching
+    OpenTaskMarket: "0x5ccF09469222E5046b0830c6d71ed6B912bE70e6",
+    ParallelTaskBatch: "0xaf23D40668f0e33426824Bf2027A0E9cD26c11Bc",
+    // Collective & Insurance
+    AgentCollective: "0x0CDE9560D2E95338922c40A52A2c81cdd20613d1",
+    AgentInsurance: "0x1798d370e3C566001A84F38EbDc0F6F1Db6bdd55",
+    // Dispute Resolution
+    DisputeArbitration: "0x37A62C6eDd18461CCe00B6772Da8640C75DE740e",
+    // ZK Verifiers
+    Groth16VerifierCapability: "0xd7108ed5C8577B30f6FC024319ebE8B380DaAb85",
+    CapabilityVerifier: "0x628CB2cA13f6FeAc48e0f24f45C3AF2Dbb1c02Fb",
+    Groth16VerifierReputation: "0xbe6AfBa53E06099410d78d56A75b689dfCa6532F",
+    ReputationVerifier: "0x1ac2532e39591cdb5E00Fb9d7C0f47E082d0F149",
+    // Router & Integration
+    COVENANTRouter: "0x565C48FEFc39c9D98a37cCE30583913C7d0d5e09",
+    LitProtocolIntegration: "0x9322B12111699Dd05DD3d0c5D8D08b764051A89f"
+  },
+  // Hardhat Local (placeholder addresses)
+  31337: {
+    AgentRegistry: "0x0000000000000000000000000000000000000000",
+    TaskEscrow: "0x0000000000000000000000000000000000000000",
+    ReceiptVerifier: "0x0000000000000000000000000000000000000000",
+    OpenTaskMarket: "0x0000000000000000000000000000000000000000",
+    ParallelTaskBatch: "0x0000000000000000000000000000000000000000",
+    AgentCollective: "0x0000000000000000000000000000000000000000",
+    AgentInsurance: "0x0000000000000000000000000000000000000000",
+    DisputeArbitration: "0x0000000000000000000000000000000000000000"
+  },
+  // Base Mainnet (placeholder - not deployed yet)
+  8453: {
+    AgentRegistry: "0x0000000000000000000000000000000000000000",
+    TaskEscrow: "0x0000000000000000000000000000000000000000",
+    ReceiptVerifier: "0x0000000000000000000000000000000000000000",
+    OpenTaskMarket: "0x0000000000000000000000000000000000000000",
+    ParallelTaskBatch: "0x0000000000000000000000000000000000000000",
+    AgentCollective: "0x0000000000000000000000000000000000000000",
+    AgentInsurance: "0x0000000000000000000000000000000000000000",
+    DisputeArbitration: "0x0000000000000000000000000000000000000000"
+  }
+};
+var V2_ADDRESSES = {
+  // Base Sepolia Testnet
+  84532: {
+    AgentRegistry: "0x773d1954997b6A91e917e0c2326ABCcAf36e21E1",
+    TaskEscrow: "0xf4d0765A935E36F888d899D9A7C9156CeCdEa6F5",
+    ReceiptVerifier: "0x05cC13692755015FCb11e95d609187b214197edF",
+    InsurancePool: "0x920f3925122B3Ce9380A220AA748e67bD787BE1d",
+    DisputeResolution: "0xFA6dd0929a4ACCCC2E083DaDaD89226dd71Ef28F"
+  },
+  // Hardhat Local (placeholder addresses)
+  31337: {
+    AgentRegistry: "0x0000000000000000000000000000000000000000",
+    TaskEscrow: "0x0000000000000000000000000000000000000000",
+    ReceiptVerifier: "0x0000000000000000000000000000000000000000",
+    InsurancePool: "0x0000000000000000000000000000000000000000",
+    DisputeResolution: "0x0000000000000000000000000000000000000000"
+  },
+  // Base Mainnet (placeholder - not deployed yet)
+  8453: {
+    AgentRegistry: "0x0000000000000000000000000000000000000000",
+    TaskEscrow: "0x0000000000000000000000000000000000000000",
+    ReceiptVerifier: "0x0000000000000000000000000000000000000000",
+    InsurancePool: "0x0000000000000000000000000000000000000000",
+    DisputeResolution: "0x0000000000000000000000000000000000000000"
+  }
+};
+var CHAIN_CONFIGS = {
+  84532: {
+    chain: {
+      id: 84532,
+      name: "Base Sepolia",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: ["https://sepolia.base.org"] } }
+    }
+  },
+  8453: {
+    chain: {
+      id: 8453,
+      name: "Base",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: ["https://mainnet.base.org"] } }
+    }
+  },
+  31337: {
+    chain: {
+      id: 31337,
+      name: "Hardhat Local",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: ["http://localhost:8545"] } }
+    }
+  }
+};
+var CHAINS = {
+  baseSepolia: {
+    id: 84532,
+    name: "Base Sepolia",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+      default: { http: ["https://sepolia.base.org"] }
+    },
+    blockExplorers: {
+      default: { name: "Basescan", url: "https://sepolia.basescan.org" }
+    },
+    testnet: true
+  },
+  base: {
+    id: 8453,
+    name: "Base",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+      default: { http: ["https://mainnet.base.org"] }
+    },
+    blockExplorers: {
+      default: { name: "Basescan", url: "https://basescan.org" }
+    }
+  }
+};
+function getContractAddresses(chainId, overrides) {
+  const defaults = DEFAULT_ADDRESSES[chainId];
+  if (!defaults) {
+    throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(DEFAULT_ADDRESSES).join(", ")}`);
+  }
+  return { ...defaults, ...overrides };
+}
+function isDeployed(chainId) {
+  const addresses = DEFAULT_ADDRESSES[chainId];
+  if (!addresses) return false;
+  return addresses.AgentRegistry !== "0x0000000000000000000000000000000000000000";
+}
+function getV2ContractAddresses(chainId, overrides) {
+  const defaults = V2_ADDRESSES[chainId];
+  if (!defaults) {
+    throw new Error(`Unsupported chain ID for V2: ${chainId}. Supported: ${Object.keys(V2_ADDRESSES).join(", ")}`);
+  }
+  return { ...defaults, ...overrides };
+}
+
+// src/contracts/AgentRegistry.ts
+var AgentRegistryABI = [
+  // Read functions
+  {
+    name: "getAgent",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "agent", type: "address" }],
+    outputs: [
+      { name: "did", type: "bytes32" },
+      { name: "name", type: "string" },
+      { name: "capabilities", type: "string[]" },
+      { name: "reputation", type: "uint256" },
+      { name: "stakedAmount", type: "uint256" },
+      { name: "tasksCompleted", type: "uint256" },
+      { name: "tasksFailed", type: "uint256" },
+      { name: "totalValueTransferred", type: "uint256" },
+      { name: "isActive", type: "bool" },
+      { name: "registeredAt", type: "uint256" },
+      { name: "walletAddress", type: "address" }
+    ]
+  },
+  {
+    name: "getAgentCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getAgentsByCapability",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "capability", type: "string" },
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "address[]" }]
+  },
+  {
+    name: "getAllAgents",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "address[]" }]
+  },
+  // Write functions
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "capabilities", type: "string[]" }
+    ],
+    outputs: []
+  },
+  {
+    name: "deactivate",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  // Events
+  {
+    name: "AgentRegistered",
+    type: "event",
+    inputs: [
+      { name: "agent", type: "address", indexed: true },
+      { name: "did", type: "bytes32", indexed: true },
+      { name: "name", type: "string", indexed: false },
+      { name: "stake", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "ReputationUpdated",
+    type: "event",
+    inputs: [
+      { name: "agent", type: "address", indexed: true },
+      { name: "delta", type: "int256", indexed: false },
+      { name: "newReputation", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/contracts/TaskEscrow.ts
+var TaskEscrowABI = [
+  // Read functions
+  {
+    name: "getTask",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "client", type: "address" },
+      { name: "worker", type: "address" },
+      { name: "payment", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "descriptionHash", type: "string" },
+      { name: "deliverableHash", type: "string" },
+      { name: "status", type: "uint8" },
+      { name: "createdAt", type: "uint256" },
+      { name: "completedAt", type: "uint256" },
+      { name: "protocolFee", type: "uint256" },
+      { name: "totalValue", type: "uint256" }
+    ]
+  },
+  {
+    name: "getTaskCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getClientTasks",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "client", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "getWorkerTasks",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "worker", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  // Write functions
+  {
+    name: "createTask",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { name: "worker", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "descriptionHash", type: "string" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "fundTask",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "startTask",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "submitWork",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "deliverableHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "verifyTask",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "success", type: "bool" }
+    ],
+    outputs: []
+  },
+  {
+    name: "disputeTask",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "cancelTask",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: []
+  },
+  // Events
+  {
+    name: "TaskCreated",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "client", type: "address", indexed: true },
+      { name: "worker", type: "address", indexed: true },
+      { name: "payment", type: "uint256", indexed: false },
+      { name: "deadline", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "WorkSubmitted",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "deliverableHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "TaskCompleted",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "workerPayment", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "TaskDisputed",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "disputedBy", type: "address", indexed: false }
+    ]
+  }
+];
+
+// src/contracts/OpenTaskMarket.ts
+var OpenTaskMarketABI = [
+  // Read functions
+  {
+    name: "getOpenTask",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: [
+      { name: "client", type: "address" },
+      { name: "maxPayment", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "descriptionHash", type: "string" },
+      { name: "bidders", type: "address[]" },
+      { name: "selectedWorker", type: "address" },
+      { name: "status", type: "uint8" }
+    ]
+  },
+  {
+    name: "getBid",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "bidder", type: "address" }
+    ],
+    outputs: [
+      { name: "price", type: "uint256" },
+      { name: "timeEstimate", type: "uint256" },
+      { name: "proposalHash", type: "string" },
+      { name: "bidAt", type: "uint256" }
+    ]
+  },
+  {
+    name: "getOpenTaskCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Write functions
+  {
+    name: "postOpenTask",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { name: "maxPayment", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "descriptionHash", type: "string" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "submitBid",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "price", type: "uint256" },
+      { name: "timeEstimate", type: "uint256" },
+      { name: "proposalHash", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "selectWorker",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "taskId", type: "uint256" },
+      { name: "worker", type: "address" }
+    ],
+    outputs: []
+  },
+  {
+    name: "withdrawBid",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "taskId", type: "uint256" }],
+    outputs: []
+  },
+  // Events
+  {
+    name: "TaskPosted",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "client", type: "address", indexed: true },
+      { name: "maxPayment", type: "uint256", indexed: false },
+      { name: "deadline", type: "uint256", indexed: false },
+      { name: "descriptionHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "BidSubmitted",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "bidder", type: "address", indexed: true },
+      { name: "price", type: "uint256", indexed: false },
+      { name: "timeEstimate", type: "uint256", indexed: false },
+      { name: "proposalHash", type: "string", indexed: false }
+    ]
+  },
+  {
+    name: "WorkerSelected",
+    type: "event",
+    inputs: [
+      { name: "taskId", type: "uint256", indexed: true },
+      { name: "worker", type: "address", indexed: true },
+      { name: "selectedPrice", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/types.ts
+var ReceiptType = /* @__PURE__ */ ((ReceiptType2) => {
+  ReceiptType2[ReceiptType2["TaskCompleted"] = 0] = "TaskCompleted";
+  ReceiptType2[ReceiptType2["AgentVerified"] = 1] = "AgentVerified";
+  ReceiptType2[ReceiptType2["DisputeResolved"] = 2] = "DisputeResolved";
+  ReceiptType2[ReceiptType2["InsuranceClaim"] = 3] = "InsuranceClaim";
+  ReceiptType2[ReceiptType2["MilestoneReached"] = 4] = "MilestoneReached";
+  ReceiptType2[ReceiptType2["ReputationUpdated"] = 5] = "ReputationUpdated";
+  return ReceiptType2;
+})(ReceiptType || {});
+
+// src/index.ts
+var CovenantSDK = class {
+  publicClient;
+  walletClient;
+  addresses;
+  chain;
+  account;
+  constructor(config) {
+    this.publicClient = config.publicClient;
+    this.walletClient = config.walletClient;
+    this.account = config.walletClient?.account;
+    this.addresses = getContractAddresses(config.chainId, config.contractAddresses);
+    this.chain = CHAIN_CONFIGS[config.chainId]?.chain ?? {
+      id: config.chainId,
+      name: `Chain ${config.chainId}`,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [] } }
+    };
+  }
+  // =========================================================================
+  // Agent Methods
+  // =========================================================================
+  /**
+   * Get agent data by address
+   */
+  async getAgent(address) {
+    const result = await this.publicClient.readContract({
+      address: this.addresses.AgentRegistry,
+      abi: AgentRegistryABI,
+      functionName: "getAgent",
+      args: [address]
+    });
+    return this.parseAgentData(result);
+  }
+  /**
+   * Get total number of registered agents
+   */
+  async getAgentCount() {
+    return await this.publicClient.readContract({
+      address: this.addresses.AgentRegistry,
+      abi: AgentRegistryABI,
+      functionName: "getAgentCount",
+      args: []
+    });
+  }
+  /**
+   * Find agents by capability
+   */
+  async findAgents(capability, minReputation, limit = 20) {
+    const addresses = await this.publicClient.readContract({
+      address: this.addresses.AgentRegistry,
+      abi: AgentRegistryABI,
+      functionName: "getAgentsByCapability",
+      args: [capability, BigInt(0), BigInt(limit)]
+    });
+    if (minReputation !== void 0) {
+      const filtered = [];
+      for (const addr of addresses) {
+        const agent = await this.getAgent(addr);
+        if (agent.reputation >= BigInt(minReputation)) {
+          filtered.push(addr);
+        }
+      }
+      return filtered;
+    }
+    return addresses;
+  }
+  /**
+   * Get all agents with pagination
+   */
+  async getAllAgents(offset = 0, limit = 50) {
+    return await this.publicClient.readContract({
+      address: this.addresses.AgentRegistry,
+      abi: AgentRegistryABI,
+      functionName: "getAllAgents",
+      args: [BigInt(offset), BigInt(limit)]
+    });
+  }
+  /**
+   * Register a new agent (requires wallet)
+   */
+  async registerAgent(name, capabilities, stake) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.AgentRegistry,
+      abi: AgentRegistryABI,
+      functionName: "register",
+      args: [name, capabilities],
+      value: stake,
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  // =========================================================================
+  // Task Methods
+  // =========================================================================
+  /**
+   * Get task data by ID
+   */
+  async getTask(taskId) {
+    const result = await this.publicClient.readContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "getTask",
+      args: [taskId]
+    });
+    return this.parseTaskData(result);
+  }
+  /**
+   * Get total number of tasks
+   */
+  async getTaskCount() {
+    return await this.publicClient.readContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "getTaskCount",
+      args: []
+    });
+  }
+  /**
+   * Get all task IDs for a client
+   */
+  async getClientTasks(client) {
+    return await this.publicClient.readContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "getClientTasks",
+      args: [client]
+    });
+  }
+  /**
+   * Get all task IDs for a worker
+   */
+  async getWorkerTasks(worker) {
+    return await this.publicClient.readContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "getWorkerTasks",
+      args: [worker]
+    });
+  }
+  /**
+   * Create a new task (requires wallet)
+   */
+  async createTask(worker, payment, deadline, descriptionHash) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "createTask",
+      args: [worker, deadline, descriptionHash],
+      value: payment,
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  /**
+   * Submit work for a task (requires wallet)
+   */
+  async submitWork(taskId, deliverableHash) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "submitWork",
+      args: [taskId, deliverableHash],
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  /**
+   * Verify task completion (requires wallet)
+   */
+  async verifyTask(taskId, success) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "verifyTask",
+      args: [taskId, success],
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  /**
+   * Dispute a task (requires wallet)
+   */
+  async disputeTask(taskId, disputeBond) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.TaskEscrow,
+      abi: TaskEscrowABI,
+      functionName: "disputeTask",
+      args: [taskId],
+      value: disputeBond,
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  // =========================================================================
+  // Open Task Market Methods
+  // =========================================================================
+  /**
+   * Post an open task for bidding
+   */
+  async postOpenTask(maxPayment, deadline, descriptionHash) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.OpenTaskMarket,
+      abi: OpenTaskMarketABI,
+      functionName: "postOpenTask",
+      args: [maxPayment, deadline, descriptionHash],
+      value: maxPayment,
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  /**
+   * Submit a bid on an open task
+   */
+  async submitBid(taskId, price, timeEstimate, proposalHash) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.OpenTaskMarket,
+      abi: OpenTaskMarketABI,
+      functionName: "submitBid",
+      args: [taskId, price, timeEstimate, proposalHash],
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  /**
+   * Select a worker for an open task
+   */
+  async selectWorker(taskId, worker) {
+    this.requireWallet();
+    return await this.walletClient.writeContract({
+      address: this.addresses.OpenTaskMarket,
+      abi: OpenTaskMarketABI,
+      functionName: "selectWorker",
+      args: [taskId, worker],
+      chain: this.chain,
+      account: this.account
+    });
+  }
+  // =========================================================================
+  // Utility Methods
+  // =========================================================================
+  /**
+   * Wait for a transaction to be confirmed
+   */
+  async waitForTransaction(hash) {
+    return await this.publicClient.waitForTransactionReceipt({ hash });
+  }
+  /**
+   * Get contract addresses being used
+   */
+  getAddresses() {
+    return { ...this.addresses };
+  }
+  // =========================================================================
+  // Private Helpers
+  // =========================================================================
+  requireWallet() {
+    if (!this.walletClient) {
+      throw new Error("Wallet client required for write operations. Pass walletClient in config.");
+    }
+  }
+  parseAgentData(result) {
+    return {
+      did: result[0],
+      name: result[1],
+      capabilities: result[2],
+      reputation: result[3],
+      stakedAmount: result[4],
+      tasksCompleted: result[5],
+      tasksFailed: result[6],
+      totalValueTransferred: result[7],
+      isActive: result[8],
+      registeredAt: result[9],
+      walletAddress: result[10]
+    };
+  }
+  parseTaskData(result) {
+    const statusMap = ["Open", "Funded", "InProgress", "Submitted", "Completed", "Disputed", "Failed", "Cancelled"];
+    return {
+      taskId: result[0],
+      client: result[1],
+      worker: result[2],
+      payment: result[3],
+      deadline: result[4],
+      descriptionHash: result[5],
+      deliverableHash: result[6],
+      status: statusMap[result[7]] || "Open",
+      createdAt: result[8],
+      completedAt: result[9],
+      protocolFee: result[10],
+      totalValue: result[11]
+    };
+  }
+};
+
+export {
+  DEFAULT_ADDRESSES,
+  V2_ADDRESSES,
+  CHAIN_CONFIGS,
+  CHAINS,
+  getContractAddresses,
+  isDeployed,
+  getV2ContractAddresses,
+  ReceiptType,
+  CovenantSDK
+};