@zakyirsyaad/monagent-plugin 0.1.0 → 0.1.3

package/dist/sdk.d.ts

@@ -1,52 +1,75 @@
-import type { PublicClient } from "viem";
+import { PluginCommand, type CommandIO, type PluginCommandContext, CommandError, InputFieldType, type InputSchema } from "@metamask/agent-wallet/plugin";
+import { type PublicClient } from "viem";
+export declare abstract class BaseMonadPluginCommand<TFinal = void> extends PluginCommand<TFinal> {
+    static description: string;
+    ctx: PluginCommandContext;
+    protected abstract readonly pluginCommandId: string;
+    setContext(ctx: PluginCommandContext): void;
+    /**
+     * Get an EVM PublicClient for reads, preferring the host's publicClient if available,
+     * with fallback to canonical Monad RPC specifically on transport errors (e.g. host Infura
+     * proxy returning 400 "Invalid chainId" when querying testnet 10143).
+     */
+    getPublicClient(chainId?: number): PublicClient;
+}
+export { type CommandIO, type PluginCommandContext, CommandError, InputFieldType, type InputSchema, type PublicClient, };
 /**
- * Standard CommandIO interface conforming to @metamask/agent-wallet/plugin
+ * EVM Transaction payload expected by MetaMask EvmWalletExecutor
  */
-export interface CommandIO {
-    resolveInputs<T>(schema: unknown): Promise<T>;
-    log(message: string): void;
-    error(message: string): void;
-    warn(message: string): void;
+export interface EvmTxParams {
+    to: `0x${string}`;
+    value?: bigint;
+    data?: `0x${string}`;
 }
-export type WalletExecutorRequest = {
+export interface EvmExecutorTransactionRequest {
     kind: "transaction";
     chainId: number;
-    to: string;
-    value?: bigint;
-    data?: `0x${string}`;
-} | {
+    transaction: EvmTxParams;
+}
+export interface EvmExecutorTypedDataRequest {
+    kind: "typed-data";
+    chainId: number;
+    typedData: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    };
+}
+export interface EvmExecutorMessageRequest {
     kind: "message";
+    chainId: number;
     message: string;
-} | {
-    kind: "typed-data";
-    domain: Record<string, unknown>;
-    types: Record<string, unknown>;
-    primaryType: string;
-    message: Record<string, unknown>;
-};
-export interface WalletExecutorResult {
+}
+export type EvmExecutorRequest = EvmExecutorTransactionRequest | EvmExecutorTypedDataRequest | EvmExecutorMessageRequest;
+export interface EvmExecutorResult {
+    kind?: string;
     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;
+    status: "CONFIRMED" | "SUBMITTED" | "FAILED" | "REJECTED" | string;
+    failureDescription?: string;
+    pendingJob?: {
+        pollingId?: string;
     };
 }
 /**
- * Base PluginCommand class simulating the sealed host lifecycle of MetaMask Agent Wallet
+ * Helper function to execute transactions through MetaMask EvmWalletExecutor
  */
-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>;
-}
+export declare function executeTransaction(ctx: PluginCommandContext, io: CommandIO, source: string, params: {
+    chainId: number;
+    to: `0x${string}`;
+    value?: bigint;
+    data?: `0x${string}`;
+}): Promise<`0x${string}`>;
+/**
+ * Helper function to sign typed data (EIP-712) through MetaMask EvmWalletExecutor
+ */
+export declare function executeSignTypedData(ctx: PluginCommandContext, io: CommandIO, source: string, params: {
+    chainId: number;
+    typedData: {
+        domain: Record<string, unknown>;
+        types: Record<string, unknown>;
+        primaryType: string;
+        message: Record<string, unknown>;
+    };
+}): Promise<`0x${string}`>;

package/dist/sdk.js

