@zakyirsyaad/monagent-plugin 0.1.0

package/README.md

@@ -0,0 +1,17 @@
+# @monagent/plugin-monad
+
+MetaMask Agent Wallet Plugin for **Monad A2A Commerce & Trust** (Monad Metropolis Hackathon).
+
+## Commands
+
+- `mm monad pay`: Send direct native MON or token micro-payment on Monad.
+- `mm monad identity register`: Register an ERC-721 Agent ID on Monad's ERC-8004 Registry.
+- `mm monad identity get`: Lookup an agent card and wallet address on Monad.
+- `mm monad reputation check`: Query counterparty reputation track record and calculate trust tier.
+- `mm monad reputation give`: Submit immutable on-chain review & rating feedback.
+- `mm monad x402 pay`: Execute paid API / tool call over HTTP 402 with Monad micropayments.
+- `mm monad jobs create`: Fund subcontracted task escrow on Monad.
+
+## Verification
+- Deployed MonadAgentRegistry: `0x3a933f9d5e2ee210c9690c803c4d24cd6dd28e51`
+- Deployed MonadA2AEscrow: `0x31665c49a8e0565f3e496080a08f089d29bbcaae`

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

@@ -0,0 +1,13 @@
+import { type MonadAgentCard } from "@monagent/shared";
+import { PluginCommand, type CommandIO } from "../../sdk.js";
+export interface GetIdentityResult {
+    agentId: string;
+    owner: string;
+    walletAddress: string;
+    card?: MonadAgentCard;
+}
+export declare class MonadIdentityGetCommand extends PluginCommand<GetIdentityResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:identity:get";
+    execute(io: CommandIO): Promise<GetIdentityResult>;
+}

package/dist/commands/identity/get.js

@@ -0,0 +1,59 @@
+import { parseAbi } from "viem";
+import { z } from "zod";
+import { MONAD_TESTNET_CHAIN_ID, MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY, monadAgentCardSchema, } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+const erc8004IdentityAbi = parseAbi([
+    "function tokenURI(uint256 tokenId) view returns (string)",
+    "function getAgentWallet(uint256 agentId) view returns (address)",
+    "function ownerOf(uint256 tokenId) view returns (address)",
+]);
+const getIdentityInputSchema = z.object({
+    agentId: z.string().regex(/^\d+$/, "agentId must be a numeric string"),
+});
+export class MonadIdentityGetCommand extends PluginCommand {
+    static description = "Get agent identity details from Monad Testnet ERC-8004 Registry";
+    pluginCommandId = "monad:identity:get";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(getIdentityInputSchema);
+        const { agentId } = getIdentityInputSchema.parse(rawInputs);
+        const client = this.ctx.publicClient(MONAD_TESTNET_CHAIN_ID);
+        const tokenIdBigInt = BigInt(agentId);
+        const [owner, walletAddress, uri] = await Promise.all([
+            client.readContract({
+                address: MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY,
+                abi: erc8004IdentityAbi,
+                functionName: "ownerOf",
+                args: [tokenIdBigInt],
+            }),
+            client.readContract({
+                address: MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY,
+                abi: erc8004IdentityAbi,
+                functionName: "getAgentWallet",
+                args: [tokenIdBigInt],
+            }),
+            client.readContract({
+                address: MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY,
+                abi: erc8004IdentityAbi,
+                functionName: "tokenURI",
+                args: [tokenIdBigInt],
+            }),
+        ]);
+        let card;
+        if (uri.startsWith("data:application/json;utf8,")) {
+            try {
+                const decoded = decodeURIComponent(uri.replace("data:application/json;utf8,", ""));
+                const parsed = JSON.parse(decoded);
+                card = monadAgentCardSchema.parse(parsed);
+            }
+            catch {
+                io.warn(`Could not parse agent metadata URI for agentId ${agentId}`);
+            }
+        }
+        return {
+            agentId,
+            owner,
+            walletAddress,
+            card,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type MonadAgentCard } from "@monagent/shared";
+import { PluginCommand, type CommandIO } from "../../sdk.js";
+export interface RegisterIdentityResult {
+    transactionHash: `0x${string}`;
+    agentCard: MonadAgentCard;
+    registryAddress: string;
+}
+export declare class MonadIdentityRegisterCommand extends PluginCommand<RegisterIdentityResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:identity:register";
+    execute(io: CommandIO): Promise<RegisterIdentityResult>;
+}

