@xpr-agents/sdk 0.1.0

package/dist/FeedbackRegistry.d.ts

@@ -0,0 +1,83 @@
+import { Feedback, FeedbackConfig, AgentScore, Dispute, FeedbackListOptions, SubmitFeedbackData, TransactionResult, JsonRpc, ProtonSession } from './types';
+export declare class FeedbackRegistry {
+    private rpc;
+    private session;
+    private contract;
+    constructor(rpc: JsonRpc, session?: ProtonSession, contract?: string);
+    /**
+     * Get feedback by ID
+     */
+    getFeedback(id: number): Promise<Feedback | null>;
+    /**
+     * List feedback for an agent
+     */
+    listFeedbackForAgent(agent: string, options?: FeedbackListOptions): Promise<Feedback[]>;
+    /**
+     * List feedback submitted by a reviewer
+     */
+    listFeedbackByReviewer(reviewer: string, options?: FeedbackListOptions): Promise<Feedback[]>;
+    /**
+     * Get aggregated score for an agent
+     */
+    getAgentScore(agent: string): Promise<AgentScore | null>;
+    /**
+     * Get dispute by ID
+     */
+    getDispute(id: number): Promise<Dispute | null>;
+    /**
+     * Get disputes for a feedback
+     */
+    getDisputesForFeedback(feedbackId: number): Promise<Dispute[]>;
+    /**
+     * Submit feedback for an agent
+     */
+    submit(data: SubmitFeedbackData): Promise<TransactionResult>;
+    /**
+     * Dispute feedback
+     */
+    dispute(feedbackId: number, reason: string, evidenceUri?: string): Promise<TransactionResult>;
+    /**
+     * Recalculate agent score (paginated).
+     *
+     * Recalculation is done in batches to avoid CPU exhaustion.
+     * - First call: offset=0, processes first `limit` feedbacks
+     * - Subsequent calls: use the next_offset from RecalcState
+     * - Recalculation expires after 1 hour if not completed
+     *
+     * @param agent - Agent account to recalculate
+     * @param offset - Must be 0 to start, or match next_offset to continue
+     * @param limit - Feedbacks to process per call (max 100)
+     */
+    recalculate(agent: string, offset?: number, limit?: number): Promise<TransactionResult>;
+    /**
+     * Resolve a feedback dispute (owner only)
+     */
+    resolve(disputeId: number, upheld: boolean, resolutionNotes: string): Promise<TransactionResult>;
+    /**
+     * Cancel an in-progress recalculation
+     */
+    cancelRecalculation(agent: string): Promise<TransactionResult>;
+    /**
+     * Submit feedback with fee in one transaction.
+     *
+     * @param data - Feedback data
+     * @param amount - The feedback fee (e.g., "1.0000 XPR")
+     */
+    submitWithFee(data: SubmitFeedbackData, amount: string): Promise<TransactionResult>;
+    /**
+     * Clean up old feedback entries (permissionless)
+     */
+    cleanFeedback(agent: string, maxAge: number, maxDelete: number): Promise<TransactionResult>;
+    /**
+     * Clean up resolved disputes (permissionless)
+     */
+    cleanDisputes(maxAge: number, maxDelete: number): Promise<TransactionResult>;
+    /**
+     * Get feedback contract configuration
+     */
+    getConfig(): Promise<FeedbackConfig>;
+    private requireSession;
+    private parseFeedback;
+    private parseAgentScore;
+    private parseDispute;
+}

