@zakyirsyaad/monagent-plugin 0.1.0 → 0.1.2

package/dist/commands/monad/pay.js

@@ -0,0 +1,123 @@
+import { encodeFunctionData, erc20Abi, parseEther, parseUnits } from "viem";
+import { resolveChain, monadPaymentInputSchema, } from "../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../sdk.js";
+import { PluginCommand } from "@metamask/agent-wallet/plugin";
+export class MonadPayCommand extends BaseMonadPluginCommand {
+    static description = "Send direct MON or ERC-20 payment on Monad";
+    pluginCommandId = "monad:pay";
+    static inputs = {
+        to: {
+            type: InputFieldType.Text,
+            flag: "to",
+            message: "Recipient EVM address on Monad",
+            required: true,
+        },
+        amount: {
+            type: InputFieldType.Text,
+            flag: "amount",
+            message: "Amount to transfer (e.g. 0.5)",
+            required: true,
+        },
+        token: {
+            type: InputFieldType.Text,
+            flag: "token",
+            message: "Token symbol (MON, USDC, or 0x<address>)",
+            default: "MON",
+            required: false,
+        },
+        memo: {
+            type: InputFieldType.Text,
+            flag: "memo",
+            message: "Payment memo or reason (audit log note, not stored on-chain)",
+            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(MonadPayCommand.inputs);
+        const parsed = monadPaymentInputSchema.safeParse(rawInputs);
+        if (!parsed.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid payment input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, "Provide a valid recipient address and positive amount.");
+        }
+        const { to, amount, token, memo } = parsed.data;
+        const chain = resolveChain(rawInputs.chainId);
+        const tokenUpper = token.trim().toUpperCase();
+        let targetAddress;
+        let txValue = 0n;
+        let txData = undefined;
+        if (tokenUpper === "MON") {
+            targetAddress = to;
+            txValue = parseEther(amount);
+            if (txValue <= 0n) {
+                throw new CommandError("INVALID_AMOUNT", "Amount must be strictly greater than zero.", "Provide an amount > 0.");
+            }
+        }
+        else if (tokenUpper === "USDC") {
+            targetAddress = chain.usdc;
+            const parsedAmount = parseUnits(amount, 6);
+            if (parsedAmount <= 0n) {
+                throw new CommandError("INVALID_AMOUNT", "Amount must be strictly greater than zero.", "Provide an amount > 0.");
+            }
+            txData = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: "transfer",
+                args: [to, parsedAmount],
+            });
+        }
+        else if (/^0x[a-fA-F0-9]{40}$/.test(token.trim())) {
+            const customTokenAddress = token.trim();
+            const client = this.getPublicClient(chain.chainId);
+            const code = await client.getCode({ address: customTokenAddress });
+            if (!code || code === "0x") {
+                throw new CommandError("INVALID_TOKEN_CONTRACT", `No contract bytecode found at token address ${customTokenAddress} on chain ${chain.chainId}.`, "Provide a valid deployed ERC-20 token contract address.");
+            }
+            let decimals = 18;
+            try {
+                decimals = (await client.readContract({
+                    address: customTokenAddress,
+                    abi: erc20Abi,
+                    functionName: "decimals",
+                }));
+            }
+            catch (err) {
+                throw new CommandError("INVALID_TOKEN_CONTRACT", `Failed to read decimals from token contract ${customTokenAddress}: ${err?.message || String(err)}`, "Ensure the target address implements the ERC-20 standard.");
+            }
+            const parsedAmount = parseUnits(amount, decimals);
+            if (parsedAmount <= 0n) {
+                throw new CommandError("INVALID_AMOUNT", "Amount must be strictly greater than zero.", "Provide an amount > 0.");
+            }
+            targetAddress = customTokenAddress;
+            txData = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: "transfer",
+                args: [to, parsedAmount],
+            });
+        }
+        else {
+            throw new CommandError("UNSUPPORTED_TOKEN", `Token "${token}" is not supported. Supported tokens are MON, USDC, or a contract address (0x...).`, "Specify --token MON, --token USDC, or --token 0x<address>.");
+        }
+        const hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: targetAddress,
+            value: txValue,
+            data: txData,
+        });
+        io.emit(`Paid ${amount} ${tokenUpper === "MON" ? "MON" : token} to ${to} on ${chain.name}. TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            transactionHash: hash,
+            to,
+            amount,
+            token,
+            memo,
+            chainId: chain.chainId,
+        };
+    }
+}

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

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

package/dist/commands/monad/reputation/check.js

@@ -0,0 +1,103 @@
+import { resolveChain, erc8004ReputationAbi, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, } from "../../../sdk.js";
+import { PluginCommand, schemaToArgs } from "@metamask/agent-wallet/plugin";
+export class MonadReputationCheckCommand extends BaseMonadPluginCommand {
+    static description = "Check peer agent reputation on Monad ERC-8004 Reputation Registry";
+    static requiresAuth = false;
+    static requiresInit = false;
+    pluginCommandId = "monad:reputation:check";
+    static inputs = {
+        agentId: {
+            type: InputFieldType.Text,
+            flag: "agentId",
+            message: "Agent token ID in ERC-8004 registry",
+            required: true,
+            index: 0,
+        },
+        tag1: {
+            type: InputFieldType.Text,
+            flag: "tag1",
+            message: "Filter by primary category tag (e.g. speed)",
+            required: false,
+        },
+        tag2: {
+            type: InputFieldType.Text,
+            flag: "tag2",
+            message: "Filter by secondary category tag (e.g. task)",
+            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(MonadReputationCheckCommand.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 tag1 = rawInputs.tag1 || "";
+        const tag2 = rawInputs.tag2 || "";
+        const chain = resolveChain(rawInputs.chainId);
+        const client = this.getPublicClient(chain.chainId);
+        const tokenIdBigInt = BigInt(agentId);
+        // Official ERC-8004 requires clientAddresses array (reverts if empty without getClients)
+        let clientsToQuery = [];
+        try {
+            const registeredClients = await client.readContract({
+                address: chain.reputationRegistry,
+                abi: erc8004ReputationAbi,
+                functionName: "getClients",
+                args: [tokenIdBigInt],
+            });
+            if (registeredClients && Array.isArray(registeredClients)) {
+                clientsToQuery = registeredClients;
+            }
+        }
+        catch {
+            // Contract might have no clients or call failed
+        }
+        let feedbackCount = 0;
+        let averageScore = 0;
+        if (clientsToQuery.length > 0) {
+            try {
+                const [count, summaryValue, decimals] = await client.readContract({
+                    address: chain.reputationRegistry,
+                    abi: erc8004ReputationAbi,
+                    functionName: "getSummary",
+                    args: [tokenIdBigInt, clientsToQuery, tag1, tag2],
+                });
+                feedbackCount = Number(count);
+                const scoreDivider = 10 ** decimals;
+                averageScore =
+                    feedbackCount > 0 ? Number(summaryValue) / (feedbackCount * scoreDivider) : 0;
+            }
+            catch {
+                // Fallback to unrated if getSummary reverts
+            }
+        }
+        let trustTier = "UNRATED";
+        if (feedbackCount > 0) {
+            if (averageScore >= 80)
+                trustTier = "HIGH";
+            else if (averageScore >= 50)
+                trustTier = "MEDIUM";
+            else
+                trustTier = "LOW";
+        }
+        io.emit(`Agent #${agentId} Reputation on ${chain.name}: ${feedbackCount} reviews, Average: ${averageScore.toFixed(1)}, Trust Tier: ${trustTier}`);
+        return {
+            agentId,
+            feedbackCount,
+            averageScore,
+            trustTier,
+            chainId: chain.chainId,
+        };
+    }
+}

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

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

