@zakyirsyaad/monagent-plugin 0.1.0 → 0.1.2

package/dist/commands/monad/identity/get.d.ts

@@ -0,0 +1,19 @@
+import { type MonadAgentCard } from "../../../monad.js";
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
+export interface GetIdentityResult {
+    agentId: string;
+    owner: string;
+    walletAddress: string;
+    card?: MonadAgentCard;
+    chainId: number;
+}
+export declare class MonadIdentityGetCommand extends BaseMonadPluginCommand<GetIdentityResult> {
+    static description: string;
+    static requiresAuth: boolean;
+    static requiresInit: boolean;
+    protected readonly pluginCommandId = "monad:identity:get";
+    static readonly inputs: InputSchema;
+    static flags: any;
+    static args: any;
+    execute(io: CommandIO): Promise<GetIdentityResult>;
+}

package/dist/commands/monad/identity/get.js

@@ -0,0 +1,113 @@
+import { resolveChain, erc8004IdentityAbi, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, } from "../../../sdk.js";
+import { PluginCommand, schemaToArgs } from "@metamask/agent-wallet/plugin";
+export class MonadIdentityGetCommand extends BaseMonadPluginCommand {
+    static description = "Get agent identity details from Monad ERC-8004 Registry";
+    static requiresAuth = false;
+    static requiresInit = false;
+    pluginCommandId = "monad:identity:get";
+    static inputs = {
+        agentId: {
+            type: InputFieldType.Text,
+            flag: "agentId",
+            message: "Agent token ID in ERC-8004 registry",
+            required: true,
+            index: 0,
+        },
+        chainId: {
+            type: InputFieldType.Text,
+            flag: "chain-id",
+            aliases: ["chainId"],
+            message: "Monad chain ID (10143 for testnet, 143 for mainnet)",
+            required: false,
+        },
+    };
+    static flags = PluginCommand.flagsWithInputs(this.inputs);
+    static args = schemaToArgs(this.inputs);
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(MonadIdentityGetCommand.inputs);
+        const agentId = String(rawInputs.agentId).trim();
+        if (!/^\d+$/.test(agentId)) {
+            throw new CommandError("INVALID_INPUT", `Invalid agentId "${agentId}". Must be a numeric string.`, "Provide a valid agent ID number (e.g. 1).");
+        }
+        const chain = resolveChain(rawInputs.chainId);
+        const client = this.getPublicClient(chain.chainId);
+        const tokenIdBigInt = BigInt(agentId);
+        let owner;
+        let walletAddress;
+        let tokenUri;
+        const registryAddress = chain.identityRegistry;
+        try {
+            [owner, walletAddress, tokenUri] = await Promise.all([
+                client.readContract({
+                    address: registryAddress,
+                    abi: erc8004IdentityAbi,
+                    functionName: "ownerOf",
+                    args: [tokenIdBigInt],
+                }),
+                client.readContract({
+                    address: registryAddress,
+                    abi: erc8004IdentityAbi,
+                    functionName: "getAgentWallet",
+                    args: [tokenIdBigInt],
+                }),
+                client.readContract({
+                    address: registryAddress,
+                    abi: erc8004IdentityAbi,
+                    functionName: "tokenURI",
+                    args: [tokenIdBigInt],
+                }),
+            ]);
+        }
+        catch (err) {
+            throw new CommandError("AGENT_NOT_FOUND", `Failed to fetch Agent #${agentId} from Monad ERC-8004 Registry (${registryAddress} on chain ${chain.chainId}): ${err?.message || String(err)}`, "Verify the agentId exists on the specified chain.");
+        }
+        let card;
+        try {
+            let jsonString = "";
+            if (tokenUri.startsWith("data:application/json;base64,")) {
+                const base64Data = tokenUri.slice("data:application/json;base64,".length);
+                jsonString = Buffer.from(base64Data, "base64").toString("utf-8");
+            }
+            else if (tokenUri.startsWith("data:application/json;utf8,") || tokenUri.startsWith("data:application/json,")) {
+                const urlEncoded = tokenUri.replace(/^data:application\/json(;utf8)?,/, "");
+                jsonString = decodeURIComponent(urlEncoded);
+            }
+            else if (tokenUri.startsWith("{")) {
+                jsonString = tokenUri;
+            }
+            if (jsonString) {
+                const parsedJson = JSON.parse(jsonString);
+                card = {
+                    name: parsedJson.name || `Agent #${agentId}`,
+                    description: parsedJson.description || "",
+                    walletAddress: walletAddress,
+                    endpoints: parsedJson.services?.map((s) => s.endpoint).filter(Boolean) || [
+                        parsedJson.endpoint || "",
+                    ],
+                    supportedProtocols: parsedJson.supportedProtocols || ["mcp", "x402"],
+                    active: parsedJson.active !== undefined ? Boolean(parsedJson.active) : true,
+                };
+            }
+        }
+        catch {
+            // If parsing fails, create card with available contract data
+            card = {
+                name: `Agent #${agentId}`,
+                description: "",
+                walletAddress: walletAddress,
+                endpoints: [],
+                supportedProtocols: ["mcp", "x402"],
+                active: true,
+            };
+        }
+        io.emit(`Agent #${agentId}: Owner: ${owner}, Wallet: ${walletAddress}, Name: ${card?.name || "N/A"}`);
+        return {
+            agentId,
+            owner,
+            walletAddress,
+            card,
+            chainId: chain.chainId,
+        };
+    }
+}