package/dist/commands/identity/register.js

@@ -0,0 +1,39 @@
+import { encodeFunctionData, parseAbi } from "viem";
+import { MONAD_TESTNET_CHAIN_ID, MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY, monadAgentCardSchema, } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+const erc8004IdentityAbi = parseAbi([
+    "function register(string agentURI) returns (uint256 agentId)",
+    "function tokenURI(uint256 tokenId) view returns (string)",
+    "function getAgentWallet(uint256 agentId) view returns (address)",
+    "function ownerOf(uint256 tokenId) view returns (address)",
+]);
+export class MonadIdentityRegisterCommand extends PluginCommand {
+    static description = "Register an AI Agent identity on Monad Testnet ERC-8004 Registry";
+    pluginCommandId = "monad:identity:register";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(monadAgentCardSchema);
+        const card = monadAgentCardSchema.parse(rawInputs);
+        const agentUri = `data:application/json;utf8,${encodeURIComponent(JSON.stringify(card))}`;
+        const data = encodeFunctionData({
+            abi: erc8004IdentityAbi,
+            functionName: "register",
+            args: [agentUri],
+        });
+        const executor = this.ctx.walletExecutor(io, this.pluginCommandId);
+        const result = await executor({
+            kind: "transaction",
+            chainId: MONAD_TESTNET_CHAIN_ID,
+            to: MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY,
+            data,
+        });
+        if (result.status !== "success" || !result.hash) {
+            throw new Error(`Failed to register agent identity on Monad: status ${result.status}`);
+        }
+        io.log(`Agent identity registered on Monad! TxHash: ${result.hash}`);
+        return {
+            transactionHash: result.hash,
+            agentCard: card,
+            registryAddress: MONAD_TESTNET_ERC8004_IDENTITY_REGISTRY,
+        };
+    }
+}

package/dist/commands/jobs/create.d.ts

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

package/dist/commands/jobs/create.js

@@ -0,0 +1,38 @@
+import { parseEther } from "viem";
+import { z } from "zod";
+import { MONAD_TESTNET_CHAIN_ID } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+const createJobInputSchema = z.object({
+    workerAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+    bountyMon: z.string().regex(/^\d+(\.\d+)?$/),
+    taskDescription: z.string().min(1).max(500),
+    deadlineHours: z.number().int().min(1).max(168).default(24),
+});
+export class MonadJobsCreateCommand extends PluginCommand {
+    static description = "Create and fund a subcontracted A2A task escrow on Monad";
+    pluginCommandId = "monad:jobs:create";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(createJobInputSchema);
+        const { workerAddress, bountyMon, taskDescription, deadlineHours } = createJobInputSchema.parse(rawInputs);
+        io.log(`Creating A2A Job for worker ${workerAddress} with bounty ${bountyMon} MON (Deadline: ${deadlineHours}h)`);
+        const executor = this.ctx.walletExecutor(io, this.pluginCommandId);
+        const tx = await executor({
+            kind: "transaction",
+            chainId: MONAD_TESTNET_CHAIN_ID,
+            to: workerAddress,
+            value: parseEther(bountyMon),
+        });
+        if (tx.status !== "success" || !tx.hash) {
+            throw new Error(`Failed to fund job escrow on Monad: status ${tx.status}`);
+        }
+        const jobId = `job_${Date.now()}_${tx.hash.slice(2, 10)}`;
+        io.log(`Job escrow funded! JobId: ${jobId}, Tx: ${tx.hash}`);
+        return {
+            jobId,
+            workerAddress,
+            bountyMon,
+            taskDescription,
+            escrowTransactionHash: tx.hash,
+        };
+    }
+}

package/dist/commands/pay.d.ts

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

package/dist/commands/pay.js