package/dist/commands/monad/reputation/give.js

@@ -0,0 +1,99 @@
+import { encodeFunctionData, keccak256, toHex } from "viem";
+import { resolveChain, erc8004ReputationAbi, monadReputationFeedbackSchema, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeTransaction, } from "../../../sdk.js";
+import { PluginCommand } from "@metamask/agent-wallet/plugin";
+export class MonadReputationGiveCommand extends BaseMonadPluginCommand {
+    static description = "Submit on-chain peer feedback to Monad ERC-8004 Reputation Registry";
+    pluginCommandId = "monad:reputation:give";
+    static inputs = {
+        agentId: {
+            type: InputFieldType.Text,
+            flag: "agentId",
+            message: "Target agent ID in ERC-8004 registry",
+            required: true,
+        },
+        value: {
+            type: InputFieldType.Text,
+            flag: "value",
+            message: "Feedback score (-100 to 100)",
+            required: true,
+        },
+        decimals: {
+            type: InputFieldType.Text,
+            flag: "decimals",
+            message: "Decimals for score (default 0)",
+            required: false,
+        },
+        tag1: {
+            type: InputFieldType.Text,
+            flag: "tag1",
+            message: "Primary feedback category tag (e.g. speed)",
+            required: false,
+        },
+        tag2: {
+            type: InputFieldType.Text,
+            flag: "tag2",
+            message: "Secondary category tag (e.g. accuracy)",
+            required: false,
+        },
+        endpoint: {
+            type: InputFieldType.Text,
+            flag: "endpoint",
+            message: "Service endpoint that performed the task",
+            required: false,
+        },
+        feedbackURI: {
+            type: InputFieldType.Text,
+            flag: "feedbackURI",
+            message: "URI pointing to detailed review or task proof",
+            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(MonadReputationGiveCommand.inputs);
+        const parsed = monadReputationFeedbackSchema.safeParse(rawInputs);
+        if (!parsed.success) {
+            throw new CommandError("INVALID_INPUT", `Invalid feedback input: ${parsed.error.issues.map((i) => i.message).join(", ")}`, "Provide a numeric agentId and score between -100 and 100.");
+        }
+        const feedback = parsed.data;
+        const chain = resolveChain(rawInputs.chainId);
+        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 hash = await executeTransaction(this.ctx, io, this.pluginCommandId, {
+            chainId: chain.chainId,
+            to: chain.reputationRegistry,
+            data,
+        });
+        io.emit(`Feedback submitted for Agent #${feedback.agentId} on ${chain.name}! Score: ${feedback.value}. TxHash: ${hash}`);
+        io.emit(`Explorer: ${chain.explorerUrl}/tx/${hash}`);
+        return {
+            transactionHash: hash,
+            feedback,
+            registryAddress: chain.reputationRegistry,
+            chainId: chain.chainId,
+        };
+    }
+}

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

@@ -0,0 +1,21 @@
+import { BaseMonadPluginCommand, type CommandIO, type InputSchema } from "../../../sdk.js";
+export interface X402PayResult {
+    url: string;
+    statusCode: number;
+    response: string;
+    paymentSettled: boolean;
+    paymentDetails?: {
+        scheme: string;
+        network: string;
+        asset: string;
+        amount: string;
+        payTo: string;
+    };
+}
+export declare class MonadX402PayCommand extends BaseMonadPluginCommand<X402PayResult> {
+    static description: string;
+    protected readonly pluginCommandId = "monad:x402:pay";
+    static readonly inputs: InputSchema;
+    static flags: any;
+    execute(io: CommandIO): Promise<X402PayResult>;
+}

package/dist/commands/monad/x402/pay.js

@@ -0,0 +1,224 @@
+import { x402Client, x402HTTPClient } from "@x402/core/client";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { recoverTypedDataAddress } from "viem";
+import { resolveChain, MONAD_TESTNET_USDC, MONAD_MAINNET_USDC, } from "../../../monad.js";
+import { BaseMonadPluginCommand, CommandError, InputFieldType, executeSignTypedData, } from "../../../sdk.js";
+import { PluginCommand } from "@metamask/agent-wallet/plugin";
+export class MonadX402PayCommand extends BaseMonadPluginCommand {
+    static description = "Execute paid tool/API call over HTTP 402 with real x402 EVM micropayments";
+    pluginCommandId = "monad:x402:pay";
+    static inputs = {
+        url: {
+            type: InputFieldType.Text,
+            flag: "url",
+            message: "Target HTTP 402 paid endpoint URL",
+            required: true,
+        },
+        method: {
+            type: InputFieldType.Text,
+            flag: "method",
+            message: "HTTP method (GET or POST)",
+            default: "GET",
+            required: false,
+        },
+        body: {
+            type: InputFieldType.Text,
+            flag: "body",
+            message: "HTTP request JSON body for POST requests",
+            required: false,
+        },
+        maxSpend: {
+            type: InputFieldType.Text,
+            flag: "maxSpend",
+            aliases: ["max-spend"],
+            message: "Maximum spend limit in token base units (e.g. 1000000 for 1 USDC)",
+            required: false,
+        },
+        payer: {
+            type: InputFieldType.Text,
+            flag: "payer",
+            message: "Payer EVM wallet address to sign payment authorization",
+            required: true,
+        },
+        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(MonadX402PayCommand.inputs);
+        const url = String(rawInputs.url).trim();
+        const method = (rawInputs.method || "GET").toUpperCase();
+        const body = rawInputs.body;
+        const maxSpend = BigInt(rawInputs.maxSpend || "1000000");
+        const rawPayer = String(rawInputs.payer || "").trim();
+        if (!/^0x[a-fA-F0-9]{40}$/.test(rawPayer) || rawPayer.toLowerCase() === "0x0000000000000000000000000000000000000000") {
+            throw new CommandError("INVALID_INPUT", `Invalid or missing --payer address "${rawPayer}". A non-zero EVM address is required.`, "Provide your agent wallet address using --payer 0x...");
+        }
+        const payerAddress = rawPayer;
+        io.emit(`Executing request to paid API: ${url}...`);
+        let initialRes;
+        try {
+            initialRes = await fetch(url, {
+                method,
+                headers: {
+                    Accept: "application/json",
+                    ...(body ? { "Content-Type": "application/json" } : {}),
+                },
+                body: method === "POST" && body ? body : undefined,
+            });
+        }
+        catch (err) {
+            throw new CommandError("FETCH_FAILED", `Failed to reach target URL: ${err?.message || String(err)}`, "Verify endpoint URL and network connectivity.");
+        }
+        if (initialRes.status !== 402) {
+            const text = await initialRes.text();
+            return {
+                url,
+                statusCode: initialRes.status,
+                response: text,
+                paymentSettled: false,
+            };
+        }
+        // Server returned 402 Payment Required. Parse x402 headers or JSON body.
+        const client = new x402Client();
+        const httpClient = new x402HTTPClient(client);
+        let paymentRequired;
+        try {
+            const headerVal = initialRes.headers.get("PAYMENT-REQUIRED") ||
+                initialRes.headers.get("payment-required");
+            const jsonBody = await initialRes.clone().json().catch(() => null);
+            if (headerVal) {
+                paymentRequired = httpClient.getPaymentRequiredResponse((name) => initialRes.headers.get(name), jsonBody);
+            }
+            else if (jsonBody && typeof jsonBody === "object") {
+                if (jsonBody.x402Version === 1) {
+                    paymentRequired = jsonBody;
+                }
+                else if (jsonBody.x402Version === 2 || jsonBody.accepts) {
+                    paymentRequired = {
+                        x402Version: jsonBody.x402Version || 2,
+                        accepts: jsonBody.accepts || [],
+                    };
+                }
+                else {
+                    throw new Error("Missing x402 accepts field in JSON body");
+                }
+            }
+            else {
+                throw new Error("No PAYMENT-REQUIRED header or JSON body present");
+            }
+        }
+        catch (err) {
+            throw new CommandError("INVALID_402_RESPONSE", `Server returned HTTP 402 but x402 Payment-Required headers/body could not be parsed: ${err?.message || String(err)}`, "Ensure the server implements the x402 protocol specification.");
+        }
+        // Resolve target chain from user input (defaults to 10143)
+        const targetChain = resolveChain(rawInputs.chainId);
+        // Inspect accepted payment requirements matching targetChain.caip2
+        const accepts = paymentRequired.accepts || [];
+        const requirement = accepts.find((req) => req.scheme === "exact" && req.network === targetChain.caip2);
+        if (!requirement) {
+            throw new CommandError("UNSUPPORTED_PAYMENT_NETWORK", `No compatible exact EVM payment requirement found for ${targetChain.name} (${targetChain.caip2}). Server accepts: ${JSON.stringify(accepts)}`, `Ensure the server supports ${targetChain.name} (${targetChain.caip2}).`);
+        }
+        const requestedAmount = BigInt(requirement.amount);
+        if (requestedAmount > maxSpend) {
+            throw new CommandError("MAX_SPEND_EXCEEDED", `Requested payment ${requestedAmount} exceeds maximum configured spend limit ${maxSpend}.`, "Increase --maxSpend if you wish to allow higher payment.");
+        }
+        const resolvedChain = targetChain;
+        // Enrich extra domain info if server didn't include it for USDC
+        const isUsdc = requirement.asset?.toLowerCase() === MONAD_TESTNET_USDC.toLowerCase() ||
+            requirement.asset?.toLowerCase() === MONAD_MAINNET_USDC.toLowerCase();
+        if (isUsdc && !requirement.extra) {
+            requirement.extra = {
+                name: "USDC",
+                version: "2",
+            };
+        }
+        if (!requirement.maxTimeoutSeconds) {
+            requirement.maxTimeoutSeconds = 3600;
+        }
+        io.emit(`Negotiating x402 payment: ${requirement.amount} (${requirement.asset}) on ${resolvedChain.name} (${requirement.network}) to ${requirement.payTo}...`);
+        // createPaymentPayload must sign EXACTLY the inspected requirement
+        const sanitizedPaymentRequired = {
+            ...paymentRequired,
+            accepts: [requirement],
+        };
+        // Build ClientEvmSigner backed by MetaMask walletExecutor
+        let lastTypedData = null;
+        let lastSignature = null;
+        const evmSigner = {
+            address: payerAddress,
+            signTypedData: async (typedDataMsg) => {
+                lastTypedData = typedDataMsg;
+                const sig = await executeSignTypedData(this.ctx, io, this.pluginCommandId, {
+                    chainId: resolvedChain.chainId,
+                    typedData: {
+                        domain: typedDataMsg.domain,
+                        types: typedDataMsg.types,
+                        primaryType: typedDataMsg.primaryType,
+                        message: typedDataMsg.message,
+                    },
+                });
+                lastSignature = sig;
+                return sig;
+            },
+        };
+        registerExactEvmScheme(client, { signer: evmSigner, networks: [requirement.network] });
+        let paymentPayload;
+        try {
+            paymentPayload = await httpClient.createPaymentPayload(sanitizedPaymentRequired);
+        }
+        catch (err) {
+            throw new CommandError("PAYMENT_PAYLOAD_FAILED", `Failed to generate x402 payment authorization: ${err?.message || String(err)}`, "Ensure wallet is unlocked and approved to sign EIP-712 payment authorization.");
+        }
+        // Verify signer matches payerAddress using recoverTypedDataAddress. Abort on ANY error.
+        if (lastTypedData && lastSignature) {
+            try {
+                const recovered = await recoverTypedDataAddress({
+                    domain: lastTypedData.domain,
+                    types: lastTypedData.types,
+                    primaryType: lastTypedData.primaryType,
+                    message: lastTypedData.message,
+                    signature: lastSignature,
+                });
+                if (recovered.toLowerCase() !== payerAddress.toLowerCase()) {
+                    throw new CommandError("PAYER_MISMATCH", `Recovered signature address ${recovered} does not match specified --payer ${payerAddress}.`, "Ensure the active wallet in MetaMask matches --payer.");
+                }
+            }
+            catch (err) {
+                if (err instanceof CommandError)
+                    throw err;
+                throw new CommandError("SIGNATURE_VERIFICATION_FAILED", `Failed to verify EIP-712 payment signature: ${err?.message || String(err)}`, "Verify that the wallet produced a valid EIP-712 signature.");
+            }
+        }
+        const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);
+        io.emit("x402 Payment authorization signed. Re-submitting request with payment proof...");
+        const paidRes = await fetch(url, {
+            method,
+            headers: {
+                Accept: "application/json",
+                ...(body ? { "Content-Type": "application/json" } : {}),
+                ...paymentHeaders,
+            },
+            body: method === "POST" && body ? body : undefined,
+        });
+        const responseText = await paidRes.text();
+        return {
+            url,
+            statusCode: paidRes.status,
+            response: responseText,
+            paymentSettled: paidRes.status >= 200 && paidRes.status < 300,
+            paymentDetails: {
+                scheme: requirement.scheme,
+                network: requirement.network,
+                asset: requirement.asset,
+                amount: requirement.amount,
+                payTo: requirement.payTo,
+            },
+        };
+    }
+}

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 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";
+export * from "./monad.js";
+export * from "./commands/monad/pay.js";
+export * from "./commands/monad/identity/register.js";
+export * from "./commands/monad/identity/get.js";
+export * from "./commands/monad/reputation/check.js";
+export * from "./commands/monad/reputation/give.js";
+export * from "./commands/monad/x402/pay.js";
+export * from "./commands/monad/jobs/create.js";
+export * from "./commands/monad/jobs/complete.js";
+export * from "./commands/monad/jobs/refund.js";

package/dist/index.js

@@ -1,8 +1,11 @@
 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";
+export * from "./monad.js";
+export * from "./commands/monad/pay.js";
+export * from "./commands/monad/identity/register.js";
+export * from "./commands/monad/identity/get.js";
+export * from "./commands/monad/reputation/check.js";
+export * from "./commands/monad/reputation/give.js";
+export * from "./commands/monad/x402/pay.js";
+export * from "./commands/monad/jobs/create.js";
+export * from "./commands/monad/jobs/complete.js";
+export * from "./commands/monad/jobs/refund.js";