package/dist/commands/monad/identity/register.d.ts

@@ -0,0 +1,16 @@
+import { type MonadAgentCard } from "../../../monad.js";
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
+export interface RegisterIdentityResult {
+    transactionHash: `0x${string}`;
+    agentId: string;
+    agentCard: MonadAgentCard;
+    registryAddress: string;
+    chainId: number;
+}
+export declare class MonadIdentityRegisterCommand extends BaseMonadPluginCommand<RegisterIdentityResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:identity:register";
+    static readonly inputs: InputSchema;
+    static flags: any;
+    execute(io: CommandIO): Promise<RegisterIdentityResult>;
+}

package/dist/commands/monad/identity/register.js

@@ -0,0 +1,122 @@
+import { encodeFunctionData, parseEventLogs } from "viem";
+import { resolveChain, erc8004IdentityAbi, monadAgentCardSchema, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../../sdk.js";
+import { PluginCommand } from "@metamask/agent-wallet/plugin";
+export class MonadIdentityRegisterCommand extends BaseMonadPluginCommand {
+    static description = "Register an AI Agent identity on Monad ERC-8004 Registry";
+    pluginCommandId = "monad:identity:register";
+    static inputs = {
+        name: {
+            type: InputFieldType.Text,
+            flag: "name",
+            message: "Human-readable agent name",
+            required: true,
+        },
+        description: {
+            type: InputFieldType.Text,
+            flag: "description",
+            message: "Agent description and capabilities",
+            required: true,
+        },
+        walletAddress: {
+            type: InputFieldType.Text,
+            flag: "walletAddress",
+            message: "Agent operational EVM wallet address",
+            required: true,
+        },
+        endpoint: {
+            type: InputFieldType.Text,
+            flag: "endpoint",
+            message: "Primary service endpoint URL",
+            required: false,
+        },
+        chainId: {
+            type: InputFieldType.Text,
+            flag: "chain-id",
+            aliases: ["chainId"],
+            message: "Monad chain ID (10143 for testnet, 143 for mainnet)",
+            required: false,
+        },
+    };
+    static flags = PluginCommand.flagsWithInputs(this.inputs);
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(MonadIdentityRegisterCommand.inputs);
+        const chain = resolveChain(rawInputs.chainId);
+        const cardInput = {
+            name: rawInputs.name,
+            description: rawInputs.description,
+            walletAddress: rawInputs.walletAddress,
+            endpoints: [rawInputs.endpoint || "https://agent.xyz"],
+            supportedProtocols: ["mcp", "x402"],
+            active: true,
+        };
+        const parsedCard = monadAgentCardSchema.safeParse(cardInput);
+        if (!parsedCard.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid agent card input: ${parsedCard.error.issues.map((i) => i.message).join(", ")}`, "Check agent name, description, wallet address, and endpoint.");
+        }
+        const card = parsedCard.data;
+        // Build standard ERC-8004 Registration JSON data URI
+        const registrationJson = {
+            type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
+            name: card.name,
+            description: card.description,
+            image: "https://i.imgur.com/JQxM4nO.png",
+            services: [
+                {
+                    name: "A2A",
+                    endpoint: card.endpoints[0],
+                    version: "0.3.0",
+                },
+                {
+                    name: "MCP",
+                    endpoint: `${card.endpoints[0]}/mcp`,
+                    version: "2025-06-18",
+                },
+            ],
+            x402Support: card.supportedProtocols.includes("x402"),
+            active: card.active,
+            registrations: [],
+            supportedTrust: ["reputation"],
+        };
+        const agentUri = `data:application/json;base64,${Buffer.from(JSON.stringify(registrationJson)).toString("base64")}`;
+        const data = encodeFunctionData({
+            abi: erc8004IdentityAbi,
+            functionName: "register",
+            args: [agentUri],
+        });
+        const hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: chain.identityRegistry,
+            data,
+        });
+        // Extract agentId from Registered event log
+        let onChainAgentId;
+        try {
+            const client = this.getPublicClient(chain.chainId);
+            const receipt = await client.waitForTransactionReceipt({ hash });
+            const logs = parseEventLogs({
+                abi: erc8004IdentityAbi,
+                logs: receipt.logs,
+                eventName: "Registered",
+            });
+            if (logs.length > 0 && logs[0].args.agentId !== undefined) {
+                onChainAgentId = logs[0].args.agentId.toString();
+            }
+            else {
+                throw new Error("Registered event not found in receipt");
+            }
+        }
+        catch (err) {
+            throw new CommandError("RECEIPT_PARSING_FAILED", `Agent registration confirmed in tx ${hash}, but Registered event log could not be parsed: ${err?.message || String(err)}`, "Check transaction on Monad Explorer.");
+        }
+        io.emit(`Agent #${onChainAgentId} registered on ${chain.name} ERC-8004 Registry! TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            transactionHash: hash,
+            agentId: onChainAgentId,
+            agentCard: card,
+            registryAddress: chain.identityRegistry,
+            chainId: chain.chainId,
+        };
+    }
+}