package/dist/FeedbackRegistry.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackRegistry = void 0;
+const utils_1 = require("./utils");
+const DEFAULT_CONTRACT = 'agentfeed';
+class FeedbackRegistry {
+    constructor(rpc, session, contract) {
+        this.rpc = rpc;
+        this.session = session || null;
+        this.contract = contract || DEFAULT_CONTRACT;
+    }
+    // ============== READ OPERATIONS ==============
+    /**
+     * Get feedback by ID
+     */
+    async getFeedback(id) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'feedback',
+            lower_bound: String(id),
+            upper_bound: String(id),
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseFeedback(result.rows[0]);
+    }
+    /**
+     * List feedback for an agent
+     */
+    async listFeedbackForAgent(agent, options = {}) {
+        const { limit = 100 } = options;
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'feedback',
+            index_position: 2,
+            key_type: 'i64',
+            limit,
+        });
+        let feedbacks = result.rows
+            .filter((row) => row.agent === agent)
+            .map((row) => this.parseFeedback(row));
+        if (options.min_score !== undefined) {
+            feedbacks = feedbacks.filter((f) => f.score >= options.min_score);
+        }
+        if (options.max_score !== undefined) {
+            feedbacks = feedbacks.filter((f) => f.score <= options.max_score);
+        }
+        return feedbacks;
+    }
+    /**
+     * List feedback submitted by a reviewer
+     */
+    async listFeedbackByReviewer(reviewer, options = {}) {
+        const { limit = 100 } = options;
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'feedback',
+            index_position: 3,
+            key_type: 'i64',
+            limit,
+        });
+        return result.rows
+            .filter((row) => row.reviewer === reviewer)
+            .map((row) => this.parseFeedback(row));
+    }
+    /**
+     * Get aggregated score for an agent
+     */
+    async getAgentScore(agent) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'agentscores',
+            lower_bound: agent,
+            upper_bound: agent,
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseAgentScore(result.rows[0]);
+    }
+    /**
+     * Get dispute by ID
+     */
+    async getDispute(id) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'disputes',
+            lower_bound: String(id),
+            upper_bound: String(id),
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseDispute(result.rows[0]);
+    }
+    /**
+     * Get disputes for a feedback
+     */
+    async getDisputesForFeedback(feedbackId) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'disputes',
+            index_position: 2,
+            key_type: 'i64',
+            limit: 100,
+        });
+        return result.rows
+            .filter((row) => row.feedback_id === String(feedbackId))
+            .map((row) => this.parseDispute(row));
+    }
+    // ============== WRITE OPERATIONS ==============
+    /**
+     * Submit feedback for an agent
+     */
+    async submit(data) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'submit',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        reviewer: this.session.auth.actor,
+                        agent: data.agent,
+                        score: data.score,
+                        tags: (data.tags || []).join(','),
+                        job_hash: data.job_hash || '',
+                        evidence_uri: data.evidence_uri || '',
+                        amount_paid: data.amount_paid || 0,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Dispute feedback
+     */
+    async dispute(feedbackId, reason, evidenceUri) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'dispute',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        disputer: this.session.auth.actor,
+                        feedback_id: feedbackId,
+                        reason,
+                        evidence_uri: evidenceUri || '',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Recalculate agent score (paginated).
+     *
+     * Recalculation is done in batches to avoid CPU exhaustion.
+     * - First call: offset=0, processes first `limit` feedbacks
+     * - Subsequent calls: use the next_offset from RecalcState
+     * - Recalculation expires after 1 hour if not completed
+     *
+     * @param agent - Agent account to recalculate
+     * @param offset - Must be 0 to start, or match next_offset to continue
+     * @param limit - Feedbacks to process per call (max 100)
+     */
+    async recalculate(agent, offset = 0, limit = 100) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'recalc',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                        offset,
+                        limit,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Resolve a feedback dispute (owner only)
+     */
+    async resolve(disputeId, upheld, resolutionNotes) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'resolve',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        resolver: this.session.auth.actor,
+                        dispute_id: disputeId,
+                        upheld,
+                        resolution_notes: resolutionNotes,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Cancel an in-progress recalculation
+     */
+    async cancelRecalculation(agent) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'cancelrecalc',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Submit feedback with fee in one transaction.
+     *
+     * @param data - Feedback data
+     * @param amount - The feedback fee (e.g., "1.0000 XPR")
+     */
+    async submitWithFee(data, amount) {
+        this.requireSession();
+        const actor = this.session.auth.actor;
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: 'eosio.token',
+                    name: 'transfer',
+                    authorization: [{
+                            actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        from: actor,
+                        to: this.contract,
+                        quantity: amount,
+                        memo: `feedfee:${actor}`,
+                    },
+                },
+                {
+                    account: this.contract,
+                    name: 'submit',
+                    authorization: [{
+                            actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        reviewer: actor,
+                        agent: data.agent,
+                        score: data.score,
+                        tags: (data.tags || []).join(','),
+                        job_hash: data.job_hash || '',
+                        evidence_uri: data.evidence_uri || '',
+                        amount_paid: data.amount_paid || 0,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Clean up old feedback entries (permissionless)
+     */
+    async cleanFeedback(agent, maxAge, maxDelete) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [{
+                    account: this.contract,
+                    name: 'cleanfback',
+                    authorization: [{
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        agent,
+                        max_age: maxAge,
+                        max_delete: maxDelete,
+                    },
+                }],
+        });
+    }
+    /**
+     * Clean up resolved disputes (permissionless)
+     */
+    async cleanDisputes(maxAge, maxDelete) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [{
+                    account: this.contract,
+                    name: 'cleandisps',
+                    authorization: [{
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        max_age: maxAge,
+                        max_delete: maxDelete,
+                    },
+                }],
+        });
+    }
+    /**
+     * Get feedback contract configuration
+     */
+    async getConfig() {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'config',
+            limit: 1,
+        });
+        if (result.rows.length === 0) {
+            throw new Error('Contract not initialized');
+        }
+        const row = result.rows[0];
+        return {
+            owner: row.owner,
+            core_contract: row.core_contract,
+            min_score: row.min_score,
+            max_score: row.max_score,
+            dispute_window: (0, utils_1.safeParseInt)(row.dispute_window),
+            decay_period: (0, utils_1.safeParseInt)(row.decay_period),
+            decay_floor: (0, utils_1.safeParseInt)(row.decay_floor),
+            paused: row.paused === 1,
+            feedback_fee: (0, utils_1.safeParseInt)(row.feedback_fee),
+        };
+    }
+    // ============== HELPERS ==============
+    requireSession() {
+        if (!this.session) {
+            throw new Error('Session required for write operations');
+        }
+    }
+    parseFeedback(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            agent: raw.agent,
+            reviewer: raw.reviewer,
+            reviewer_kyc_level: raw.reviewer_kyc_level,
+            score: raw.score,
+            tags: (0, utils_1.parseTags)(raw.tags),
+            job_hash: raw.job_hash,
+            evidence_uri: raw.evidence_uri,
+            amount_paid: (0, utils_1.safeParseInt)(raw.amount_paid),
+            timestamp: (0, utils_1.safeParseInt)(raw.timestamp),
+            disputed: raw.disputed === 1,
+            resolved: raw.resolved === 1,
+        };
+    }
+    parseAgentScore(raw) {
+        return {
+            agent: raw.agent,
+            total_score: (0, utils_1.safeParseInt)(raw.total_score),
+            total_weight: (0, utils_1.safeParseInt)(raw.total_weight),
+            feedback_count: (0, utils_1.safeParseInt)(raw.feedback_count),
+            avg_score: (0, utils_1.safeParseInt)(raw.avg_score),
+            last_updated: (0, utils_1.safeParseInt)(raw.last_updated),
+        };
+    }
+    parseDispute(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            feedback_id: (0, utils_1.safeParseInt)(raw.feedback_id),
+            disputer: raw.disputer,
+            reason: raw.reason,
+            evidence_uri: raw.evidence_uri,
+            status: (0, utils_1.disputeStatusFromNumber)(raw.status),
+            resolver: raw.resolver,
+            resolution_notes: raw.resolution_notes,
+            created_at: (0, utils_1.safeParseInt)(raw.created_at),
+            resolved_at: (0, utils_1.safeParseInt)(raw.resolved_at),
+        };
+    }
+}
+exports.FeedbackRegistry = FeedbackRegistry;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FeedbackRegistry.js","sourceRoot":"","sources":["../src/FeedbackRegistry.ts"],"names":[],"mappings":";;;AAaA,mCAA2E;AAE3E,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAErC,MAAa,gBAAgB;IAK3B,YAAY,GAAY,EAAE,OAAuB,EAAE,QAAiB;QAClE,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,IAAI,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,gBAAgB,CAAC;IAC/C,CAAC;IAED,gDAAgD;IAEhD;;OAEG;IACH,KAAK,CAAC,WAAW,CAAC,EAAU;QAC1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAAc;YACxD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,UAAU;YACjB,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;YACvB,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;YACvB,KAAK,EAAE,CAAC;SACT,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CACxB,KAAa,EACb,UAA+B,EAAE;QAEjC,MAAM,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC;QAEhC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAAc;YACxD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,UAAU;YACjB,cAAc,EAAE,CAAC;YACjB,QAAQ,EAAE,KAAK;YACf,KAAK;SACN,CAAC,CAAC;QAEH,IAAI,SAAS,GAAG,MAAM,CAAC,IAAI;aACxB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,KAAK,KAAK,CAAC;aACpC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;QAEzC,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACpC,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,SAAU,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACpC,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,SAAU,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB,CAC1B,QAAgB,EAChB,UAA+B,EAAE;QAEjC,MAAM,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,OAAO,CAAC;QAEhC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAAc;YACxD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,UAAU;YACjB,cAAc,EAAE,CAAC;YACjB,QAAQ,EAAE,KAAK;YACf,KAAK;SACN,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,IAAI;aACf,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC;aAC1C,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa;QAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAAgB;YAC1D,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,aAAa;YACpB,WAAW,EAAE,KAAK;YAClB,WAAW,EAAE,KAAK;YAClB,KAAK,EAAE,CAAC;SACT,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,EAAU;QACzB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAWzC;YACD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,UAAU;YACjB,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;YACvB,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC;YACvB,KAAK,EAAE,CAAC;SACT,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC1C,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB,CAAC,UAAkB;QAC7C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAWzC;YACD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,UAAU;YACjB,cAAc,EAAE,CAAC;YACjB,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,GAAG;SACX,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,IAAI;aACf,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,KAAK,MAAM,CAAC,UAAU,CAAC,CAAC;aACvD,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,iDAAiD;IAEjD;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,IAAwB;QACnC,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,QAAQ;oBACd,aAAa,EAAE;wBACb;4BACE,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C;qBACF;oBACD,IAAI,EAAE;wBACJ,QAAQ,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;wBAClC,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;wBACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,EAAE;wBAC7B,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,EAAE;wBACrC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,CAAC;qBACnC;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,UAAkB,EAClB,MAAc,EACd,WAAoB;QAEpB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,SAAS;oBACf,aAAa,EAAE;wBACb;4BACE,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C;qBACF;oBACD,IAAI,EAAE;wBACJ,QAAQ,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;wBAClC,WAAW,EAAE,UAAU;wBACvB,MAAM;wBACN,YAAY,EAAE,WAAW,IAAI,EAAE;qBAChC;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,WAAW,CAAC,KAAa,EAAE,SAAiB,CAAC,EAAE,QAAgB,GAAG;QACtE,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,QAAQ;oBACd,aAAa,EAAE;wBACb;4BACE,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C;qBACF;oBACD,IAAI,EAAE;wBACJ,KAAK;wBACL,MAAM;wBACN,KAAK;qBACN;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,SAAiB,EACjB,MAAe,EACf,eAAuB;QAEvB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,SAAS;oBACf,aAAa,EAAE;wBACb;4BACE,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C;qBACF;oBACD,IAAI,EAAE;wBACJ,QAAQ,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;wBAClC,UAAU,EAAE,SAAS;wBACrB,MAAM;wBACN,gBAAgB,EAAE,eAAe;qBAClC;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,mBAAmB,CAAC,KAAa;QACrC,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,cAAc;oBACpB,aAAa,EAAE;wBACb;4BACE,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C;qBACF;oBACD,IAAI,EAAE;wBACJ,KAAK;qBACN;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CAAC,IAAwB,EAAE,MAAc;QAC1D,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;QAEvC,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE;gBACP;oBACE,OAAO,EAAE,aAAa;oBACtB,IAAI,EAAE,UAAU;oBAChB,aAAa,EAAE,CAAC;4BACd,KAAK;4BACL,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C,CAAC;oBACF,IAAI,EAAE;wBACJ,IAAI,EAAE,KAAK;wBACX,EAAE,EAAE,IAAI,CAAC,QAAQ;wBACjB,QAAQ,EAAE,MAAM;wBAChB,IAAI,EAAE,WAAW,KAAK,EAAE;qBACzB;iBACF;gBACD;oBACE,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,QAAQ;oBACd,aAAa,EAAE,CAAC;4BACd,KAAK;4BACL,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C,CAAC;oBACF,IAAI,EAAE;wBACJ,QAAQ,EAAE,KAAK;wBACf,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;wBACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,EAAE;wBAC7B,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,EAAE;wBACrC,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,CAAC;qBACnC;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,MAAc,EAAE,SAAiB;QAClE,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE,CAAC;oBACR,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,YAAY;oBAClB,aAAa,EAAE,CAAC;4BACd,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C,CAAC;oBACF,IAAI,EAAE;wBACJ,KAAK;wBACL,OAAO,EAAE,MAAM;wBACf,UAAU,EAAE,SAAS;qBACtB;iBACF,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa,CAAC,MAAc,EAAE,SAAiB;QACnD,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC;YACjC,OAAO,EAAE,CAAC;oBACR,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,IAAI,EAAE,YAAY;oBAClB,aAAa,EAAE,CAAC;4BACd,KAAK,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,KAAK;4BAC/B,UAAU,EAAE,IAAI,CAAC,OAAQ,CAAC,IAAI,CAAC,UAAU;yBAC1C,CAAC;oBACF,IAAI,EAAE;wBACJ,OAAO,EAAE,MAAM;wBACf,UAAU,EAAE,SAAS;qBACtB;iBACF,CAAC;SACH,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS;QACb,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,CAUzC;YACD,IAAI,EAAE,IAAI;YACV,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,KAAK,EAAE,IAAI,CAAC,QAAQ;YACpB,KAAK,EAAE,QAAQ;YACf,KAAK,EAAE,CAAC;SACT,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QAED,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC3B,OAAO;YACL,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,aAAa,EAAE,GAAG,CAAC,aAAa;YAChC,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,cAAc,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,cAAc,CAAC;YAChD,YAAY,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,YAAY,CAAC;YAC5C,WAAW,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,WAAW,CAAC;YAC1C,MAAM,EAAE,GAAG,CAAC,MAAM,KAAK,CAAC;YACxB,YAAY,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,YAAY,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED,wCAAwC;IAEhC,cAAc;QACpB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,GAAgB;QACpC,OAAO;YACL,EAAE,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,EAAE,CAAC;YACxB,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,kBAAkB,EAAE,GAAG,CAAC,kBAAkB;YAC1C,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,IAAI,EAAE,IAAA,iBAAS,EAAC,GAAG,CAAC,IAAI,CAAC;YACzB,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,YAAY,EAAE,GAAG,CAAC,YAAY;YAC9B,WAAW,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,WAAW,CAAC;YAC1C,SAAS,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,SAAS,CAAC;YACtC,QAAQ,EAAE,GAAG,CAAC,QAAQ,KAAK,CAAC;YAC5B,QAAQ,EAAE,GAAG,CAAC,QAAQ,KAAK,CAAC;SAC7B,CAAC;IACJ,CAAC;IAEO,eAAe,CAAC,GAAkB;QACxC,OAAO;YACL,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,WAAW,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,WAAW,CAAC;YAC1C,YAAY,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,YAAY,CAAC;YAC5C,cAAc,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,cAAc,CAAC;YAChD,SAAS,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,SAAS,CAAC;YACtC,YAAY,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,YAAY,CAAC;SAC7C,CAAC;IACJ,CAAC;IAEO,YAAY,CAAC,GAWpB;QACC,OAAO;YACL,EAAE,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,EAAE,CAAC;YACxB,WAAW,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,WAAW,CAAC;YAC1C,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,YAAY,EAAE,GAAG,CAAC,YAAY;YAC9B,MAAM,EAAE,IAAA,+BAAuB,EAAC,GAAG,CAAC,MAAM,CAAC;YAC3C,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;YACtC,UAAU,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,UAAU,CAAC;YACxC,WAAW,EAAE,IAAA,oBAAY,EAAC,GAAG,CAAC,WAAW,CAAC;SAC3C,CAAC;IACJ,CAAC;CACF;AAtgBD,4CAsgBC","sourcesContent":["import {\n  Feedback,\n  FeedbackRaw,\n  FeedbackConfig,\n  AgentScore,\n  AgentScoreRaw,\n  Dispute,\n  FeedbackListOptions,\n  SubmitFeedbackData,\n  TransactionResult,\n  JsonRpc,\n  ProtonSession,\n} from './types';\nimport { parseTags, disputeStatusFromNumber, safeParseInt } from './utils';\n\nconst DEFAULT_CONTRACT = 'agentfeed';\n\nexport class FeedbackRegistry {\n  private rpc: JsonRpc;\n  private session: ProtonSession | null;\n  private contract: string;\n\n  constructor(rpc: JsonRpc, session?: ProtonSession, contract?: string) {\n    this.rpc = rpc;\n    this.session = session || null;\n    this.contract = contract || DEFAULT_CONTRACT;\n  }\n\n  // ============== READ OPERATIONS ==============\n\n  /**\n   * Get feedback by ID\n   */\n  async getFeedback(id: number): Promise<Feedback | null> {\n    const result = await this.rpc.get_table_rows<FeedbackRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'feedback',\n      lower_bound: String(id),\n      upper_bound: String(id),\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) return null;\n    return this.parseFeedback(result.rows[0]);\n  }\n\n  /**\n   * List feedback for an agent\n   */\n  async listFeedbackForAgent(\n    agent: string,\n    options: FeedbackListOptions = {}\n  ): Promise<Feedback[]> {\n    const { limit = 100 } = options;\n\n    const result = await this.rpc.get_table_rows<FeedbackRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'feedback',\n      index_position: 2,\n      key_type: 'i64',\n      limit,\n    });\n\n    let feedbacks = result.rows\n      .filter((row) => row.agent === agent)\n      .map((row) => this.parseFeedback(row));\n\n    if (options.min_score !== undefined) {\n      feedbacks = feedbacks.filter((f) => f.score >= options.min_score!);\n    }\n\n    if (options.max_score !== undefined) {\n      feedbacks = feedbacks.filter((f) => f.score <= options.max_score!);\n    }\n\n    return feedbacks;\n  }\n\n  /**\n   * List feedback submitted by a reviewer\n   */\n  async listFeedbackByReviewer(\n    reviewer: string,\n    options: FeedbackListOptions = {}\n  ): Promise<Feedback[]> {\n    const { limit = 100 } = options;\n\n    const result = await this.rpc.get_table_rows<FeedbackRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'feedback',\n      index_position: 3,\n      key_type: 'i64',\n      limit,\n    });\n\n    return result.rows\n      .filter((row) => row.reviewer === reviewer)\n      .map((row) => this.parseFeedback(row));\n  }\n\n  /**\n   * Get aggregated score for an agent\n   */\n  async getAgentScore(agent: string): Promise<AgentScore | null> {\n    const result = await this.rpc.get_table_rows<AgentScoreRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'agentscores',\n      lower_bound: agent,\n      upper_bound: agent,\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) return null;\n    return this.parseAgentScore(result.rows[0]);\n  }\n\n  /**\n   * Get dispute by ID\n   */\n  async getDispute(id: number): Promise<Dispute | null> {\n    const result = await this.rpc.get_table_rows<{\n      id: string;\n      feedback_id: string;\n      disputer: string;\n      reason: string;\n      evidence_uri: string;\n      status: number;\n      resolver: string;\n      resolution_notes: string;\n      created_at: string;\n      resolved_at: string;\n    }>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'disputes',\n      lower_bound: String(id),\n      upper_bound: String(id),\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) return null;\n    return this.parseDispute(result.rows[0]);\n  }\n\n  /**\n   * Get disputes for a feedback\n   */\n  async getDisputesForFeedback(feedbackId: number): Promise<Dispute[]> {\n    const result = await this.rpc.get_table_rows<{\n      id: string;\n      feedback_id: string;\n      disputer: string;\n      reason: string;\n      evidence_uri: string;\n      status: number;\n      resolver: string;\n      resolution_notes: string;\n      created_at: string;\n      resolved_at: string;\n    }>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'disputes',\n      index_position: 2,\n      key_type: 'i64',\n      limit: 100,\n    });\n\n    return result.rows\n      .filter((row) => row.feedback_id === String(feedbackId))\n      .map((row) => this.parseDispute(row));\n  }\n\n  // ============== WRITE OPERATIONS ==============\n\n  /**\n   * Submit feedback for an agent\n   */\n  async submit(data: SubmitFeedbackData): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'submit',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            reviewer: this.session!.auth.actor,\n            agent: data.agent,\n            score: data.score,\n            tags: (data.tags || []).join(','),\n            job_hash: data.job_hash || '',\n            evidence_uri: data.evidence_uri || '',\n            amount_paid: data.amount_paid || 0,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Dispute feedback\n   */\n  async dispute(\n    feedbackId: number,\n    reason: string,\n    evidenceUri?: string\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'dispute',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            disputer: this.session!.auth.actor,\n            feedback_id: feedbackId,\n            reason,\n            evidence_uri: evidenceUri || '',\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Recalculate agent score (paginated).\n   *\n   * Recalculation is done in batches to avoid CPU exhaustion.\n   * - First call: offset=0, processes first `limit` feedbacks\n   * - Subsequent calls: use the next_offset from RecalcState\n   * - Recalculation expires after 1 hour if not completed\n   *\n   * @param agent - Agent account to recalculate\n   * @param offset - Must be 0 to start, or match next_offset to continue\n   * @param limit - Feedbacks to process per call (max 100)\n   */\n  async recalculate(agent: string, offset: number = 0, limit: number = 100): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'recalc',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n            offset,\n            limit,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Resolve a feedback dispute (owner only)\n   */\n  async resolve(\n    disputeId: number,\n    upheld: boolean,\n    resolutionNotes: string\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'resolve',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            resolver: this.session!.auth.actor,\n            dispute_id: disputeId,\n            upheld,\n            resolution_notes: resolutionNotes,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Cancel an in-progress recalculation\n   */\n  async cancelRecalculation(agent: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'cancelrecalc',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Submit feedback with fee in one transaction.\n   *\n   * @param data - Feedback data\n   * @param amount - The feedback fee (e.g., \"1.0000 XPR\")\n   */\n  async submitWithFee(data: SubmitFeedbackData, amount: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    const actor = this.session!.auth.actor;\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: 'eosio.token',\n          name: 'transfer',\n          authorization: [{\n            actor,\n            permission: this.session!.auth.permission,\n          }],\n          data: {\n            from: actor,\n            to: this.contract,\n            quantity: amount,\n            memo: `feedfee:${actor}`,\n          },\n        },\n        {\n          account: this.contract,\n          name: 'submit',\n          authorization: [{\n            actor,\n            permission: this.session!.auth.permission,\n          }],\n          data: {\n            reviewer: actor,\n            agent: data.agent,\n            score: data.score,\n            tags: (data.tags || []).join(','),\n            job_hash: data.job_hash || '',\n            evidence_uri: data.evidence_uri || '',\n            amount_paid: data.amount_paid || 0,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Clean up old feedback entries (permissionless)\n   */\n  async cleanFeedback(agent: string, maxAge: number, maxDelete: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [{\n        account: this.contract,\n        name: 'cleanfback',\n        authorization: [{\n          actor: this.session!.auth.actor,\n          permission: this.session!.auth.permission,\n        }],\n        data: {\n          agent,\n          max_age: maxAge,\n          max_delete: maxDelete,\n        },\n      }],\n    });\n  }\n\n  /**\n   * Clean up resolved disputes (permissionless)\n   */\n  async cleanDisputes(maxAge: number, maxDelete: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [{\n        account: this.contract,\n        name: 'cleandisps',\n        authorization: [{\n          actor: this.session!.auth.actor,\n          permission: this.session!.auth.permission,\n        }],\n        data: {\n          max_age: maxAge,\n          max_delete: maxDelete,\n        },\n      }],\n    });\n  }\n\n  /**\n   * Get feedback contract configuration\n   */\n  async getConfig(): Promise<FeedbackConfig> {\n    const result = await this.rpc.get_table_rows<{\n      owner: string;\n      core_contract: string;\n      min_score: number;\n      max_score: number;\n      dispute_window: string;\n      decay_period: string;\n      decay_floor: string;\n      paused: number;\n      feedback_fee: string;\n    }>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'config',\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) {\n      throw new Error('Contract not initialized');\n    }\n\n    const row = result.rows[0];\n    return {\n      owner: row.owner,\n      core_contract: row.core_contract,\n      min_score: row.min_score,\n      max_score: row.max_score,\n      dispute_window: safeParseInt(row.dispute_window),\n      decay_period: safeParseInt(row.decay_period),\n      decay_floor: safeParseInt(row.decay_floor),\n      paused: row.paused === 1,\n      feedback_fee: safeParseInt(row.feedback_fee),\n    };\n  }\n\n  // ============== HELPERS ==============\n\n  private requireSession(): void {\n    if (!this.session) {\n      throw new Error('Session required for write operations');\n    }\n  }\n\n  private parseFeedback(raw: FeedbackRaw): Feedback {\n    return {\n      id: safeParseInt(raw.id),\n      agent: raw.agent,\n      reviewer: raw.reviewer,\n      reviewer_kyc_level: raw.reviewer_kyc_level,\n      score: raw.score,\n      tags: parseTags(raw.tags),\n      job_hash: raw.job_hash,\n      evidence_uri: raw.evidence_uri,\n      amount_paid: safeParseInt(raw.amount_paid),\n      timestamp: safeParseInt(raw.timestamp),\n      disputed: raw.disputed === 1,\n      resolved: raw.resolved === 1,\n    };\n  }\n\n  private parseAgentScore(raw: AgentScoreRaw): AgentScore {\n    return {\n      agent: raw.agent,\n      total_score: safeParseInt(raw.total_score),\n      total_weight: safeParseInt(raw.total_weight),\n      feedback_count: safeParseInt(raw.feedback_count),\n      avg_score: safeParseInt(raw.avg_score),\n      last_updated: safeParseInt(raw.last_updated),\n    };\n  }\n\n  private parseDispute(raw: {\n    id: string;\n    feedback_id: string;\n    disputer: string;\n    reason: string;\n    evidence_uri: string;\n    status: number;\n    resolver: string;\n    resolution_notes: string;\n    created_at: string;\n    resolved_at: string;\n  }): Dispute {\n    return {\n      id: safeParseInt(raw.id),\n      feedback_id: safeParseInt(raw.feedback_id),\n      disputer: raw.disputer,\n      reason: raw.reason,\n      evidence_uri: raw.evidence_uri,\n      status: disputeStatusFromNumber(raw.status),\n      resolver: raw.resolver,\n      resolution_notes: raw.resolution_notes,\n      created_at: safeParseInt(raw.created_at),\n      resolved_at: safeParseInt(raw.resolved_at),\n    };\n  }\n}\n"]}

package/dist/ValidationRegistry.d.ts

@@ -0,0 +1,115 @@
+import { Validator, Validation, ValidationConfig, Challenge, ValidatorListOptions, SubmitValidationData, TransactionResult, JsonRpc, ProtonSession } from './types';
+export declare class ValidationRegistry {
+    private rpc;
+    private session;
+    private contract;
+    constructor(rpc: JsonRpc, session?: ProtonSession, contract?: string);
+    /**
+     * Get a validator by account
+     */
+    getValidator(account: string): Promise<Validator | null>;
+    /**
+     * List all validators
+     */
+    listValidators(options?: ValidatorListOptions): Promise<Validator[]>;
+    /**
+     * Get validation by ID
+     */
+    getValidation(id: number): Promise<Validation | null>;
+    /**
+     * List validations for an agent
+     */
+    listValidationsForAgent(agent: string, limit?: number): Promise<Validation[]>;
+    /**
+     * List validations by a validator
+     */
+    listValidationsByValidator(validator: string, limit?: number): Promise<Validation[]>;
+    /**
+     * Get challenge by ID
+     */
+    getChallenge(id: number): Promise<Challenge | null>;
+    /**
+     * Get challenges for a validation
+     */
+    getChallengesForValidation(validationId: number): Promise<Challenge[]>;
+    /**
+     * Register as a validator
+     */
+    registerValidator(method: string, specializations: string[]): Promise<TransactionResult>;
+    /**
+     * Update validator info
+     */
+    updateValidator(method: string, specializations: string[]): Promise<TransactionResult>;
+    /**
+     * Stake XPR as validator
+     */
+    stake(amount: string): Promise<TransactionResult>;
+    /**
+     * Submit validation
+     */
+    validate(data: SubmitValidationData): Promise<TransactionResult>;
+    /**
+     * Challenge a validation
+     */
+    challenge(validationId: number, reason: string, evidenceUri?: string): Promise<TransactionResult>;
+    /**
+     * Stake for a challenge
+     */
+    stakeChallengeDeposit(challengeId: number, amount: string): Promise<TransactionResult>;
+    /**
+     * Set validator active status
+     */
+    setValidatorStatus(active: boolean): Promise<TransactionResult>;
+    /**
+     * Request to unstake validator funds (time-delayed).
+     * Must be deactivated and have no pending challenges first.
+     *
+     * @param amount - Amount to unstake in smallest units
+     */
+    unstake(amount: number): Promise<TransactionResult>;
+    /**
+     * Withdraw unstaked validator funds (after delay period)
+     *
+     * @param unstakeId - The ID of the unstake request to withdraw
+     */
+    withdraw(unstakeId: number): Promise<TransactionResult>;
+    /**
+     * Cancel an unfunded challenge (within grace period or after deadline)
+     */
+    cancelChallenge(challengeId: number): Promise<TransactionResult>;
+    /**
+     * Resolve a validation challenge (owner only)
+     */
+    resolve(challengeId: number, upheld: boolean, resolutionNotes: string): Promise<TransactionResult>;
+    /**
+     * Expire an unfunded challenge (permissionless cleanup)
+     */
+    expireUnfundedChallenge(challengeId: number): Promise<TransactionResult>;
+    /**
+     * Expire a funded challenge that was not resolved within timeout (permissionless cleanup)
+     */
+    expireFundedChallenge(challengeId: number): Promise<TransactionResult>;
+    /**
+     * Submit validation with fee in one transaction.
+     *
+     * @param data - Validation data
+     * @param amount - The validation fee (e.g., "1.0000 XPR")
+     */
+    validateWithFee(data: SubmitValidationData, amount: string): Promise<TransactionResult>;
+    /**
+     * Clean up old validations (permissionless)
+     */
+    cleanValidations(agent: string, maxAge: number, maxDelete: number): Promise<TransactionResult>;
+    /**
+     * Clean up resolved challenges (permissionless)
+     */
+    cleanChallenges(maxAge: number, maxDelete: number): Promise<TransactionResult>;
+    /**
+     * Get validation contract configuration
+     */
+    getConfig(): Promise<ValidationConfig>;
+    private requireSession;
+    private parseValidator;
+    private parseValidation;
+    private parseChallenge;
+}