@xpr-agents/sdk 0.1.0

package/dist/ValidationRegistry.js

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationRegistry = void 0;
+const utils_1 = require("./utils");
+const DEFAULT_CONTRACT = 'agentvalid';
+class ValidationRegistry {
+    constructor(rpc, session, contract) {
+        this.rpc = rpc;
+        this.session = session || null;
+        this.contract = contract || DEFAULT_CONTRACT;
+    }
+    // ============== READ OPERATIONS ==============
+    /**
+     * Get a validator by account
+     */
+    async getValidator(account) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'validators',
+            lower_bound: account,
+            upper_bound: account,
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseValidator(result.rows[0]);
+    }
+    /**
+     * List all validators
+     */
+    async listValidators(options = {}) {
+        const { limit = 100, active_only = true } = options;
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'validators',
+            limit,
+        });
+        let validators = result.rows.map((row) => this.parseValidator(row));
+        if (active_only) {
+            validators = validators.filter((v) => v.active);
+        }
+        if (options.min_stake !== undefined) {
+            validators = validators.filter((v) => v.stake >= options.min_stake);
+        }
+        if (options.min_accuracy !== undefined) {
+            validators = validators.filter((v) => v.accuracy_score >= options.min_accuracy);
+        }
+        if (options.specialization) {
+            validators = validators.filter((v) => v.specializations.includes(options.specialization));
+        }
+        return validators;
+    }
+    /**
+     * Get validation by ID
+     */
+    async getValidation(id) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'validations',
+            lower_bound: String(id),
+            upper_bound: String(id),
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseValidation(result.rows[0]);
+    }
+    /**
+     * List validations for an agent
+     */
+    async listValidationsForAgent(agent, limit = 100) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'validations',
+            index_position: 2,
+            key_type: 'i64',
+            limit,
+        });
+        return result.rows
+            .filter((row) => row.agent === agent)
+            .map((row) => this.parseValidation(row));
+    }
+    /**
+     * List validations by a validator
+     */
+    async listValidationsByValidator(validator, limit = 100) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'validations',
+            index_position: 3,
+            key_type: 'i64',
+            limit,
+        });
+        return result.rows
+            .filter((row) => row.validator === validator)
+            .map((row) => this.parseValidation(row));
+    }
+    /**
+     * Get challenge by ID
+     */
+    async getChallenge(id) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'challenges',
+            lower_bound: String(id),
+            upper_bound: String(id),
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseChallenge(result.rows[0]);
+    }
+    /**
+     * Get challenges for a validation
+     */
+    async getChallengesForValidation(validationId) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'challenges',
+            index_position: 2,
+            key_type: 'i64',
+            limit: 100,
+        });
+        return result.rows
+            .filter((row) => row.validation_id === String(validationId))
+            .map((row) => this.parseChallenge(row));
+    }
+    // ============== WRITE OPERATIONS ==============
+    /**
+     * Register as a validator
+     */
+    async registerValidator(method, specializations) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'regval',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        method,
+                        specializations: JSON.stringify(specializations),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Update validator info
+     */
+    async updateValidator(method, specializations) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'updateval',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        method,
+                        specializations: JSON.stringify(specializations),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Stake XPR as validator
+     */
+    async stake(amount) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: 'eosio.token',
+                    name: 'transfer',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        from: this.session.auth.actor,
+                        to: this.contract,
+                        quantity: amount,
+                        memo: 'stake',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Submit validation
+     */
+    async validate(data) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'validate',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        validator: this.session.auth.actor,
+                        agent: data.agent,
+                        job_hash: data.job_hash,
+                        result: (0, utils_1.validationResultToNumber)(data.result),
+                        confidence: data.confidence,
+                        evidence_uri: data.evidence_uri || '',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Challenge a validation
+     */
+    async challenge(validationId, reason, evidenceUri) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'challenge',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        challenger: this.session.auth.actor,
+                        validation_id: validationId,
+                        reason,
+                        evidence_uri: evidenceUri || '',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Stake for a challenge
+     */
+    async stakeChallengeDeposit(challengeId, amount) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: 'eosio.token',
+                    name: 'transfer',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        from: this.session.auth.actor,
+                        to: this.contract,
+                        quantity: amount,
+                        memo: `challenge:${challengeId}`,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Set validator active status
+     */
+    async setValidatorStatus(active) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'setvalstat',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        active,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Request to unstake validator funds (time-delayed).
+     * Must be deactivated and have no pending challenges first.
+     *
+     * @param amount - Amount to unstake in smallest units
+     */
+    async unstake(amount) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'unstake',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        amount,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Withdraw unstaked validator funds (after delay period)
+     *
+     * @param unstakeId - The ID of the unstake request to withdraw
+     */
+    async withdraw(unstakeId) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'withdraw',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        unstake_id: unstakeId,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Cancel an unfunded challenge (within grace period or after deadline)
+     */
+    async cancelChallenge(challengeId) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'cancelchal',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        challenger: this.session.auth.actor,
+                        challenge_id: challengeId,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Resolve a validation challenge (owner only)
+     */
+    async resolve(challengeId, 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,
+                        challenge_id: challengeId,
+                        upheld,
+                        resolution_notes: resolutionNotes,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Expire an unfunded challenge (permissionless cleanup)
+     */
+    async expireUnfundedChallenge(challengeId) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'expireunfund',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        challenge_id: challengeId,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Expire a funded challenge that was not resolved within timeout (permissionless cleanup)
+     */
+    async expireFundedChallenge(challengeId) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'expirefunded',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        challenge_id: challengeId,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Submit validation with fee in one transaction.
+     *
+     * @param data - Validation data
+     * @param amount - The validation fee (e.g., "1.0000 XPR")
+     */
+    async validateWithFee(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: `valfee:${actor}`,
+                    },
+                },
+                {
+                    account: this.contract,
+                    name: 'validate',
+                    authorization: [{
+                            actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        validator: actor,
+                        agent: data.agent,
+                        job_hash: data.job_hash,
+                        result: (0, utils_1.validationResultToNumber)(data.result),
+                        confidence: data.confidence,
+                        evidence_uri: data.evidence_uri || '',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Clean up old validations (permissionless)
+     */
+    async cleanValidations(agent, maxAge, maxDelete) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [{
+                    account: this.contract,
+                    name: 'cleanvals',
+                    authorization: [{
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        agent,
+                        max_age: maxAge,
+                        max_delete: maxDelete,
+                    },
+                }],
+        });
+    }
+    /**
+     * Clean up resolved challenges (permissionless)
+     */
+    async cleanChallenges(maxAge, maxDelete) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [{
+                    account: this.contract,
+                    name: 'cleanchals',
+                    authorization: [{
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        max_age: maxAge,
+                        max_delete: maxDelete,
+                    },
+                }],
+        });
+    }
+    /**
+     * Get validation 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_stake: (0, utils_1.safeParseInt)(row.min_stake),
+            challenge_stake: (0, utils_1.safeParseInt)(row.challenge_stake),
+            unstake_delay: (0, utils_1.safeParseInt)(row.unstake_delay),
+            challenge_window: (0, utils_1.safeParseInt)(row.challenge_window),
+            slash_percent: (0, utils_1.safeParseInt)(row.slash_percent),
+            dispute_period: (0, utils_1.safeParseInt)(row.dispute_period),
+            funded_challenge_timeout: (0, utils_1.safeParseInt)(row.funded_challenge_timeout),
+            paused: row.paused === 1,
+            validation_fee: (0, utils_1.safeParseInt)(row.validation_fee),
+        };
+    }
+    // ============== HELPERS ==============
+    requireSession() {
+        if (!this.session) {
+            throw new Error('Session required for write operations');
+        }
+    }
+    parseValidator(raw) {
+        return {
+            account: raw.account,
+            stake: (0, utils_1.safeParseInt)(raw.stake),
+            method: raw.method,
+            specializations: (0, utils_1.parseSpecializations)(raw.specializations),
+            total_validations: (0, utils_1.safeParseInt)(raw.total_validations),
+            incorrect_validations: (0, utils_1.safeParseInt)(raw.incorrect_validations),
+            accuracy_score: (0, utils_1.safeParseInt)(raw.accuracy_score),
+            pending_challenges: (0, utils_1.safeParseInt)(raw.pending_challenges),
+            registered_at: (0, utils_1.safeParseInt)(raw.registered_at),
+            active: raw.active === 1,
+        };
+    }
+    parseValidation(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            validator: raw.validator,
+            agent: raw.agent,
+            job_hash: raw.job_hash,
+            result: (0, utils_1.validationResultFromNumber)(raw.result),
+            confidence: raw.confidence,
+            evidence_uri: raw.evidence_uri,
+            challenged: raw.challenged === 1,
+            timestamp: (0, utils_1.safeParseInt)(raw.timestamp),
+        };
+    }
+    parseChallenge(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            validation_id: (0, utils_1.safeParseInt)(raw.validation_id),
+            challenger: raw.challenger,
+            reason: raw.reason,
+            evidence_uri: raw.evidence_uri,
+            stake: (0, utils_1.safeParseInt)(raw.stake),
+            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),
+            funding_deadline: (0, utils_1.safeParseInt)(raw.funding_deadline),
+            funded_at: (0, utils_1.safeParseInt)(raw.funded_at),
+        };
+    }
+}
+exports.ValidationRegistry = ValidationRegistry;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ValidationRegistry.js","sourceRoot":"","sources":["../src/ValidationRegistry.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Validator,\n  ValidatorRaw,\n  Validation,\n  ValidationRaw,\n  ValidationConfig,\n  Challenge,\n  ValidatorListOptions,\n  SubmitValidationData,\n  TransactionResult,\n  JsonRpc,\n  ProtonSession,\n  ValidationResult,\n} from './types';\nimport {\n  parseSpecializations,\n  validationResultFromNumber,\n  validationResultToNumber,\n  disputeStatusFromNumber,\n  safeParseInt,\n} from './utils';\n\nconst DEFAULT_CONTRACT = 'agentvalid';\n\nexport class ValidationRegistry {\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 a validator by account\n   */\n  async getValidator(account: string): Promise<Validator | null> {\n    const result = await this.rpc.get_table_rows<ValidatorRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'validators',\n      lower_bound: account,\n      upper_bound: account,\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) return null;\n    return this.parseValidator(result.rows[0]);\n  }\n\n  /**\n   * List all validators\n   */\n  async listValidators(options: ValidatorListOptions = {}): Promise<Validator[]> {\n    const { limit = 100, active_only = true } = options;\n\n    const result = await this.rpc.get_table_rows<ValidatorRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'validators',\n      limit,\n    });\n\n    let validators = result.rows.map((row) => this.parseValidator(row));\n\n    if (active_only) {\n      validators = validators.filter((v) => v.active);\n    }\n\n    if (options.min_stake !== undefined) {\n      validators = validators.filter((v) => v.stake >= options.min_stake!);\n    }\n\n    if (options.min_accuracy !== undefined) {\n      validators = validators.filter((v) => v.accuracy_score >= options.min_accuracy!);\n    }\n\n    if (options.specialization) {\n      validators = validators.filter((v) =>\n        v.specializations.includes(options.specialization!)\n      );\n    }\n\n    return validators;\n  }\n\n  /**\n   * Get validation by ID\n   */\n  async getValidation(id: number): Promise<Validation | null> {\n    const result = await this.rpc.get_table_rows<ValidationRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'validations',\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.parseValidation(result.rows[0]);\n  }\n\n  /**\n   * List validations for an agent\n   */\n  async listValidationsForAgent(agent: string, limit: number = 100): Promise<Validation[]> {\n    const result = await this.rpc.get_table_rows<ValidationRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'validations',\n      index_position: 2,\n      key_type: 'i64',\n      limit,\n    });\n\n    return result.rows\n      .filter((row) => row.agent === agent)\n      .map((row) => this.parseValidation(row));\n  }\n\n  /**\n   * List validations by a validator\n   */\n  async listValidationsByValidator(\n    validator: string,\n    limit: number = 100\n  ): Promise<Validation[]> {\n    const result = await this.rpc.get_table_rows<ValidationRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'validations',\n      index_position: 3,\n      key_type: 'i64',\n      limit,\n    });\n\n    return result.rows\n      .filter((row) => row.validator === validator)\n      .map((row) => this.parseValidation(row));\n  }\n\n  /**\n   * Get challenge by ID\n   */\n  async getChallenge(id: number): Promise<Challenge | null> {\n    const result = await this.rpc.get_table_rows<{\n      id: string;\n      validation_id: string;\n      challenger: string;\n      reason: string;\n      evidence_uri: string;\n      stake: string;\n      status: number;\n      resolver: string;\n      resolution_notes: string;\n      created_at: string;\n      resolved_at: string;\n      funding_deadline: string;\n      funded_at: string;\n    }>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'challenges',\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.parseChallenge(result.rows[0]);\n  }\n\n  /**\n   * Get challenges for a validation\n   */\n  async getChallengesForValidation(validationId: number): Promise<Challenge[]> {\n    const result = await this.rpc.get_table_rows<{\n      id: string;\n      validation_id: string;\n      challenger: string;\n      reason: string;\n      evidence_uri: string;\n      stake: string;\n      status: number;\n      resolver: string;\n      resolution_notes: string;\n      created_at: string;\n      resolved_at: string;\n      funding_deadline: string;\n      funded_at: string;\n    }>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'challenges',\n      index_position: 2,\n      key_type: 'i64',\n      limit: 100,\n    });\n\n    return result.rows\n      .filter((row) => row.validation_id === String(validationId))\n      .map((row) => this.parseChallenge(row));\n  }\n\n  // ============== WRITE OPERATIONS ==============\n\n  /**\n   * Register as a validator\n   */\n  async registerValidator(\n    method: string,\n    specializations: string[]\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'regval',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            account: this.session!.auth.actor,\n            method,\n            specializations: JSON.stringify(specializations),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Update validator info\n   */\n  async updateValidator(\n    method: string,\n    specializations: string[]\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'updateval',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            account: this.session!.auth.actor,\n            method,\n            specializations: JSON.stringify(specializations),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Stake XPR as validator\n   */\n  async stake(amount: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: 'eosio.token',\n          name: 'transfer',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            from: this.session!.auth.actor,\n            to: this.contract,\n            quantity: amount,\n            memo: 'stake',\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Submit validation\n   */\n  async validate(data: SubmitValidationData): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'validate',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            validator: this.session!.auth.actor,\n            agent: data.agent,\n            job_hash: data.job_hash,\n            result: validationResultToNumber(data.result),\n            confidence: data.confidence,\n            evidence_uri: data.evidence_uri || '',\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Challenge a validation\n   */\n  async challenge(\n    validationId: 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: 'challenge',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            challenger: this.session!.auth.actor,\n            validation_id: validationId,\n            reason,\n            evidence_uri: evidenceUri || '',\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Stake for a challenge\n   */\n  async stakeChallengeDeposit(\n    challengeId: number,\n    amount: string\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: 'eosio.token',\n          name: 'transfer',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            from: this.session!.auth.actor,\n            to: this.contract,\n            quantity: amount,\n            memo: `challenge:${challengeId}`,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Set validator active status\n   */\n  async setValidatorStatus(active: boolean): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'setvalstat',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            account: this.session!.auth.actor,\n            active,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Request to unstake validator funds (time-delayed).\n   * Must be deactivated and have no pending challenges first.\n   *\n   * @param amount - Amount to unstake in smallest units\n   */\n  async unstake(amount: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'unstake',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            account: this.session!.auth.actor,\n            amount,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Withdraw unstaked validator funds (after delay period)\n   *\n   * @param unstakeId - The ID of the unstake request to withdraw\n   */\n  async withdraw(unstakeId: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'withdraw',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            account: this.session!.auth.actor,\n            unstake_id: unstakeId,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Cancel an unfunded challenge (within grace period or after deadline)\n   */\n  async cancelChallenge(challengeId: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'cancelchal',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            challenger: this.session!.auth.actor,\n            challenge_id: challengeId,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Resolve a validation challenge (owner only)\n   */\n  async resolve(\n    challengeId: 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            challenge_id: challengeId,\n            upheld,\n            resolution_notes: resolutionNotes,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Expire an unfunded challenge (permissionless cleanup)\n   */\n  async expireUnfundedChallenge(challengeId: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'expireunfund',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            challenge_id: challengeId,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Expire a funded challenge that was not resolved within timeout (permissionless cleanup)\n   */\n  async expireFundedChallenge(challengeId: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'expirefunded',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            challenge_id: challengeId,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Submit validation with fee in one transaction.\n   *\n   * @param data - Validation data\n   * @param amount - The validation fee (e.g., \"1.0000 XPR\")\n   */\n  async validateWithFee(data: SubmitValidationData, 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: `valfee:${actor}`,\n          },\n        },\n        {\n          account: this.contract,\n          name: 'validate',\n          authorization: [{\n            actor,\n            permission: this.session!.auth.permission,\n          }],\n          data: {\n            validator: actor,\n            agent: data.agent,\n            job_hash: data.job_hash,\n            result: validationResultToNumber(data.result),\n            confidence: data.confidence,\n            evidence_uri: data.evidence_uri || '',\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Clean up old validations (permissionless)\n   */\n  async cleanValidations(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: 'cleanvals',\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 challenges (permissionless)\n   */\n  async cleanChallenges(maxAge: number, maxDelete: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [{\n        account: this.contract,\n        name: 'cleanchals',\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 validation contract configuration\n   */\n  async getConfig(): Promise<ValidationConfig> {\n    const result = await this.rpc.get_table_rows<{\n      owner: string;\n      core_contract: string;\n      min_stake: string;\n      challenge_stake: string;\n      unstake_delay: string;\n      challenge_window: string;\n      slash_percent: string;\n      dispute_period: string;\n      funded_challenge_timeout: string;\n      paused: number;\n      validation_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_stake: safeParseInt(row.min_stake),\n      challenge_stake: safeParseInt(row.challenge_stake),\n      unstake_delay: safeParseInt(row.unstake_delay),\n      challenge_window: safeParseInt(row.challenge_window),\n      slash_percent: safeParseInt(row.slash_percent),\n      dispute_period: safeParseInt(row.dispute_period),\n      funded_challenge_timeout: safeParseInt(row.funded_challenge_timeout),\n      paused: row.paused === 1,\n      validation_fee: safeParseInt(row.validation_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 parseValidator(raw: ValidatorRaw): Validator {\n    return {\n      account: raw.account,\n      stake: safeParseInt(raw.stake),\n      method: raw.method,\n      specializations: parseSpecializations(raw.specializations),\n      total_validations: safeParseInt(raw.total_validations),\n      incorrect_validations: safeParseInt(raw.incorrect_validations),\n      accuracy_score: safeParseInt(raw.accuracy_score),\n      pending_challenges: safeParseInt(raw.pending_challenges),\n      registered_at: safeParseInt(raw.registered_at),\n      active: raw.active === 1,\n    };\n  }\n\n  private parseValidation(raw: ValidationRaw): Validation {\n    return {\n      id: safeParseInt(raw.id),\n      validator: raw.validator,\n      agent: raw.agent,\n      job_hash: raw.job_hash,\n      result: validationResultFromNumber(raw.result),\n      confidence: raw.confidence,\n      evidence_uri: raw.evidence_uri,\n      challenged: raw.challenged === 1,\n      timestamp: safeParseInt(raw.timestamp),\n    };\n  }\n\n  private parseChallenge(raw: {\n    id: string;\n    validation_id: string;\n    challenger: string;\n    reason: string;\n    evidence_uri: string;\n    stake: string;\n    status: number;\n    resolver: string;\n    resolution_notes: string;\n    created_at: string;\n    resolved_at: string;\n    funding_deadline: string;\n    funded_at: string;\n  }): Challenge {\n    return {\n      id: safeParseInt(raw.id),\n      validation_id: safeParseInt(raw.validation_id),\n      challenger: raw.challenger,\n      reason: raw.reason,\n      evidence_uri: raw.evidence_uri,\n      stake: safeParseInt(raw.stake),\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      funding_deadline: safeParseInt(raw.funding_deadline),\n      funded_at: safeParseInt(raw.funded_at),\n    };\n  }\n}\n"]}