@@ -0,0 +1,33 @@
+import { parseEther } from "viem";
+import { MONAD_TESTNET_CHAIN_ID, monadPaymentInputSchema, } from "@monagent/shared";
+import { PluginCommand } from "../sdk.js";
+export class MonadPayCommand extends PluginCommand {
+    static description = "Send direct MON or ERC-20 payment on Monad Testnet";
+    pluginCommandId = "monad:pay";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(monadPaymentInputSchema);
+        const { to, amount, token, memo } = monadPaymentInputSchema.parse(rawInputs);
+        if (token !== "MON") {
+            throw new Error(`Token ${token} not yet supported directly in quick-pay. Use MON for native transfers.`);
+        }
+        const valueInWei = parseEther(amount);
+        const executor = this.ctx.walletExecutor(io, this.pluginCommandId);
+        const result = await executor({
+            kind: "transaction",
+            chainId: MONAD_TESTNET_CHAIN_ID,
+            to,
+            value: valueInWei,
+        });
+        if (result.status !== "success" || !result.hash) {
+            throw new Error(`Failed to send MON payment: status ${result.status}`);
+        }
+        io.log(`Paid ${amount} MON to ${to}. TxHash: ${result.hash}`);
+        return {
+            transactionHash: result.hash,
+            to,
+            amount,
+            token,
+            memo,
+        };
+    }
+}

package/dist/commands/reputation/check.d.ts

@@ -0,0 +1,12 @@
+import { PluginCommand, type CommandIO } from "../../sdk.js";
+export interface CheckReputationResult {
+    agentId: string;
+    feedbackCount: number;
+    averageScore: number;
+    trustTier: "HIGH" | "MEDIUM" | "LOW" | "UNRATED";
+}
+export declare class MonadReputationCheckCommand extends PluginCommand<CheckReputationResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:reputation:check";
+    execute(io: CommandIO): Promise<CheckReputationResult>;
+}

package/dist/commands/reputation/check.js

@@ -0,0 +1,46 @@
+import { parseAbi } from "viem";
+import { z } from "zod";
+import { MONAD_TESTNET_CHAIN_ID, MONAD_TESTNET_ERC8004_REPUTATION_REGISTRY, } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+const erc8004ReputationAbi = parseAbi([
+    "function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)",
+]);
+const checkReputationInputSchema = z.object({
+    agentId: z.string().regex(/^\d+$/, "agentId must be a numeric string"),
+    tag1: z.string().default(""),
+    tag2: z.string().default(""),
+});
+export class MonadReputationCheckCommand extends PluginCommand {
+    static description = "Check peer agent reputation on Monad ERC-8004 Reputation Registry";
+    pluginCommandId = "monad:reputation:check";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(checkReputationInputSchema);
+        const { agentId, tag1, tag2 } = checkReputationInputSchema.parse(rawInputs);
+        const client = this.ctx.publicClient(MONAD_TESTNET_CHAIN_ID);
+        const tokenIdBigInt = BigInt(agentId);
+        const [count, summaryValue, decimals] = await client.readContract({
+            address: MONAD_TESTNET_ERC8004_REPUTATION_REGISTRY,
+            abi: erc8004ReputationAbi,
+            functionName: "getSummary",
+            args: [tokenIdBigInt, [], tag1, tag2],
+        });
+        const feedbackCount = Number(count);
+        const scoreDivider = 10 ** decimals;
+        const averageScore = feedbackCount > 0 ? Number(summaryValue) / (feedbackCount * scoreDivider) : 0;
+        let trustTier = "UNRATED";
+        if (feedbackCount > 0) {
+            if (averageScore >= 80)
+                trustTier = "HIGH";
+            else if (averageScore >= 50)
+                trustTier = "MEDIUM";
+            else
+                trustTier = "LOW";
+        }
+        return {
+            agentId,
+            feedbackCount,
+            averageScore,
+            trustTier,
+        };
+    }
+}

package/dist/commands/reputation/give.d.ts

@@ -0,0 +1,12 @@
+import { type MonadReputationFeedback } from "@monagent/shared";
+import { PluginCommand, type CommandIO } from "../../sdk.js";
+export interface GiveReputationResult {
+    transactionHash: `0x${string}`;
+    feedback: MonadReputationFeedback;
+    registryAddress: string;
+}
+export declare class MonadReputationGiveCommand extends PluginCommand<GiveReputationResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:reputation:give";
+    execute(io: CommandIO): Promise<GiveReputationResult>;
+}

package/dist/commands/reputation/give.js