package/dist/commands/monad/jobs/complete.d.ts

@@ -0,0 +1,15 @@
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
+export interface CompleteJobResult {
+    jobId: string;
+    resultURI: string;
+    transactionHash: `0x${string}`;
+    chainId: number;
+}
+export declare class MonadJobsCompleteCommand extends BaseMonadPluginCommand<CompleteJobResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:jobs:complete";
+    static readonly inputs: InputSchema;
+    static flags: any;
+    static args: any;
+    execute(io: CommandIO): Promise<CompleteJobResult>;
+}

package/dist/commands/monad/jobs/complete.js

@@ -0,0 +1,63 @@
+import { encodeFunctionData } from "viem";
+import { resolveChain, monadEscrowAbi, monadCompleteJobSchema, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../../sdk.js";
+import { PluginCommand, schemaToArgs } from "@metamask/agent-wallet/plugin";
+export class MonadJobsCompleteCommand extends BaseMonadPluginCommand {
+    static description = "Complete and release a subcontracted A2A task escrow on Monad";
+    pluginCommandId = "monad:jobs:complete";
+    static inputs = {
+        jobId: {
+            type: InputFieldType.Text,
+            flag: "jobId",
+            message: "Escrow job ID to complete",
+            required: true,
+            index: 0,
+        },
+        resultURI: {
+            type: InputFieldType.Text,
+            flag: "resultURI",
+            message: "Deliverable URI or proof hash",
+            required: false,
+        },
+        chainId: {
+            type: InputFieldType.Text,
+            flag: "chain-id",
+            aliases: ["chainId"],
+            message: "Monad chain ID (10143 for testnet, 143 for mainnet)",
+            required: false,
+        },
+    };
+    static flags = PluginCommand.flagsWithInputs(this.inputs);
+    static args = schemaToArgs(this.inputs);
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(MonadJobsCompleteCommand.inputs);
+        const parsed = monadCompleteJobSchema.safeParse(rawInputs);
+        if (!parsed.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid complete job input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, "Provide a numeric jobId and optional resultURI.");
+        }
+        const { jobId, resultURI } = parsed.data;
+        const chain = resolveChain(rawInputs.chainId);
+        if (!chain.escrow) {
+            throw new CommandError("ESCROW_NOT_DEPLOYED", `MonadA2AEscrow is not deployed on Monad chain ${chain.chainId}. Escrow is currently available on Monad Testnet (10143).`, "Specify --chain-id 10143 to interact with escrow contracts.");
+        }
+        io.emit(`Releasing escrow for Job #${jobId} on ${chain.name}...`);
+        const data = encodeFunctionData({
+            abi: monadEscrowAbi,
+            functionName: "completeJob",
+            args: [BigInt(jobId), resultURI],
+        });
+        const hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: chain.escrow,
+            data,
+        });
+        io.emit(`Job #${jobId} escrow released and settled on ${chain.name}! TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            jobId,
+            resultURI,
+            transactionHash: hash,
+            chainId: chain.chainId,
+        };
+    }
+}

package/dist/commands/{jobs → monad/jobs}/create.d.ts

@@ -1,13 +1,16 @@
-import { PluginCommand, type CommandIO } from "../../sdk.js";
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
 export interface CreateJobResult {
     jobId: string;
     workerAddress: string;
     bountyMon: string;
     taskDescription: string;
     escrowTransactionHash: `0x${string}`;
+    chainId: number;
 }
-export declare class MonadJobsCreateCommand extends PluginCommand<CreateJobResult> {
+export declare class MonadJobsCreateCommand extends BaseMonadPluginCommand<CreateJobResult> {
     static description: string;
     protected readonly pluginCommandId = "monad:jobs:create";
+    static readonly inputs: InputSchema;
+    static flags: any;
     execute(io: CommandIO): Promise<CreateJobResult>;
 }

package/dist/commands/monad/jobs/create.js

@@ -0,0 +1,88 @@
+import { encodeFunctionData, parseEther, parseEventLogs } from "viem";
+import { resolveChain, monadEscrowAbi, monadCreateJobSchema, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../../sdk.js";
+import { PluginCommand } from "@metamask/agent-wallet/plugin";
+export class MonadJobsCreateCommand extends BaseMonadPluginCommand {
+    static description = "Create and fund a subcontracted A2A task escrow on Monad";
+    pluginCommandId = "monad:jobs:create";
+    static inputs = {
+        workerAddress: {
+            type: InputFieldType.Text,
+            flag: "workerAddress",
+            message: "Worker EVM address receiving the escrow bounty",
+            required: true,
+        },
+        bountyMon: {
+            type: InputFieldType.Text,
+            flag: "bountyMon",
+            message: "Bounty amount in native MON (e.g. 0.2)",
+            required: true,
+        },
+        taskDescription: {
+            type: InputFieldType.Text,
+            flag: "taskDescription",
+            message: "Clear deliverable description or specifications",
+            required: true,
+        },
+        deadlineHours: {
+            type: InputFieldType.Text,
+            flag: "deadlineHours",
+            message: "Review and task window in hours (default 24)",
+            required: false,
+        },
+        chainId: {
+            type: InputFieldType.Text,
+            flag: "chain-id",
+            aliases: ["chainId"],
+            message: "Monad chain ID (10143 for testnet, 143 for mainnet)",
+            required: false,
+        },
+    };
+    static flags = PluginCommand.flagsWithInputs(this.inputs);
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(MonadJobsCreateCommand.inputs);
+        const parsed = monadCreateJobSchema.safeParse(rawInputs);
+        if (!parsed.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid job creation input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, "Provide valid workerAddress, positive bountyMon, and taskDescription.");
+        }
+        const { workerAddress, bountyMon, taskDescription, deadlineHours } = parsed.data;
+        const chain = resolveChain(rawInputs.chainId);
+        if (!chain.escrow) {
+            throw new CommandError("ESCROW_NOT_DEPLOYED", `MonadA2AEscrow is not deployed on Monad chain ${chain.chainId}. Escrow is currently available on Monad Testnet (10143).`, "Specify --chain-id 10143 to interact with escrow contracts.");
+        }
+        io.emit(`Creating A2A Job on ${chain.name} for worker ${workerAddress} with bounty ${bountyMon} MON (Deadline: ${deadlineHours}h)...`);
+        const data = encodeFunctionData({
+            abi: monadEscrowAbi,
+            functionName: "createAndFundJob",
+            args: [workerAddress, taskDescription, BigInt(deadlineHours)],
+        });
+        const hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: chain.escrow,
+            value: parseEther(bountyMon),
+            data,
+        });
+        // Wait for receipt and decode JobCreated event
+        const client = this.getPublicClient(chain.chainId);
+        const receipt = await client.waitForTransactionReceipt({ hash });
+        const logs = parseEventLogs({
+            abi: monadEscrowAbi,
+            logs: receipt.logs,
+            eventName: "JobCreated",
+        });
+        if (logs.length === 0 || logs[0].args.jobId === undefined) {
+            throw new CommandError("RECEIPT_PARSING_FAILED", `Transaction ${hash} confirmed, but JobCreated event was not found in receipt logs.`, "Check escrow contract address and receipt on Monad Explorer.");
+        }
+        const onChainJobId = logs[0].args.jobId.toString();
+        io.emit(`Job escrow funded on ${chain.name}! JobId: ${onChainJobId}, TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            jobId: onChainJobId,
+            workerAddress,
+            bountyMon,
+            taskDescription,
+            escrowTransactionHash: hash,
+            chainId: chain.chainId,
+        };
+    }
+}