@@ -1,12 +1,99 @@
-/**
- * Base PluginCommand class simulating the sealed host lifecycle of MetaMask Agent Wallet
- */
-export class PluginCommand {
-    static description = "";
-    static requiresAuth = true;
-    static requiresInit = true;
-    ctx;
+import { PluginCommand, CommandError, InputFieldType, } from "@metamask/agent-wallet/plugin";
+import { createPublicClient, http, HttpRequestError } from "viem";
+import { resolveChain, MONAD_TESTNET_CHAIN_ID } from "./monad.js";
+export class BaseMonadPluginCommand extends PluginCommand {
+    static description;
     setContext(ctx) {
         this.ctx = ctx;
     }
+    /**
+     * Get an EVM PublicClient for reads, preferring the host's publicClient if available,
+     * with fallback to canonical Monad RPC specifically on transport errors (e.g. host Infura
+     * proxy returning 400 "Invalid chainId" when querying testnet 10143).
+     */
+    getPublicClient(chainId = MONAD_TESTNET_CHAIN_ID) {
+        const chain = resolveChain(chainId);
+        const directClient = createPublicClient({
+            transport: http(chain.rpcUrl),
+        });
+        if (this.ctx && typeof this.ctx.publicClient === "function") {
+            try {
+                const hostClient = this.ctx.publicClient(chain.chainId);
+                return new Proxy(hostClient, {
+                    get(target, prop, receiver) {
+                        const orig = Reflect.get(target, prop, receiver);
+                        if (typeof orig === "function") {
+                            return (...args) => {
+                                const res = orig.apply(target, args);
+                                // Only wrap promises to preserve sync behavior of synchronous methods
+                                if (res && typeof res.then === "function") {
+                                    return res.catch((err) => {
+                                        const errMsg = String(err?.message || err);
+                                        const isTransportError = err instanceof HttpRequestError ||
+                                            err?.cause instanceof HttpRequestError ||
+                                            err?.name === "HttpRequestError" ||
+                                            err?.cause?.name === "HttpRequestError" ||
+                                            (typeof err?.status === "number" && (err.status === 400 || err.status === 500)) ||
+                                            (typeof err?.cause?.status === "number" && (err.cause.status === 400 || err.cause.status === 500)) ||
+                                            errMsg.includes("HTTP request failed") ||
+                                            errMsg.includes("Invalid chainId") ||
+                                            errMsg.includes("MISSING_PROJECT_ID") ||
+                                            errMsg.includes("fetch failed");
+                                        if (isTransportError) {
+                                            const fallbackFn = Reflect.get(directClient, prop, directClient);
+                                            if (typeof fallbackFn === "function") {
+                                                return fallbackFn.apply(directClient, args);
+                                            }
+                                        }
+                                        throw err;
+                                    });
+                                }
+                                return res;
+                            };
+                        }
+                        return orig;
+                    },
+                });
+            }
+            catch {
+                // Host resolution threw synchronously (e.g. missing projectId)
+            }
+        }
+        return directClient;
+    }
+}
+export { CommandError, InputFieldType, };
+/**
+ * Helper function to execute transactions through MetaMask EvmWalletExecutor
+ */
+export async function executeTransaction(ctx, io, source, params) {
+    const executor = await ctx.walletExecutor(io, source);
+    const res = (await executor({
+        kind: "transaction",
+        chainId: params.chainId,
+        transaction: {
+            to: params.to,
+            value: params.value,
+            data: params.data,
+        },
+    }, { signal: io.signal }));
+    if ((res.status !== "CONFIRMED" && res.status !== "SUBMITTED") || !res.hash) {
+        throw new CommandError("TRANSACTION_FAILED", `Transaction failed on Monad: ${res.failureDescription || res.status}`, "Check wallet balance and RPC connectivity, then retry.");
+    }
+    return res.hash;
+}
+/**
+ * Helper function to sign typed data (EIP-712) through MetaMask EvmWalletExecutor
+ */
+export async function executeSignTypedData(ctx, io, source, params) {
+    const executor = await ctx.walletExecutor(io, source);
+    const res = (await executor({
+        kind: "typed-data",
+        chainId: params.chainId,
+        typedData: params.typedData,
+    }, { signal: io.signal }));
+    if (res.status !== "CONFIRMED" || !res.signature) {
+        throw new CommandError("SIGNING_FAILED", `EIP-712 signing failed: ${res.failureDescription || res.status}`, "Ensure wallet is unlocked and approved.");
+    }
+    return res.signature;
 }