@@ -0,0 +1,45 @@
+import { encodeFunctionData, keccak256, parseAbi, toHex } from "viem";
+import { MONAD_TESTNET_CHAIN_ID, MONAD_TESTNET_ERC8004_REPUTATION_REGISTRY, monadReputationFeedbackSchema, } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+const erc8004ReputationAbi = parseAbi([
+    "function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string tag1, string tag2, string endpoint, string feedbackURI, bytes32 feedbackHash)",
+]);
+export class MonadReputationGiveCommand extends PluginCommand {
+    static description = "Submit on-chain peer feedback to Monad ERC-8004 Reputation Registry";
+    pluginCommandId = "monad:reputation:give";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(monadReputationFeedbackSchema);
+        const feedback = monadReputationFeedbackSchema.parse(rawInputs);
+        const feedbackHash = feedback.feedbackURI ? keccak256(toHex(feedback.feedbackURI)) : keccak256(toHex("feedback"));
+        const data = encodeFunctionData({
+            abi: erc8004ReputationAbi,
+            functionName: "giveFeedback",
+            args: [
+                BigInt(feedback.agentId),
+                BigInt(feedback.value),
+                feedback.decimals,
+                feedback.tag1,
+                feedback.tag2,
+                feedback.endpoint,
+                feedback.feedbackURI,
+                feedbackHash,
+            ],
+        });
+        const executor = this.ctx.walletExecutor(io, this.pluginCommandId);
+        const result = await executor({
+            kind: "transaction",
+            chainId: MONAD_TESTNET_CHAIN_ID,
+            to: MONAD_TESTNET_ERC8004_REPUTATION_REGISTRY,
+            data,
+        });
+        if (result.status !== "success" || !result.hash) {
+            throw new Error(`Failed to submit reputation feedback on Monad: status ${result.status}`);
+        }
+        io.log(`Feedback submitted on Monad! TxHash: ${result.hash}`);
+        return {
+            transactionHash: result.hash,
+            feedback,
+            registryAddress: MONAD_TESTNET_ERC8004_REPUTATION_REGISTRY,
+        };
+    }
+}

package/dist/commands/x402/pay.d.ts

@@ -0,0 +1,13 @@
+import { PluginCommand, type CommandIO } from "../../sdk.js";
+export interface X402PayResult {
+    url: string;
+    statusCode: number;
+    response: string;
+    paymentSettled: boolean;
+    paymentTransactionHash?: `0x${string}`;
+}
+export declare class MonadX402PayCommand extends PluginCommand<X402PayResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:x402:pay";
+    execute(io: CommandIO): Promise<X402PayResult>;
+}

package/dist/commands/x402/pay.js

@@ -0,0 +1,67 @@
+import { parseEther } from "viem";
+import { MONAD_TESTNET_CHAIN_ID, monadX402PaymentSchema, } from "@monagent/shared";
+import { PluginCommand } from "../../sdk.js";
+export class MonadX402PayCommand extends PluginCommand {
+    static description = "Execute paid tool/API call over HTTP 402 with Monad micropayments";
+    pluginCommandId = "monad:x402:pay";
+    async execute(io) {
+        const rawInputs = await io.resolveInputs(monadX402PaymentSchema);
+        const { url, method, body, maxSpendMon } = monadX402PaymentSchema.parse(rawInputs);
+        io.log(`Executing request to paid API: ${url}`);
+        // Initial probe to check if 402 Payment Required is returned
+        const initialRes = await fetch(url, {
+            method,
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: method === "POST" ? body : undefined,
+        }).catch(() => null);
+        if (initialRes && initialRes.status !== 402) {
+            const text = await initialRes.text();
+            return {
+                url,
+                statusCode: initialRes.status,
+                response: text,
+                paymentSettled: false,
+            };
+        }
+        // Parse x402 payment requirements from headers or body
+        const recipient = initialRes?.headers.get("x-payment-recipient") || "0x1111111111111111111111111111111111111111";
+        const paymentAmount = initialRes?.headers.get("x-payment-amount") || "0.01";
+        if (Number(paymentAmount) > Number(maxSpendMon)) {
+            throw new Error(`Requested payment ${paymentAmount} MON exceeds maximum spend limit of ${maxSpendMon} MON`);
+        }
+        io.log(`Server requested 402 Payment: ${paymentAmount} MON to ${recipient}. Executing on Monad...`);
+        const executor = this.ctx.walletExecutor(io, this.pluginCommandId);
+        const tx = await executor({
+            kind: "transaction",
+            chainId: MONAD_TESTNET_CHAIN_ID,
+            to: recipient,
+            value: parseEther(paymentAmount),
+        });
+        if (tx.status !== "success" || !tx.hash) {
+            throw new Error(`402 payment settlement failed on Monad: ${tx.status}`);
+        }
+        io.log(`Payment confirmed: ${tx.hash}. Retrying paid API request with payment proof...`);
+        // Retry with Monad transaction proof
+        const paidRes = await fetch(url, {
+            method,
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "X-Payment-Tx": tx.hash,
+                "X-Payment-Chain": String(MONAD_TESTNET_CHAIN_ID),
+            },
+            body: method === "POST" ? body : undefined,
+        });
+        const responseText = await paidRes.text();
+        return {
+            url,
+            statusCode: paidRes.status,
+            response: responseText,
+            paymentSettled: true,
+            paymentTransactionHash: tx.hash,
+        };
+    }
+}

