@varun-ai07/covenant-mcp 2.0.2 → 2.0.3

package/dist/sdk/v5-extensions.js

@@ -0,0 +1,993 @@
+import { getContractAddresses, CHAIN_CONFIGS } from "./config.js";
+// V5 ABIs (all functions)
+import CovenantSettlementABI from "./contracts/CovenantSettlement.json" with { type: "json" };
+import CovenantArbitrationABI from "./contracts/CovenantArbitration.json" with { type: "json" };
+import CovenantAttestationABI from "./contracts/CovenantAttestation.json" with { type: "json" };
+import CovenantGovernanceABI from "./contracts/CovenantGovernance.json" with { type: "json" };
+import InsurancePoolABI from "./contracts/InsurancePool.json" with { type: "json" };
+import TrainingMarketplaceABI from "./contracts/TrainingMarketplace.json" with { type: "json" };
+import GrantProgramABI from "./contracts/GrantProgram.json" with { type: "json" };
+import RevisionManagerABI from "./contracts/RevisionManager.json" with { type: "json" };
+import ParallelTaskBatchABI from "./contracts/ParallelTaskBatch.json" with { type: "json" };
+import AgentCollectiveABI from "./contracts/AgentCollective.json" with { type: "json" };
+import MultiTokenEscrowABI from "./contracts/MultiTokenEscrow.json" with { type: "json" };
+import COVENANTRouterABI from "./contracts/COVENANTRouter.json" with { type: "json" };
+export class CovenantSDKV5 {
+    publicClient;
+    walletClient;
+    chain;
+    account;
+    addresses;
+    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: [] } },
+        };
+    }
+    requireWallet() {
+        if (!this.walletClient) {
+            throw new Error("Wallet client required for write operations. Pass walletClient in config.");
+        }
+    }
+    getAddresses() {
+        return { ...this.addresses };
+    }
+    async waitForTransaction(hash) {
+        return await this.publicClient.waitForTransactionReceipt({ hash });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // CovenantSettlement (17 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createStream(payee, ratePerSecond, duration) {
+        this.requireWallet();
+        const totalCost = ratePerSecond * BigInt(duration);
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "createStream",
+            args: [payee, ratePerSecond, duration],
+            value: totalCost,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async withdrawStream(streamId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "withdrawStream",
+            args: [streamId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async cancelStream(streamId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "cancelStream",
+            args: [streamId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getStream(streamId) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "getStream",
+            args: [streamId],
+        });
+    }
+    async streamCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "streamCount",
+            args: [],
+        });
+    }
+    async claimableAmount(streamId) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "claimableAmount",
+            args: [streamId],
+        });
+    }
+    async settleReceipt(payer, payee, amount, nonce, payerSignature) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "settleReceipt",
+            args: [payer, payee, amount, nonce, payerSignature],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async batchSettleReceipts(payers, payees, amounts, nonces, payerSignatures) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "batchSettleReceipts",
+            args: [payers, payees, amounts, nonces, payerSignatures],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async receiptCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "receiptCount",
+            args: [],
+        });
+    }
+    async batchCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantSettlement,
+            abi: CovenantSettlementABI.abi,
+            functionName: "batchCount",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // CovenantArbitration (17 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createDispute(taskId, evidenceHash) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "createDispute",
+            args: [taskId, evidenceHash],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async stakeForDispute(disputeId, amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "stakeForDispute",
+            args: [disputeId],
+            value: amount,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async settleDispute(disputeId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "settleDispute",
+            args: [disputeId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async submitRuling(disputeId, ruling, splitBps, arbiterSignature) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "submitRuling",
+            args: [disputeId, ruling, splitBps, arbiterSignature],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getDispute(disputeId) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "getDispute",
+            args: [disputeId],
+        });
+    }
+    async disputeCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "disputeCount",
+            args: [],
+        });
+    }
+    async arbiter() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantArbitration,
+            abi: CovenantArbitrationABI.abi,
+            functionName: "arbiter",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // CovenantAttestation (15 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async attest(subject, schemaHash, dataHash, expiresAt) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "attest",
+            args: [subject, schemaHash, dataHash, expiresAt],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async attestBatch(subjects, schemaHash, dataHashes, expiresAt) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "attestBatch",
+            args: [subjects, schemaHash, dataHashes, expiresAt],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async verifyAttestation(attestationId) {
+        const result = await this.publicClient.readContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "verify",
+            args: [attestationId],
+        });
+        return result;
+    }
+    async attestationCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "attestationCount",
+            args: [],
+        });
+    }
+    async getAgentAttestations(agent) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "getAgentAttestations",
+            args: [agent],
+        });
+    }
+    async registerIssuer(issuer, name) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "registerIssuer",
+            args: [issuer, name],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async registerSchema(schemaHash, name) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "registerSchema",
+            args: [schemaHash, name],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async revokeAttestation(attestationId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "revoke",
+            args: [attestationId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async isIssuer(address) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "isIssuer",
+            args: [address],
+        });
+    }
+    async schemaExists(schemaHash) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantAttestation,
+            abi: CovenantAttestationABI.abi,
+            functionName: "schemas",
+            args: [schemaHash],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // CovenantGovernance (26 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async propose(target, callData, descriptionHash, votingPeriod) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "propose",
+            args: [target, callData, descriptionHash, votingPeriod],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async submitVotes(proposalId, forVotes, againstVotes, guardianSignature) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "submitVotes",
+            args: [proposalId, forVotes, againstVotes, guardianSignature],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async executeProposal(proposalId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "executeProposal",
+            args: [proposalId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async vetoProposal(proposalId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "vetoProposal",
+            args: [proposalId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async emergencyPause(target, paused) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "emergencyPause",
+            args: [target, paused],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getProposal(proposalId) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "getProposal",
+            args: [proposalId],
+        });
+    }
+    async proposalCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "proposalCount",
+            args: [],
+        });
+    }
+    async quorum() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "quorum",
+            args: [],
+        });
+    }
+    async guardian() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "guardian",
+            args: [],
+        });
+    }
+    async vetoer() {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "vetoer",
+            args: [],
+        });
+    }
+    async isPaused(target) {
+        return this.publicClient.readContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "isPaused",
+            args: [target],
+        });
+    }
+    async setGuardian(newGuardian) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "setGuardian",
+            args: [newGuardian],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async setVetoer(newVetoer) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "setVetoer",
+            args: [newVetoer],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async setQuorum(newQuorum) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.CovenantGovernance,
+            abi: CovenantGovernanceABI.abi,
+            functionName: "setQuorum",
+            args: [newQuorum],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // InsurancePool (19 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async joinPool(amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "joinPool",
+            args: [],
+            value: amount,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async fileClaim(taskId, amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "fileClaim",
+            args: [taskId, amount],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async voteOnClaim(claimId, inFavor) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "voteOnClaim",
+            args: [claimId, inFavor],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async approveClaim(claimId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "approveClaim",
+            args: [claimId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async payClaim(claimId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "payClaim",
+            args: [claimId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async withdrawPool() {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "withdraw",
+            args: [],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getPoolBalance() {
+        return this.publicClient.readContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "getPoolBalance",
+            args: [],
+        });
+    }
+    async getMemberInfo(address) {
+        return this.publicClient.readContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "members",
+            args: [address],
+        });
+    }
+    async getClaim(claimId) {
+        return this.publicClient.readContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "claims",
+            args: [claimId],
+        });
+    }
+    async claimCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "claimCount",
+            args: [],
+        });
+    }
+    async memberCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.InsurancePool,
+            abi: InsurancePoolABI.abi,
+            functionName: "memberCount",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // TrainingMarketplace (13 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createTraining(title, price) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "createTraining",
+            args: [title, price],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async enroll(trainingId, price) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "enroll",
+            args: [trainingId],
+            value: price,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getTraining(trainingId) {
+        return this.publicClient.readContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "trainings",
+            args: [trainingId],
+        });
+    }
+    async trainingCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "trainingCount",
+            args: [],
+        });
+    }
+    async platformFeeBps() {
+        return this.publicClient.readContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "platformFeeBps",
+            args: [],
+        });
+    }
+    async feeRecipient() {
+        return this.publicClient.readContract({
+            address: this.addresses.TrainingMarketplace,
+            abi: TrainingMarketplaceABI.abi,
+            functionName: "feeRecipient",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // GrantProgram (14 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async depositToGrants(amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "deposit",
+            args: [],
+            value: amount,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async applyGrant(amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "applyGrant",
+            args: [amount],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async voteGrant(grantId, inFavor) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "voteGrant",
+            args: [grantId, inFavor],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async disburseGrant(grantId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "disburseGrant",
+            args: [grantId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getGrant(grantId) {
+        return this.publicClient.readContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "grants",
+            args: [grantId],
+        });
+    }
+    async grantCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "grantCount",
+            args: [],
+        });
+    }
+    async treasury() {
+        return this.publicClient.readContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "treasury",
+            args: [],
+        });
+    }
+    async votingPeriod() {
+        return this.publicClient.readContract({
+            address: this.addresses.GrantProgram,
+            abi: GrantProgramABI.abi,
+            functionName: "votingPeriod",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // RevisionManager (17 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async requestRevision(taskId, feedbackHash) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "requestRevision",
+            args: [taskId, feedbackHash],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async submitRevision(taskId, newHash) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "submitRevision",
+            args: [taskId, newHash],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getRevisionCount(taskId) {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "getRevisionCount",
+            args: [taskId],
+        });
+    }
+    async getLatestRevision(taskId) {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "getLatestRevision",
+            args: [taskId],
+        });
+    }
+    async getRevision(taskId, revisionNumber) {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "revisions",
+            args: [taskId, revisionNumber],
+        });
+    }
+    async revisionAllowed(taskId) {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "revisionAllowed",
+            args: [taskId],
+        });
+    }
+    async taskClient(taskId) {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "taskClient",
+            args: [taskId],
+        });
+    }
+    async setTaskClient(taskId, client) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "setTaskClient",
+            args: [taskId, client],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async setMaxRevisions(taskId, max) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "setMaxRevisions",
+            args: [taskId, max],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async setRevisionAllowed(taskId, allowed) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "setRevisionAllowed",
+            args: [taskId, allowed],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async defaultMaxRevisions() {
+        return this.publicClient.readContract({
+            address: this.addresses.RevisionManager,
+            abi: RevisionManagerABI.abi,
+            functionName: "defaultMaxRevisions",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // ParallelTaskBatch (15 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createBatch(workers, payments, deadlines, descriptionHashes, aggregationSpec) {
+        this.requireWallet();
+        const totalBudget = payments.reduce((a, b) => a + b, 0n);
+        return this.walletClient.writeContract({
+            address: this.addresses.ParallelTaskBatch,
+            abi: ParallelTaskBatchABI.abi,
+            functionName: "createBatch",
+            args: [workers, payments, deadlines, descriptionHashes, aggregationSpec],
+            value: totalBudget,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async aggregateResults(batchId) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.ParallelTaskBatch,
+            abi: ParallelTaskBatchABI.abi,
+            functionName: "aggregateResults",
+            args: [batchId],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getBatch(batchId) {
+        return this.publicClient.readContract({
+            address: this.addresses.ParallelTaskBatch,
+            abi: ParallelTaskBatchABI.abi,
+            functionName: "getBatch",
+            args: [batchId],
+        });
+    }
+    async batchCounter() {
+        return this.publicClient.readContract({
+            address: this.addresses.ParallelTaskBatch,
+            abi: ParallelTaskBatchABI.abi,
+            functionName: "batchCounter",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // AgentCollective (15 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createCollective(minContribution, maxMembers) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.AgentCollective,
+            abi: AgentCollectiveABI.abi,
+            functionName: "createCollective",
+            args: [minContribution, maxMembers],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async joinCollective(collectiveId, amount) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.AgentCollective,
+            abi: AgentCollectiveABI.abi,
+            functionName: "joinCollective",
+            args: [collectiveId],
+            value: amount,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async launchCollectiveTask(collectiveId, worker, payment, deadline, descriptionHash) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.AgentCollective,
+            abi: AgentCollectiveABI.abi,
+            functionName: "launchCollectiveTask",
+            args: [collectiveId, worker, payment, deadline, descriptionHash],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async getCollective(collectiveId) {
+        return this.publicClient.readContract({
+            address: this.addresses.AgentCollective,
+            abi: AgentCollectiveABI.abi,
+            functionName: "getCollective",
+            args: [collectiveId],
+        });
+    }
+    async collectiveCounter() {
+        return this.publicClient.readContract({
+            address: this.addresses.AgentCollective,
+            abi: AgentCollectiveABI.abi,
+            functionName: "collectiveCounter",
+            args: [],
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // MultiTokenEscrow (16 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async createTaskERC20(worker, token, amount, deadline) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "createTaskERC20",
+            args: [worker, token, amount, deadline],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async verifyTask(taskId, success) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "verifyTask",
+            args: [taskId, success],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async multiTokenTaskCount() {
+        return this.publicClient.readContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "taskCount",
+            args: [],
+        });
+    }
+    async isAcceptedToken(token) {
+        return this.publicClient.readContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "acceptedTokens",
+            args: [token],
+        });
+    }
+    async tokenFee(token) {
+        return this.publicClient.readContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "tokenFees",
+            args: [token],
+        });
+    }
+    async setAcceptedToken(token, accepted) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.MultiTokenEscrow,
+            abi: MultiTokenEscrowABI.abi,
+            functionName: "setAcceptedToken",
+            args: [token, accepted],
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // COVENANTRouter (7 functions)
+    // ═══════════════════════════════════════════════════════════════
+    async multicall(calls) {
+        this.requireWallet();
+        const totalValue = calls.reduce((a, b) => a + b.value, 0n);
+        return this.walletClient.writeContract({
+            address: this.addresses.COVENANTRouter,
+            abi: COVENANTRouterABI.abi,
+            functionName: "multicall",
+            args: [calls],
+            value: totalValue,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+    async registerAndCreateTask(agentRegistry, taskEscrow, name, capabilities, worker, payment, deadline, descriptionHash) {
+        this.requireWallet();
+        return this.walletClient.writeContract({
+            address: this.addresses.COVENANTRouter,
+            abi: COVENANTRouterABI.abi,
+            functionName: "registerAndCreateTask",
+            args: [agentRegistry, taskEscrow, name, capabilities, worker, payment, deadline, descriptionHash],
+            value: payment,
+            chain: this.chain,
+            account: this.account,
+        });
+    }
+}
+//# sourceMappingURL=v5-extensions.js.map