@xpr-agents/sdk 0.1.0

package/dist/AgentRegistry.js

@@ -0,0 +1,892 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRegistry = void 0;
+const utils_1 = require("./utils");
+const DEFAULT_CONTRACT = 'agentcore';
+// Valid protocols for agent endpoints
+const VALID_PROTOCOLS = ['http', 'https', 'grpc', 'websocket', 'mqtt', 'wss'];
+// Valid endpoint URL prefixes
+const VALID_ENDPOINT_PREFIXES = ['http://', 'https://', 'grpc://', 'wss://'];
+/**
+ * Validates agent registration/update data before sending to the blockchain.
+ * Throws descriptive errors for invalid input.
+ *
+ * CRITICAL FIX: Validates TRIMMED length to prevent whitespace padding bypass.
+ */
+function validateAgentData(data) {
+    // Validate name: 1-64 characters after trimming, non-empty
+    if (data.name !== undefined) {
+        if (typeof data.name !== 'string') {
+            throw new Error('Name must be a string');
+        }
+        const trimmedName = data.name.trim();
+        // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass
+        if (trimmedName.length < 1 || trimmedName.length > 64) {
+            throw new Error('Name must be 1-64 characters (after trimming whitespace)');
+        }
+    }
+    // Validate description: 1-256 characters after trimming, non-empty
+    if (data.description !== undefined) {
+        if (typeof data.description !== 'string') {
+            throw new Error('Description must be a string');
+        }
+        const trimmedDesc = data.description.trim();
+        // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass
+        if (trimmedDesc.length < 1 || trimmedDesc.length > 256) {
+            throw new Error('Description must be 1-256 characters (after trimming whitespace)');
+        }
+    }
+    // Validate endpoint: 1-256 characters after trimming, must start with valid protocol prefix
+    if (data.endpoint !== undefined) {
+        if (typeof data.endpoint !== 'string') {
+            throw new Error('Endpoint must be a string');
+        }
+        const trimmedEndpoint = data.endpoint.trim();
+        // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass
+        if (trimmedEndpoint.length < 1 || trimmedEndpoint.length > 256) {
+            throw new Error('Endpoint must be 1-256 characters and start with http://, https://, grpc://, or wss://');
+        }
+        const hasValidPrefix = VALID_ENDPOINT_PREFIXES.some(prefix => trimmedEndpoint.toLowerCase().startsWith(prefix));
+        if (!hasValidPrefix) {
+            throw new Error('Endpoint must be 1-256 characters and start with http://, https://, grpc://, or wss://');
+        }
+    }
+    // Validate protocol: must be one of the valid protocols (case-insensitive)
+    if (data.protocol !== undefined) {
+        const normalizedProtocol = data.protocol.toLowerCase();
+        if (!VALID_PROTOCOLS.includes(normalizedProtocol)) {
+            throw new Error(`Protocol must be one of: ${VALID_PROTOCOLS.join(', ')}`);
+        }
+    }
+    // Validate capabilities: array, when stringified must be <= 2048 characters
+    if (data.capabilities !== undefined) {
+        if (!Array.isArray(data.capabilities)) {
+            throw new Error('Capabilities must be an array with stringified length <= 2048 characters');
+        }
+        const stringified = JSON.stringify(data.capabilities);
+        if (stringified.length > 2048) {
+            throw new Error('Capabilities must be an array with stringified length <= 2048 characters');
+        }
+    }
+}
+class AgentRegistry {
+    constructor(rpc, session, contract) {
+        this.rpc = rpc;
+        this.session = session || null;
+        this.contract = contract || DEFAULT_CONTRACT;
+    }
+    // ============== READ OPERATIONS ==============
+    /**
+     * Get a single agent by account name
+     */
+    async getAgent(account) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'agents',
+            lower_bound: account,
+            upper_bound: account,
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parseAgent(result.rows[0]);
+    }
+    /**
+     * List all agents with optional filters and pagination
+     * @returns PaginatedResult with items, hasMore flag, and nextCursor for pagination
+     */
+    async listAgents(options = {}) {
+        const { limit = 100, cursor, active_only = true } = options;
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'agents',
+            lower_bound: cursor,
+            limit: limit + 1, // Fetch one extra to check if there are more
+        });
+        const hasMore = result.rows.length > limit;
+        const rows = hasMore ? result.rows.slice(0, limit) : result.rows;
+        let agents = rows.map((row) => this.parseAgent(row));
+        // Apply filters after fetching
+        if (active_only) {
+            agents = agents.filter((a) => a.active);
+        }
+        // Note: Agents use system staking (eosio::voters), not contract-managed staking
+        // To filter by stake, query system staking separately
+        // Get next cursor from the last row if there are more
+        const nextCursor = hasMore && rows.length > 0
+            ? rows[rows.length - 1].account
+            : undefined;
+        return {
+            items: agents,
+            hasMore,
+            nextCursor,
+        };
+    }
+    /**
+     * Iterate through all agents with automatic pagination
+     */
+    async *listAgentsIterator(options = {}) {
+        let cursor;
+        do {
+            const result = await this.listAgents({ ...options, cursor });
+            for (const agent of result.items) {
+                yield agent;
+            }
+            cursor = result.nextCursor;
+        } while (cursor);
+    }
+    /**
+     * Get a plugin by ID
+     */
+    async getPlugin(id) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'plugins',
+            lower_bound: String(id),
+            upper_bound: String(id),
+            limit: 1,
+        });
+        if (result.rows.length === 0)
+            return null;
+        return this.parsePlugin(result.rows[0]);
+    }
+    /**
+     * List all plugins
+     */
+    async listPlugins(category) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'plugins',
+            limit: 1000,
+        });
+        let plugins = result.rows.map((row) => this.parsePlugin(row));
+        if (category) {
+            plugins = plugins.filter((p) => p.category === category);
+        }
+        return plugins;
+    }
+    /**
+     * Get plugins assigned to an agent
+     */
+    async getAgentPlugins(account) {
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'agentplugs',
+            index_position: 2,
+            key_type: 'name',
+            lower_bound: account,
+            upper_bound: account,
+            limit: 100,
+        });
+        return result.rows.map((row) => this.parseAgentPlugin(row));
+    }
+    // Note: Agents use system staking via eosio::voters table, not contract-managed staking
+    // There is no unstakes table in agentcore - agents stake/unstake via system resources
+    // Use agentcore::getagentinfo action to query an agent's system stake
+    /**
+     * Get trust score for an agent (0-100)
+     * Combines KYC level, stake, reputation, and longevity
+     */
+    async getTrustScore(account) {
+        // Get agent
+        const agent = await this.getAgent(account);
+        if (!agent)
+            return null;
+        // Get agent score from agentfeed
+        const feedContract = 'agentfeed'; // Default feed contract
+        const scoreResult = await this.rpc.get_table_rows({
+            json: true,
+            code: feedContract,
+            scope: feedContract,
+            table: 'agentscores',
+            lower_bound: account,
+            upper_bound: account,
+            limit: 1,
+        });
+        const agentScore = scoreResult.rows.length > 0
+            ? {
+                agent: scoreResult.rows[0].agent,
+                total_score: (0, utils_1.safeParseInt)(scoreResult.rows[0].total_score),
+                total_weight: (0, utils_1.safeParseInt)(scoreResult.rows[0].total_weight),
+                feedback_count: (0, utils_1.safeParseInt)(scoreResult.rows[0].feedback_count),
+                avg_score: (0, utils_1.safeParseInt)(scoreResult.rows[0].avg_score),
+                last_updated: (0, utils_1.safeParseInt)(scoreResult.rows[0].last_updated),
+            }
+            : null;
+        // Get KYC level from the OWNER (not the agent)
+        // This is the key insight: agents inherit trust from their human sponsor
+        let kycLevel = 0;
+        if (agent.owner) {
+            const kycResult = await this.rpc.get_table_rows({
+                json: true,
+                code: 'eosio.proton',
+                scope: 'eosio.proton',
+                table: 'usersinfo',
+                lower_bound: agent.owner,
+                upper_bound: agent.owner,
+                limit: 1,
+            });
+            if (kycResult.rows.length > 0 && kycResult.rows[0].kyc?.length > 0) {
+                // Find the highest KYC level, handling various formats:
+                // - number: 3
+                // - string number: "3"
+                // - provider:level: "metallicus:3"
+                // - comma-separated multi-provider: "provA:3,provB:1"
+                const levels = [];
+                for (const k of kycResult.rows[0].kyc) {
+                    if (typeof k.kyc_level === 'number') {
+                        levels.push(k.kyc_level);
+                    }
+                    else {
+                        const levelStr = String(k.kyc_level);
+                        // Handle comma-separated multi-provider strings (e.g., "provA:3,provB:1")
+                        const providers = levelStr.split(',');
+                        for (const provider of providers) {
+                            const trimmed = provider.trim();
+                            if (trimmed.includes(':')) {
+                                // "provider:level" format - take the level part
+                                const parts = trimmed.split(':');
+                                const level = parseInt(parts[parts.length - 1], 10);
+                                if (!isNaN(level))
+                                    levels.push(level);
+                            }
+                            else {
+                                // Plain number string
+                                const level = parseInt(trimmed, 10);
+                                if (!isNaN(level))
+                                    levels.push(level);
+                            }
+                        }
+                    }
+                }
+                // P2 FIX: Safe max - fallback to 0 if no valid levels found
+                // Math.max(...[]) returns -Infinity, which would poison trust scores
+                kycLevel = levels.length > 0 ? Math.max(...levels) : 0;
+            }
+        }
+        // Get system stake from eosio::voters
+        const votersResult = await this.rpc.get_table_rows({
+            json: true,
+            code: 'eosio',
+            scope: 'eosio',
+            table: 'voters',
+            lower_bound: account,
+            upper_bound: account,
+            limit: 1,
+        });
+        let stakeAmount = 0;
+        if (votersResult.rows.length > 0 && votersResult.rows[0].staked) {
+            stakeAmount = (0, utils_1.safeParseInt)(votersResult.rows[0].staked);
+        }
+        return (0, utils_1.calculateTrustScore)(agent, agentScore, kycLevel, stakeAmount);
+    }
+    /**
+     * Get 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,
+            min_stake: (0, utils_1.safeParseInt)(row.min_stake),
+            registration_fee: (0, utils_1.safeParseInt)(row.registration_fee),
+            claim_fee: (0, utils_1.safeParseInt)(row.claim_fee),
+            feed_contract: row.feed_contract,
+            valid_contract: row.valid_contract,
+            escrow_contract: row.escrow_contract,
+            paused: row.paused === 1,
+        };
+    }
+    // ============== WRITE OPERATIONS ==============
+    /**
+     * Register a new agent
+     */
+    async register(data) {
+        this.requireSession();
+        // Validate input before sending to blockchain
+        validateAgentData({
+            name: data.name,
+            description: data.description,
+            endpoint: data.endpoint,
+            protocol: data.protocol,
+            capabilities: data.capabilities,
+        });
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'register',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        name: data.name,
+                        description: data.description,
+                        endpoint: data.endpoint,
+                        protocol: data.protocol,
+                        capabilities: JSON.stringify(data.capabilities),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Register a new agent with registration fee in one transaction.
+     * Sends the fee deposit and registers in a single tx.
+     *
+     * @param data - Agent registration data
+     * @param amount - The registration fee (e.g., "1.0000 XPR")
+     */
+    async registerWithFee(data, amount) {
+        this.requireSession();
+        validateAgentData({
+            name: data.name,
+            description: data.description,
+            endpoint: data.endpoint,
+            protocol: data.protocol,
+            capabilities: data.capabilities,
+        });
+        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: `regfee:${actor}`,
+                    },
+                },
+                {
+                    account: this.contract,
+                    name: 'register',
+                    authorization: [{
+                            actor,
+                            permission: this.session.auth.permission,
+                        }],
+                    data: {
+                        account: actor,
+                        name: data.name,
+                        description: data.description,
+                        endpoint: data.endpoint,
+                        protocol: data.protocol,
+                        capabilities: JSON.stringify(data.capabilities),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Update agent metadata
+     */
+    async update(data) {
+        this.requireSession();
+        // Validate input before sending to blockchain
+        // Only validate fields that are provided (UpdateAgentData has optional fields)
+        validateAgentData({
+            name: data.name,
+            description: data.description,
+            endpoint: data.endpoint,
+            protocol: data.protocol,
+            capabilities: data.capabilities,
+        });
+        // Get current agent data to merge with updates
+        const current = await this.getAgent(this.session.auth.actor);
+        if (!current) {
+            throw new Error('Agent not found');
+        }
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'update',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        name: data.name ?? current.name,
+                        description: data.description ?? current.description,
+                        endpoint: data.endpoint ?? current.endpoint,
+                        protocol: data.protocol ?? current.protocol,
+                        capabilities: JSON.stringify(data.capabilities ?? current.capabilities),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Set agent active status
+     */
+    async setStatus(active) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'setstatus',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        account: this.session.auth.actor,
+                        active,
+                    },
+                },
+            ],
+        });
+    }
+    // ============== SYSTEM STAKING NOTE ==============
+    // Agents use XPR Network's native system staking (eosio::voters table)
+    // instead of contract-managed staking. To stake/unstake:
+    //
+    // 1. Stake: Use system stake action or resources.xprnetwork.org
+    // 2. Unstake: Use system unstake action
+    // 3. Query stake: Call agentcore::getagentinfo action or query eosio::voters table
+    //
+    // This design leverages the existing staking infrastructure and allows
+    // agents to earn staking rewards while meeting minimum stake requirements.
+    /**
+     * Add plugin to agent
+     */
+    async addPlugin(pluginId, config = {}) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'addplugin',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent: this.session.auth.actor,
+                        plugin_id: pluginId,
+                        pluginConfig: JSON.stringify(config),
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Remove plugin from agent
+     */
+    async removePlugin(agentPluginId) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'rmplugin',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent: this.session.auth.actor,
+                        agentplugin_id: agentPluginId,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Register a new plugin
+     */
+    async registerPlugin(name, version, contract, action, schema, category) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'regplugin',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        author: this.session.auth.actor,
+                        name,
+                        version,
+                        contract,
+                        action,
+                        schema: JSON.stringify(schema),
+                        category,
+                    },
+                },
+            ],
+        });
+    }
+    // ============== OWNERSHIP ==============
+    /**
+     * Step 1: Agent approves a human to claim them.
+     * This is called by the AGENT to give consent.
+     *
+     * @param newOwner - The KYC'd human being approved to claim
+     */
+    async approveClaim(newOwner) {
+        this.requireSession();
+        // The session holder IS the agent giving consent
+        const agent = this.session.auth.actor;
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'approveclaim',
+                    authorization: [
+                        {
+                            actor: agent,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                        new_owner: newOwner,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Step 2: Human completes the claim after agent approval.
+     * Agent must have called approveClaim first.
+     *
+     * IMPORTANT: Before calling this, you must:
+     * 1. Have the agent call approveClaim(yourAccount)
+     * 2. Send the claim fee with memo "claim:agentname:yourname"
+     *
+     * @param agent - The agent account to claim
+     */
+    async claim(agent) {
+        this.requireSession();
+        const owner = this.session.auth.actor;
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'claim',
+                    authorization: [
+                        {
+                            actor: owner,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Send claim fee and complete the claim in one transaction.
+     * Agent must have already called approveClaim first.
+     *
+     * @param agent - The agent account to claim
+     * @param amount - The claim fee amount (e.g., "1.0000 XPR")
+     */
+    async claimWithFee(agent, amount) {
+        this.requireSession();
+        const owner = this.session.auth.actor;
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: 'eosio.token',
+                    name: 'transfer',
+                    authorization: [
+                        {
+                            actor: owner,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        from: owner,
+                        to: this.contract,
+                        quantity: amount,
+                        memo: `claim:${agent}:${owner}`,
+                    },
+                },
+                {
+                    account: this.contract,
+                    name: 'claim',
+                    authorization: [
+                        {
+                            actor: owner,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Cancel a pending claim approval.
+     * Only the agent can cancel their own approval.
+     * Any deposit will be refunded to the payer.
+     *
+     * NOTE: The session holder must be the agent account.
+     */
+    async cancelClaim() {
+        this.requireSession();
+        const agent = this.session.auth.actor;
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'cancelclaim',
+                    authorization: [
+                        {
+                            actor: agent,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Transfer ownership of an agent to a new owner.
+     *
+     * IMPORTANT: The contract requires THREE signatures:
+     * 1. Current owner (must authorize)
+     * 2. New owner (must authorize)
+     * 3. Agent itself (must consent to the transfer)
+     *
+     * This method includes only the session holder's authorization.
+     * It will FAIL unless the session holder controls all three accounts,
+     * which is rare in practice.
+     *
+     * For most use cases, use `buildTransferProposal()` to create a multi-sig
+     * proposal that can be signed by all three parties.
+     *
+     * @param agent - The agent account
+     * @param newOwner - The new owner (must have KYC)
+     * @throws Will fail if session holder doesn't control all 3 required accounts
+     */
+    async transferOwnership(agent, newOwner) {
+        this.requireSession();
+        // P2 FIX: Warn about the three-signature requirement
+        console.warn('transferOwnership requires 3 signatures (current owner, new owner, agent). ' +
+            'This will fail unless session controls all accounts. Use buildTransferProposal() for multi-sig.');
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'transfer',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                        new_owner: newOwner,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Build a transfer ownership action for use in a multi-sig proposal.
+     * Returns the action data that can be used with msig.propose.
+     *
+     * The transfer requires signatures from:
+     * 1. Current owner
+     * 2. New owner
+     * 3. Agent itself
+     *
+     * @param agent - The agent account
+     * @param currentOwner - The current owner account
+     * @param newOwner - The new owner account (must have KYC)
+     * @returns Action data for multi-sig proposal
+     */
+    buildTransferProposal(agent, currentOwner, newOwner) {
+        return {
+            account: this.contract,
+            name: 'transfer',
+            authorization: [
+                { actor: currentOwner, permission: 'active' },
+                { actor: newOwner, permission: 'active' },
+                { actor: agent, permission: 'active' },
+            ],
+            data: {
+                agent,
+                new_owner: newOwner,
+            },
+        };
+    }
+    /**
+     * Release ownership of an agent.
+     * Only the current owner can release.
+     * Claim deposit is refunded to the owner.
+     *
+     * @param agent - The agent account to release
+     */
+    async release(agent) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'release',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Verify an agent's owner still has valid KYC.
+     * Anyone can call this to trigger re-verification.
+     *
+     * If the owner's KYC has dropped below level 1, the ownership
+     * is removed and the claim deposit is refunded to the former owner.
+     *
+     * This helps maintain trust score integrity by allowing community
+     * enforcement of KYC requirements.
+     *
+     * @param agent - The agent account to verify
+     */
+    async verifyClaim(agent) {
+        this.requireSession();
+        return this.session.link.transact({
+            actions: [
+                {
+                    account: this.contract,
+                    name: 'verifyclaim',
+                    authorization: [
+                        {
+                            actor: this.session.auth.actor,
+                            permission: this.session.auth.permission,
+                        },
+                    ],
+                    data: {
+                        agent,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Get agents owned by a specific account
+     */
+    async getAgentsByOwner(owner, limit = 100) {
+        // Use secondary index to query by owner
+        const result = await this.rpc.get_table_rows({
+            json: true,
+            code: this.contract,
+            scope: this.contract,
+            table: 'agents',
+            index_position: 2, // byOwner secondary index
+            key_type: 'name',
+            lower_bound: owner,
+            upper_bound: owner,
+            limit,
+        });
+        return result.rows.map((row) => this.parseAgent(row));
+    }
+    // ============== HELPERS ==============
+    requireSession() {
+        if (!this.session) {
+            throw new Error('Session required for write operations');
+        }
+    }
+    parseAgent(raw) {
+        return {
+            account: raw.account,
+            owner: raw.owner || null, // Empty string means no owner
+            pending_owner: raw.pending_owner || null,
+            name: raw.name,
+            description: raw.description,
+            endpoint: raw.endpoint,
+            protocol: raw.protocol,
+            capabilities: (0, utils_1.parseCapabilities)(raw.capabilities),
+            total_jobs: (0, utils_1.safeParseInt)(raw.total_jobs),
+            registered_at: (0, utils_1.safeParseInt)(raw.registered_at),
+            active: raw.active === 1,
+            claim_deposit: (0, utils_1.safeParseInt)(raw.claim_deposit),
+            deposit_payer: raw.deposit_payer || null,
+            // Note: stake is queried from system staking (eosio::voters), not stored here
+        };
+    }
+    parsePlugin(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            name: raw.name,
+            version: raw.version,
+            contract: raw.contract,
+            action: raw.action,
+            schema: (0, utils_1.safeJsonParse)(raw.schema, {}),
+            category: raw.category,
+            author: raw.author,
+            verified: raw.verified === 1,
+        };
+    }
+    parseAgentPlugin(raw) {
+        return {
+            id: (0, utils_1.safeParseInt)(raw.id),
+            agent: raw.agent,
+            plugin_id: (0, utils_1.safeParseInt)(raw.plugin_id),
+            config: (0, utils_1.safeJsonParse)(raw.config, {}),
+            enabled: raw.enabled === 1,
+        };
+    }
+}
+exports.AgentRegistry = AgentRegistry;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AgentRegistry.js","sourceRoot":"","sources":["../src/AgentRegistry.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Agent,\n  AgentRaw,\n  Plugin,\n  PluginRaw,\n  AgentPlugin,\n  AgentPluginRaw,\n  AgentCoreConfig,\n  AgentListOptions,\n  RegisterAgentData,\n  UpdateAgentData,\n  TransactionResult,\n  JsonRpc,\n  ProtonSession,\n  PluginCategory,\n  PaginatedResult,\n  TrustScore,\n  AgentScore,\n} from './types';\nimport { parseCapabilities, safeJsonParse, formatXpr, calculateTrustScore, safeParseInt } from './utils';\n\nconst DEFAULT_CONTRACT = 'agentcore';\n\n// Valid protocols for agent endpoints\nconst VALID_PROTOCOLS = ['http', 'https', 'grpc', 'websocket', 'mqtt', 'wss'] as const;\n\n// Valid endpoint URL prefixes\nconst VALID_ENDPOINT_PREFIXES = ['http://', 'https://', 'grpc://', 'wss://'];\n\n/**\n * Validates agent registration/update data before sending to the blockchain.\n * Throws descriptive errors for invalid input.\n *\n * CRITICAL FIX: Validates TRIMMED length to prevent whitespace padding bypass.\n */\nfunction validateAgentData(data: {\n  name?: string;\n  description?: string;\n  endpoint?: string;\n  protocol?: string;\n  capabilities?: string[];\n}): void {\n  // Validate name: 1-64 characters after trimming, non-empty\n  if (data.name !== undefined) {\n    if (typeof data.name !== 'string') {\n      throw new Error('Name must be a string');\n    }\n    const trimmedName = data.name.trim();\n    // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass\n    if (trimmedName.length < 1 || trimmedName.length > 64) {\n      throw new Error('Name must be 1-64 characters (after trimming whitespace)');\n    }\n  }\n\n  // Validate description: 1-256 characters after trimming, non-empty\n  if (data.description !== undefined) {\n    if (typeof data.description !== 'string') {\n      throw new Error('Description must be a string');\n    }\n    const trimmedDesc = data.description.trim();\n    // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass\n    if (trimmedDesc.length < 1 || trimmedDesc.length > 256) {\n      throw new Error('Description must be 1-256 characters (after trimming whitespace)');\n    }\n  }\n\n  // Validate endpoint: 1-256 characters after trimming, must start with valid protocol prefix\n  if (data.endpoint !== undefined) {\n    if (typeof data.endpoint !== 'string') {\n      throw new Error('Endpoint must be a string');\n    }\n    const trimmedEndpoint = data.endpoint.trim();\n    // CRITICAL FIX: Check trimmed length to prevent whitespace padding bypass\n    if (trimmedEndpoint.length < 1 || trimmedEndpoint.length > 256) {\n      throw new Error('Endpoint must be 1-256 characters and start with http://, https://, grpc://, or wss://');\n    }\n    const hasValidPrefix = VALID_ENDPOINT_PREFIXES.some(prefix =>\n      trimmedEndpoint.toLowerCase().startsWith(prefix)\n    );\n    if (!hasValidPrefix) {\n      throw new Error('Endpoint must be 1-256 characters and start with http://, https://, grpc://, or wss://');\n    }\n  }\n\n  // Validate protocol: must be one of the valid protocols (case-insensitive)\n  if (data.protocol !== undefined) {\n    const normalizedProtocol = data.protocol.toLowerCase();\n    if (!VALID_PROTOCOLS.includes(normalizedProtocol as typeof VALID_PROTOCOLS[number])) {\n      throw new Error(`Protocol must be one of: ${VALID_PROTOCOLS.join(', ')}`);\n    }\n  }\n\n  // Validate capabilities: array, when stringified must be <= 2048 characters\n  if (data.capabilities !== undefined) {\n    if (!Array.isArray(data.capabilities)) {\n      throw new Error('Capabilities must be an array with stringified length <= 2048 characters');\n    }\n    const stringified = JSON.stringify(data.capabilities);\n    if (stringified.length > 2048) {\n      throw new Error('Capabilities must be an array with stringified length <= 2048 characters');\n    }\n  }\n}\n\nexport class AgentRegistry {\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 single agent by account name\n   */\n  async getAgent(account: string): Promise<Agent | null> {\n    const result = await this.rpc.get_table_rows<AgentRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'agents',\n      lower_bound: account,\n      upper_bound: account,\n      limit: 1,\n    });\n\n    if (result.rows.length === 0) return null;\n    return this.parseAgent(result.rows[0]);\n  }\n\n  /**\n   * List all agents with optional filters and pagination\n   * @returns PaginatedResult with items, hasMore flag, and nextCursor for pagination\n   */\n  async listAgents(options: AgentListOptions = {}): Promise<PaginatedResult<Agent>> {\n    const { limit = 100, cursor, active_only = true } = options;\n\n    const result = await this.rpc.get_table_rows<AgentRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'agents',\n      lower_bound: cursor,\n      limit: limit + 1, // Fetch one extra to check if there are more\n    });\n\n    const hasMore = result.rows.length > limit;\n    const rows = hasMore ? result.rows.slice(0, limit) : result.rows;\n    let agents = rows.map((row) => this.parseAgent(row));\n\n    // Apply filters after fetching\n    if (active_only) {\n      agents = agents.filter((a) => a.active);\n    }\n\n    // Note: Agents use system staking (eosio::voters), not contract-managed staking\n    // To filter by stake, query system staking separately\n\n    // Get next cursor from the last row if there are more\n    const nextCursor = hasMore && rows.length > 0\n      ? rows[rows.length - 1].account\n      : undefined;\n\n    return {\n      items: agents,\n      hasMore,\n      nextCursor,\n    };\n  }\n\n  /**\n   * Iterate through all agents with automatic pagination\n   */\n  async *listAgentsIterator(options: Omit<AgentListOptions, 'cursor'> = {}): AsyncGenerator<Agent> {\n    let cursor: string | undefined;\n\n    do {\n      const result = await this.listAgents({ ...options, cursor });\n      for (const agent of result.items) {\n        yield agent;\n      }\n      cursor = result.nextCursor;\n    } while (cursor);\n  }\n\n  /**\n   * Get a plugin by ID\n   */\n  async getPlugin(id: number): Promise<Plugin | null> {\n    const result = await this.rpc.get_table_rows<PluginRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'plugins',\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.parsePlugin(result.rows[0]);\n  }\n\n  /**\n   * List all plugins\n   */\n  async listPlugins(category?: PluginCategory): Promise<Plugin[]> {\n    const result = await this.rpc.get_table_rows<PluginRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'plugins',\n      limit: 1000,\n    });\n\n    let plugins = result.rows.map((row) => this.parsePlugin(row));\n\n    if (category) {\n      plugins = plugins.filter((p) => p.category === category);\n    }\n\n    return plugins;\n  }\n\n  /**\n   * Get plugins assigned to an agent\n   */\n  async getAgentPlugins(account: string): Promise<AgentPlugin[]> {\n    const result = await this.rpc.get_table_rows<AgentPluginRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'agentplugs',\n      index_position: 2,\n      key_type: 'name',\n      lower_bound: account,\n      upper_bound: account,\n      limit: 100,\n    });\n\n    return result.rows.map((row) => this.parseAgentPlugin(row));\n  }\n\n  // Note: Agents use system staking via eosio::voters table, not contract-managed staking\n  // There is no unstakes table in agentcore - agents stake/unstake via system resources\n  // Use agentcore::getagentinfo action to query an agent's system stake\n\n  /**\n   * Get trust score for an agent (0-100)\n   * Combines KYC level, stake, reputation, and longevity\n   */\n  async getTrustScore(account: string): Promise<TrustScore | null> {\n    // Get agent\n    const agent = await this.getAgent(account);\n    if (!agent) return null;\n\n    // Get agent score from agentfeed\n    const feedContract = 'agentfeed'; // Default feed contract\n    const scoreResult = await this.rpc.get_table_rows<{\n      agent: string;\n      total_score: string;\n      total_weight: string;\n      feedback_count: string;\n      avg_score: string;\n      last_updated: string;\n    }>({\n      json: true,\n      code: feedContract,\n      scope: feedContract,\n      table: 'agentscores',\n      lower_bound: account,\n      upper_bound: account,\n      limit: 1,\n    });\n\n    const agentScore: AgentScore | null = scoreResult.rows.length > 0\n      ? {\n          agent: scoreResult.rows[0].agent,\n          total_score: safeParseInt(scoreResult.rows[0].total_score),\n          total_weight: safeParseInt(scoreResult.rows[0].total_weight),\n          feedback_count: safeParseInt(scoreResult.rows[0].feedback_count),\n          avg_score: safeParseInt(scoreResult.rows[0].avg_score),\n          last_updated: safeParseInt(scoreResult.rows[0].last_updated),\n        }\n      : null;\n\n    // Get KYC level from the OWNER (not the agent)\n    // This is the key insight: agents inherit trust from their human sponsor\n    let kycLevel = 0;\n    if (agent.owner) {\n      const kycResult = await this.rpc.get_table_rows<{\n        acc: string;\n        kyc: Array<{ kyc_level: number | string; kyc_provider?: string }>;\n      }>({\n        json: true,\n        code: 'eosio.proton',\n        scope: 'eosio.proton',\n        table: 'usersinfo',\n        lower_bound: agent.owner,\n        upper_bound: agent.owner,\n        limit: 1,\n      });\n\n      if (kycResult.rows.length > 0 && kycResult.rows[0].kyc?.length > 0) {\n        // Find the highest KYC level, handling various formats:\n        // - number: 3\n        // - string number: \"3\"\n        // - provider:level: \"metallicus:3\"\n        // - comma-separated multi-provider: \"provA:3,provB:1\"\n        const levels: number[] = [];\n\n        for (const k of kycResult.rows[0].kyc) {\n          if (typeof k.kyc_level === 'number') {\n            levels.push(k.kyc_level);\n          } else {\n            const levelStr = String(k.kyc_level);\n            // Handle comma-separated multi-provider strings (e.g., \"provA:3,provB:1\")\n            const providers = levelStr.split(',');\n            for (const provider of providers) {\n              const trimmed = provider.trim();\n              if (trimmed.includes(':')) {\n                // \"provider:level\" format - take the level part\n                const parts = trimmed.split(':');\n                const level = parseInt(parts[parts.length - 1], 10);\n                if (!isNaN(level)) levels.push(level);\n              } else {\n                // Plain number string\n                const level = parseInt(trimmed, 10);\n                if (!isNaN(level)) levels.push(level);\n              }\n            }\n          }\n        }\n\n        // P2 FIX: Safe max - fallback to 0 if no valid levels found\n        // Math.max(...[]) returns -Infinity, which would poison trust scores\n        kycLevel = levels.length > 0 ? Math.max(...levels) : 0;\n      }\n    }\n\n    // Get system stake from eosio::voters\n    const votersResult = await this.rpc.get_table_rows<{\n      owner: string;\n      staked: string;\n    }>({\n      json: true,\n      code: 'eosio',\n      scope: 'eosio',\n      table: 'voters',\n      lower_bound: account,\n      upper_bound: account,\n      limit: 1,\n    });\n\n    let stakeAmount = 0;\n    if (votersResult.rows.length > 0 && votersResult.rows[0].staked) {\n      stakeAmount = safeParseInt(votersResult.rows[0].staked);\n    }\n\n    return calculateTrustScore(agent, agentScore, kycLevel, stakeAmount);\n  }\n\n  /**\n   * Get contract configuration\n   */\n  async getConfig(): Promise<AgentCoreConfig> {\n    const result = await this.rpc.get_table_rows<{\n      owner: string;\n      min_stake: string;\n      registration_fee: string;\n      claim_fee: string;\n      feed_contract: string;\n      valid_contract: string;\n      escrow_contract: string;\n      paused: number;\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      min_stake: safeParseInt(row.min_stake),\n      registration_fee: safeParseInt(row.registration_fee),\n      claim_fee: safeParseInt(row.claim_fee),\n      feed_contract: row.feed_contract,\n      valid_contract: row.valid_contract,\n      escrow_contract: row.escrow_contract,\n      paused: row.paused === 1,\n    };\n  }\n\n  // ============== WRITE OPERATIONS ==============\n\n  /**\n   * Register a new agent\n   */\n  async register(data: RegisterAgentData): Promise<TransactionResult> {\n    this.requireSession();\n\n    // Validate input before sending to blockchain\n    validateAgentData({\n      name: data.name,\n      description: data.description,\n      endpoint: data.endpoint,\n      protocol: data.protocol,\n      capabilities: data.capabilities,\n    });\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'register',\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            name: data.name,\n            description: data.description,\n            endpoint: data.endpoint,\n            protocol: data.protocol,\n            capabilities: JSON.stringify(data.capabilities),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Register a new agent with registration fee in one transaction.\n   * Sends the fee deposit and registers in a single tx.\n   *\n   * @param data - Agent registration data\n   * @param amount - The registration fee (e.g., \"1.0000 XPR\")\n   */\n  async registerWithFee(data: RegisterAgentData, amount: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    validateAgentData({\n      name: data.name,\n      description: data.description,\n      endpoint: data.endpoint,\n      protocol: data.protocol,\n      capabilities: data.capabilities,\n    });\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: `regfee:${actor}`,\n          },\n        },\n        {\n          account: this.contract,\n          name: 'register',\n          authorization: [{\n            actor,\n            permission: this.session!.auth.permission,\n          }],\n          data: {\n            account: actor,\n            name: data.name,\n            description: data.description,\n            endpoint: data.endpoint,\n            protocol: data.protocol,\n            capabilities: JSON.stringify(data.capabilities),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Update agent metadata\n   */\n  async update(data: UpdateAgentData): Promise<TransactionResult> {\n    this.requireSession();\n\n    // Validate input before sending to blockchain\n    // Only validate fields that are provided (UpdateAgentData has optional fields)\n    validateAgentData({\n      name: data.name,\n      description: data.description,\n      endpoint: data.endpoint,\n      protocol: data.protocol,\n      capabilities: data.capabilities,\n    });\n\n    // Get current agent data to merge with updates\n    const current = await this.getAgent(this.session!.auth.actor);\n    if (!current) {\n      throw new Error('Agent not found');\n    }\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'update',\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            name: data.name ?? current.name,\n            description: data.description ?? current.description,\n            endpoint: data.endpoint ?? current.endpoint,\n            protocol: data.protocol ?? current.protocol,\n            capabilities: JSON.stringify(data.capabilities ?? current.capabilities),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Set agent active status\n   */\n  async setStatus(active: boolean): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'setstatus',\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  // ============== SYSTEM STAKING NOTE ==============\n  // Agents use XPR Network's native system staking (eosio::voters table)\n  // instead of contract-managed staking. To stake/unstake:\n  //\n  // 1. Stake: Use system stake action or resources.xprnetwork.org\n  // 2. Unstake: Use system unstake action\n  // 3. Query stake: Call agentcore::getagentinfo action or query eosio::voters table\n  //\n  // This design leverages the existing staking infrastructure and allows\n  // agents to earn staking rewards while meeting minimum stake requirements.\n\n  /**\n   * Add plugin to agent\n   */\n  async addPlugin(pluginId: number, config: object = {}): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'addplugin',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent: this.session!.auth.actor,\n            plugin_id: pluginId,\n            pluginConfig: JSON.stringify(config),\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Remove plugin from agent\n   */\n  async removePlugin(agentPluginId: number): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'rmplugin',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent: this.session!.auth.actor,\n            agentplugin_id: agentPluginId,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Register a new plugin\n   */\n  async registerPlugin(\n    name: string,\n    version: string,\n    contract: string,\n    action: string,\n    schema: object,\n    category: PluginCategory\n  ): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'regplugin',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            author: this.session!.auth.actor,\n            name,\n            version,\n            contract,\n            action,\n            schema: JSON.stringify(schema),\n            category,\n          },\n        },\n      ],\n    });\n  }\n\n  // ============== OWNERSHIP ==============\n\n  /**\n   * Step 1: Agent approves a human to claim them.\n   * This is called by the AGENT to give consent.\n   *\n   * @param newOwner - The KYC'd human being approved to claim\n   */\n  async approveClaim(newOwner: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    // The session holder IS the agent giving consent\n    const agent = this.session!.auth.actor;\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'approveclaim',\n          authorization: [\n            {\n              actor: agent,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n            new_owner: newOwner,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Step 2: Human completes the claim after agent approval.\n   * Agent must have called approveClaim first.\n   *\n   * IMPORTANT: Before calling this, you must:\n   * 1. Have the agent call approveClaim(yourAccount)\n   * 2. Send the claim fee with memo \"claim:agentname:yourname\"\n   *\n   * @param agent - The agent account to claim\n   */\n  async claim(agent: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    const owner = this.session!.auth.actor;\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'claim',\n          authorization: [\n            {\n              actor: owner,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Send claim fee and complete the claim in one transaction.\n   * Agent must have already called approveClaim first.\n   *\n   * @param agent - The agent account to claim\n   * @param amount - The claim fee amount (e.g., \"1.0000 XPR\")\n   */\n  async claimWithFee(agent: string, amount: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    const owner = this.session!.auth.actor;\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: 'eosio.token',\n          name: 'transfer',\n          authorization: [\n            {\n              actor: owner,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            from: owner,\n            to: this.contract,\n            quantity: amount,\n            memo: `claim:${agent}:${owner}`,\n          },\n        },\n        {\n          account: this.contract,\n          name: 'claim',\n          authorization: [\n            {\n              actor: owner,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Cancel a pending claim approval.\n   * Only the agent can cancel their own approval.\n   * Any deposit will be refunded to the payer.\n   *\n   * NOTE: The session holder must be the agent account.\n   */\n  async cancelClaim(): Promise<TransactionResult> {\n    this.requireSession();\n\n    const agent = this.session!.auth.actor;\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'cancelclaim',\n          authorization: [\n            {\n              actor: agent,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Transfer ownership of an agent to a new owner.\n   *\n   * IMPORTANT: The contract requires THREE signatures:\n   * 1. Current owner (must authorize)\n   * 2. New owner (must authorize)\n   * 3. Agent itself (must consent to the transfer)\n   *\n   * This method includes only the session holder's authorization.\n   * It will FAIL unless the session holder controls all three accounts,\n   * which is rare in practice.\n   *\n   * For most use cases, use `buildTransferProposal()` to create a multi-sig\n   * proposal that can be signed by all three parties.\n   *\n   * @param agent - The agent account\n   * @param newOwner - The new owner (must have KYC)\n   * @throws Will fail if session holder doesn't control all 3 required accounts\n   */\n  async transferOwnership(agent: string, newOwner: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    // P2 FIX: Warn about the three-signature requirement\n    console.warn(\n      'transferOwnership requires 3 signatures (current owner, new owner, agent). ' +\n      'This will fail unless session controls all accounts. Use buildTransferProposal() for multi-sig.'\n    );\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'transfer',\n          authorization: [\n            {\n              actor: this.session!.auth.actor,\n              permission: this.session!.auth.permission,\n            },\n          ],\n          data: {\n            agent,\n            new_owner: newOwner,\n          },\n        },\n      ],\n    });\n  }\n\n  /**\n   * Build a transfer ownership action for use in a multi-sig proposal.\n   * Returns the action data that can be used with msig.propose.\n   *\n   * The transfer requires signatures from:\n   * 1. Current owner\n   * 2. New owner\n   * 3. Agent itself\n   *\n   * @param agent - The agent account\n   * @param currentOwner - The current owner account\n   * @param newOwner - The new owner account (must have KYC)\n   * @returns Action data for multi-sig proposal\n   */\n  buildTransferProposal(agent: string, currentOwner: string, newOwner: string): {\n    account: string;\n    name: string;\n    authorization: Array<{ actor: string; permission: string }>;\n    data: { agent: string; new_owner: string };\n  } {\n    return {\n      account: this.contract,\n      name: 'transfer',\n      authorization: [\n        { actor: currentOwner, permission: 'active' },\n        { actor: newOwner, permission: 'active' },\n        { actor: agent, permission: 'active' },\n      ],\n      data: {\n        agent,\n        new_owner: newOwner,\n      },\n    };\n  }\n\n  /**\n   * Release ownership of an agent.\n   * Only the current owner can release.\n   * Claim deposit is refunded to the owner.\n   *\n   * @param agent - The agent account to release\n   */\n  async release(agent: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'release',\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   * Verify an agent's owner still has valid KYC.\n   * Anyone can call this to trigger re-verification.\n   *\n   * If the owner's KYC has dropped below level 1, the ownership\n   * is removed and the claim deposit is refunded to the former owner.\n   *\n   * This helps maintain trust score integrity by allowing community\n   * enforcement of KYC requirements.\n   *\n   * @param agent - The agent account to verify\n   */\n  async verifyClaim(agent: string): Promise<TransactionResult> {\n    this.requireSession();\n\n    return this.session!.link.transact({\n      actions: [\n        {\n          account: this.contract,\n          name: 'verifyclaim',\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   * Get agents owned by a specific account\n   */\n  async getAgentsByOwner(owner: string, limit: number = 100): Promise<Agent[]> {\n    // Use secondary index to query by owner\n    const result = await this.rpc.get_table_rows<AgentRaw>({\n      json: true,\n      code: this.contract,\n      scope: this.contract,\n      table: 'agents',\n      index_position: 2, // byOwner secondary index\n      key_type: 'name',\n      lower_bound: owner,\n      upper_bound: owner,\n      limit,\n    });\n\n    return result.rows.map((row) => this.parseAgent(row));\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 parseAgent(raw: AgentRaw): Agent {\n    return {\n      account: raw.account,\n      owner: raw.owner || null,  // Empty string means no owner\n      pending_owner: raw.pending_owner || null,\n      name: raw.name,\n      description: raw.description,\n      endpoint: raw.endpoint,\n      protocol: raw.protocol,\n      capabilities: parseCapabilities(raw.capabilities),\n      total_jobs: safeParseInt(raw.total_jobs),\n      registered_at: safeParseInt(raw.registered_at),\n      active: raw.active === 1,\n      claim_deposit: safeParseInt(raw.claim_deposit),\n      deposit_payer: raw.deposit_payer || null,\n      // Note: stake is queried from system staking (eosio::voters), not stored here\n    };\n  }\n\n  private parsePlugin(raw: PluginRaw): Plugin {\n    return {\n      id: safeParseInt(raw.id),\n      name: raw.name,\n      version: raw.version,\n      contract: raw.contract,\n      action: raw.action,\n      schema: safeJsonParse(raw.schema, {}),\n      category: raw.category as PluginCategory,\n      author: raw.author,\n      verified: raw.verified === 1,\n    };\n  }\n\n  private parseAgentPlugin(raw: AgentPluginRaw): AgentPlugin {\n    return {\n      id: safeParseInt(raw.id),\n      agent: raw.agent,\n      plugin_id: safeParseInt(raw.plugin_id),\n      config: safeJsonParse(raw.config, {}),\n      enabled: raw.enabled === 1,\n    };\n  }\n}\n"]}