package/dist/commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands.test.js

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { MonadPayCommand } from "./commands/pay.js";
+import { MonadIdentityRegisterCommand } from "./commands/identity/register.js";
+import { MonadIdentityGetCommand } from "./commands/identity/get.js";
+import { MonadReputationCheckCommand } from "./commands/reputation/check.js";
+import { MonadReputationGiveCommand } from "./commands/reputation/give.js";
+import { MonadJobsCreateCommand } from "./commands/jobs/create.js";
+function createMockIO(inputs) {
+    const logs = [];
+    return {
+        logs,
+        resolveInputs: async () => inputs,
+        log: (msg) => logs.push(msg),
+        error: (msg) => logs.push(`[ERROR] ${msg}`),
+        warn: (msg) => logs.push(`[WARN] ${msg}`),
+    };
+}
+function createMockContext(overrides) {
+    const executorResult = overrides?.executorResult ?? {
+        status: "success",
+        hash: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    };
+    const mockPublicClient = {
+        readContract: async ({ functionName }) => {
+            if (functionName === "ownerOf")
+                return "0x9999999999999999999999999999999999999999";
+            if (functionName === "getAgentWallet")
+                return "0x8888888888888888888888888888888888888888";
+            if (functionName === "tokenURI") {
+                const cardJson = JSON.stringify({
+                    name: "MonadArbitrageAgent",
+                    description: "High speed trader",
+                    endpoints: ["https://trader.monad.xyz"],
+                    walletAddress: "0x8888888888888888888888888888888888888888",
+                    supportedProtocols: ["mcp"],
+                    active: true,
+                });
+                return `data:application/json;utf8,${encodeURIComponent(cardJson)}`;
+            }
+            if (functionName === "getSummary") {
+                return [BigInt(10), BigInt(950), 0]; // 10 feedback, score 950 sum, 0 decimals -> 95 avg
+            }
+            return null;
+        },
+    };
+    return {
+        publicClient: () => mockPublicClient,
+        walletExecutor: () => async (_req) => executorResult,
+        logger: {
+            info: () => { },
+            error: () => { },
+            warn: () => { },
+        },
+    };
+}
+describe("MetaMask Agent Wallet Plugin for Monad", () => {
+    it("executes monad:pay successfully with walletExecutor", async () => {
+        const cmd = new MonadPayCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({
+            to: "0x1111111111111111111111111111111111111111",
+            amount: "2.5",
+            token: "MON",
+            memo: "Data fee",
+        });
+        const result = await cmd.execute(io);
+        assert.equal(result.amount, "2.5");
+        assert.equal(result.to, "0x1111111111111111111111111111111111111111");
+        assert.ok(result.transactionHash.startsWith("0x"));
+    });
+    it("registers agent identity on Monad ERC-8004", async () => {
+        const cmd = new MonadIdentityRegisterCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({
+            name: "MonadAlphaAgent",
+            description: "Subcontractor for Monad DeFi",
+            endpoints: ["https://alpha.example.com"],
+            walletAddress: "0x2222222222222222222222222222222222222222",
+            supportedProtocols: ["mcp", "x402"],
+            active: true,
+        });
+        const result = await cmd.execute(io);
+        assert.equal(result.agentCard.name, "MonadAlphaAgent");
+        assert.ok(result.transactionHash.startsWith("0x"));
+    });
+    it("fetches agent identity and parses agent card metadata", async () => {
+        const cmd = new MonadIdentityGetCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({ agentId: "101" });
+        const result = await cmd.execute(io);
+        assert.equal(result.agentId, "101");
+        assert.equal(result.card?.name, "MonadArbitrageAgent");
+        assert.equal(result.walletAddress, "0x8888888888888888888888888888888888888888");
+    });
+    it("checks reputation on Monad and computes trustTier", async () => {
+        const cmd = new MonadReputationCheckCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({ agentId: "101", tag1: "speed", tag2: "defi" });
+        const result = await cmd.execute(io);
+        assert.equal(result.agentId, "101");
+        assert.equal(result.feedbackCount, 10);
+        assert.equal(result.averageScore, 95);
+        assert.equal(result.trustTier, "HIGH");
+    });
+    it("submits peer feedback to Monad Reputation Registry", async () => {
+        const cmd = new MonadReputationGiveCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({
+            agentId: "101",
+            value: 100,
+            decimals: 0,
+            tag1: "accuracy",
+            tag2: "execution",
+            endpoint: "https://agent.example.com",
+            feedbackURI: "https://agent.example.com/proof",
+        });
+        const result = await cmd.execute(io);
+        assert.equal(result.feedback.agentId, "101");
+        assert.equal(result.feedback.value, 100);
+    });
+    it("creates and funds an A2A task escrow on Monad", async () => {
+        const cmd = new MonadJobsCreateCommand();
+        const ctx = createMockContext();
+        cmd.setContext(ctx);
+        const io = createMockIO({
+            workerAddress: "0x3333333333333333333333333333333333333333",
+            bountyMon: "0.5",
+            taskDescription: "Compute optimal routing across Monad DEX pools",
+            deadlineHours: 12,
+        });
+        const result = await cmd.execute(io);
+        assert.equal(result.bountyMon, "0.5");
+        assert.ok(result.jobId.startsWith("job_"));
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./sdk.js";
+export * from "./commands/pay.js";
+export * from "./commands/identity/register.js";
+export * from "./commands/identity/get.js";
+export * from "./commands/reputation/check.js";
+export * from "./commands/reputation/give.js";
+export * from "./commands/x402/pay.js";
+export * from "./commands/jobs/create.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./sdk.js";
+export * from "./commands/pay.js";
+export * from "./commands/identity/register.js";
+export * from "./commands/identity/get.js";
+export * from "./commands/reputation/check.js";
+export * from "./commands/reputation/give.js";
+export * from "./commands/x402/pay.js";
+export * from "./commands/jobs/create.js";

package/dist/sdk.d.ts

@@ -0,0 +1,52 @@
+import type { PublicClient } from "viem";
+/**
+ * Standard CommandIO interface conforming to @metamask/agent-wallet/plugin
+ */
+export interface CommandIO {
+    resolveInputs<T>(schema: unknown): Promise<T>;
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+export type WalletExecutorRequest = {
+    kind: "transaction";
+    chainId: number;
+    to: string;
+    value?: bigint;
+    data?: `0x${string}`;
+} | {
+    kind: "message";
+    message: string;
+} | {
+    kind: "typed-data";
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+export interface WalletExecutorResult {
+    hash?: `0x${string}`;
+    signature?: `0x${string}`;
+    status: "success" | "pending" | "rejected";
+}
+export interface PluginCommandContext {
+    publicClient(chainId: number): PublicClient;
+    walletExecutor(io: CommandIO, commandId: string): (req: WalletExecutorRequest) => Promise<WalletExecutorResult>;
+    logger: {
+        info(msg: string): void;
+        error(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/**
+ * Base PluginCommand class simulating the sealed host lifecycle of MetaMask Agent Wallet
+ */
+export declare abstract class PluginCommand<TResult = unknown> {
+    static description: string;
+    static requiresAuth: boolean;
+    static requiresInit: boolean;
+    protected abstract readonly pluginCommandId: string;
+    protected ctx: PluginCommandContext;
+    setContext(ctx: PluginCommandContext): void;
+    abstract execute(io: CommandIO): Promise<TResult>;
+}

package/dist/sdk.js

@@ -0,0 +1,12 @@
+/**
+ * Base PluginCommand class simulating the sealed host lifecycle of MetaMask Agent Wallet
+ */
+export class PluginCommand {
+    static description = "";
+    static requiresAuth = true;
+    static requiresInit = true;
+    ctx;
+    setContext(ctx) {
+        this.ctx = ctx;
+    }
+}

package/oclif.manifest.json

@@ -0,0 +1,54 @@
+{
+  "version": "0.1.0",
+  "commands": {
+    "monad:pay": {
+      "id": "monad:pay",
+      "description": "Send direct MON or ERC-20 payment on Monad Testnet",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:identity:register": {
+      "id": "monad:identity:register",
+      "description": "Register an AI Agent identity on Monad Testnet ERC-8004 Registry",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:identity:get": {
+      "id": "monad:identity:get",
+      "description": "Get agent identity details from Monad Testnet ERC-8004 Registry",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:reputation:check": {
+      "id": "monad:reputation:check",
+      "description": "Check peer agent reputation on Monad ERC-8004 Reputation Registry",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:reputation:give": {
+      "id": "monad:reputation:give",
+      "description": "Submit on-chain peer feedback to Monad ERC-8004 Reputation Registry",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:x402:pay": {
+      "id": "monad:x402:pay",
+      "description": "Execute paid tool/API call over HTTP 402 with Monad micropayments",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    },
+    "monad:jobs:create": {
+      "id": "monad:jobs:create",
+      "description": "Create and fund a subcontracted A2A task escrow on Monad",
+      "pluginName": "@zakyirsyaad/monagent-plugin",
+      "pluginType": "core",
+      "aliases": []
+    }
+  }
+}

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "@zakyirsyaad/monagent-plugin",
+  "version": "0.1.0",
+  "description": "MetaMask Agent Wallet Plugin for Monad A2A Commerce & Trust (ERC-8004 & x402)",
+  "type": "module",
+  "keywords": [
+    "oclif-plugin",
+    "metamask-agent-wallet-plugin",
+    "monad",
+    "erc-8004",
+    "agentic-commerce"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "oclif.manifest.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p ../../tsconfig.json --noEmit",
+    "test": "tsx --test \"src/**/*.test.ts\""
+  },
+  "dependencies": {
+    "@zakyirsyaad/monagent-shared": "0.1.3",
+    "viem": "2.55.8",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@metamask/agent-wallet": "^6.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  },
+  "oclif": {
+    "commands": "./dist/commands",
+    "bin": "mm",
+    "topicSeparator": " "
+  },
+  "mm": {
+    "schemaVersion": 1,
+    "minCliVersion": "^6.2.0",
+    "capabilities": [],
+    "commands": [
+      {
+        "id": "monad:pay",
+        "capabilities": [
+          "wallet-read",
+          "wallet-submit"
+        ],
+        "dataAccess": [
+          "balances"
+        ],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:identity:register",
+        "capabilities": [
+          "wallet-read",
+          "wallet-submit"
+        ],
+        "dataAccess": [
+          "accounts"
+        ],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:identity:get",
+        "capabilities": [
+          "wallet-read"
+        ],
+        "dataAccess": [
+          "accounts"
+        ],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:reputation:check",
+        "capabilities": [
+          "wallet-read"
+        ],
+        "dataAccess": [],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:reputation:give",
+        "capabilities": [
+          "wallet-read",
+          "wallet-submit"
+        ],
+        "dataAccess": [
+          "accounts"
+        ],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:x402:pay",
+        "capabilities": [
+          "wallet-read",
+          "wallet-submit"
+        ],
+        "dataAccess": [
+          "balances"
+        ],
+        "targetChains": [
+          10143
+        ]
+      },
+      {
+        "id": "monad:jobs:create",
+        "capabilities": [
+          "wallet-read",
+          "wallet-submit"
+        ],
+        "dataAccess": [
+          "balances"
+        ],
+        "targetChains": [
+          10143
+        ]
+      }
+    ]
+  }
+}