package/dist/commands/monad/jobs/refund.d.ts

@@ -0,0 +1,14 @@
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
+export interface RefundJobResult {
+    jobId: string;
+    transactionHash: `0x${string}`;
+    chainId: number;
+}
+export declare class MonadJobsRefundCommand extends BaseMonadPluginCommand<RefundJobResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:jobs:refund";
+    static readonly inputs: InputSchema;
+    static flags: any;
+    static args: any;
+    execute(io: CommandIO): Promise<RefundJobResult>;
+}

package/dist/commands/monad/jobs/refund.js

@@ -0,0 +1,56 @@
+import { encodeFunctionData } from "viem";
+import { resolveChain, monadEscrowAbi, monadRefundJobSchema, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../../sdk.js";
+import { PluginCommand, schemaToArgs } from "@metamask/agent-wallet/plugin";
+export class MonadJobsRefundCommand extends BaseMonadPluginCommand {
+    static description = "Refund an expired subcontracted A2A task escrow on Monad";
+    pluginCommandId = "monad:jobs:refund";
+    static inputs = {
+        jobId: {
+            type: InputFieldType.Text,
+            flag: "jobId",
+            message: "Escrow job ID to refund after deadline",
+            required: true,
+            index: 0,
+        },
+        chainId: {
+            type: InputFieldType.Text,
+            flag: "chain-id",
+            aliases: ["chainId"],
+            message: "Monad chain ID (10143 for testnet, 143 for mainnet)",
+            required: false,
+        },
+    };
+    static flags = PluginCommand.flagsWithInputs(this.inputs);
+    static args = schemaToArgs(this.inputs);
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(MonadJobsRefundCommand.inputs);
+        const parsed = monadRefundJobSchema.safeParse(rawInputs);
+        if (!parsed.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid refund job input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, "Provide a numeric jobId.");
+        }
+        const { jobId } = parsed.data;
+        const chain = resolveChain(rawInputs.chainId);
+        if (!chain.escrow) {
+            throw new CommandError("ESCROW_NOT_DEPLOYED", `MonadA2AEscrow is not deployed on Monad chain ${chain.chainId}. Escrow is currently available on Monad Testnet (10143).`, "Specify --chain-id 10143 to interact with escrow contracts.");
+        }
+        io.emit(`Refunding expired escrow for Job #${jobId} on ${chain.name}...`);
+        const data = encodeFunctionData({
+            abi: monadEscrowAbi,
+            functionName: "refundExpiredJob",
+            args: [BigInt(jobId)],
+        });
+        const hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: chain.escrow,
+            data,
+        });
+        io.emit(`Job #${jobId} escrow refunded on ${chain.name}! TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            jobId,
+            transactionHash: hash,
+            chainId: chain.chainId,
+        };
+    }
+}

package/dist/commands/{pay.d.ts → monad/pay.d.ts}

@@ -1,13 +1,16 @@
-import { PluginCommand, type CommandIO } from "../sdk.js";
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../sdk.js";
 export interface MonadPaymentResult {
     transactionHash: `0x${string}`;
     to: string;
     amount: string;
     token: string;
     memo?: string;
+    chainId: number;
 }
-export declare class MonadPayCommand extends PluginCommand<MonadPaymentResult> {
+export declare class MonadPayCommand extends BaseMonadPluginCommand<MonadPaymentResult> {
     static description: string;
     protected readonly pluginCommandId = "monad:pay";
+    static readonly inputs: InputSchema;
+    static flags: any;
     execute(io: CommandIO): Promise<MonadPaymentResult>;
 }