helius-mcp 1.3.0 → 2.0.0

package/dist/utils/config.d.ts

@@ -6,7 +6,7 @@ interface HeliusConfig {
     network?: string;
     projectId?: string;
     preferences?: {
-        budget?: 'free' | 'developer' | 'business' | 'professional';
+        budget?: 'agent' | 'developer' | 'business' | 'professional';
         complexity?: 'low' | 'medium' | 'high';
     };
 }
@@ -17,7 +17,7 @@ export declare function setSharedApiKey(apiKey: string): void;
 export declare function getJwt(): string | undefined;
 export declare function setJwt(jwt: string): void;
 export declare function getPreferences(): {
-    budget?: "free" | "developer" | "business" | "professional";
+    budget?: "agent" | "developer" | "business" | "professional";
     complexity?: "low" | "medium" | "high";
 };
 export declare function savePreferences(prefs: HeliusConfig['preferences']): void;

package/dist/utils/config.js

@@ -9,17 +9,79 @@ function ensureDir() {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
     }
 }
+/** Best-effort recovery when config.json is corrupted (matches helius-cli behavior). */
+function recoverPartialConfig(raw) {
+    const recovered = {};
+    const patterns = [
+        { key: "jwt", regex: /"jwt"\s*:\s*"([^"]+)"/ },
+        { key: "apiKey", regex: /"apiKey"\s*:\s*"([^"]+)"/ },
+        {
+            key: "network",
+            regex: /"network"\s*:\s*"(mainnet|mainnet-beta|devnet)"/,
+        },
+        { key: "projectId", regex: /"projectId"\s*:\s*"([^"]+)"/ },
+    ];
+    for (const { key, regex } of patterns) {
+        const match = raw.match(regex);
+        if (match) {
+            recovered[key] = match[1];
+        }
+    }
+    const budgetMatch = raw.match(/"budget"\s*:\s*"(free|developer|business|professional)"/);
+    const complexityMatch = raw.match(/"complexity"\s*:\s*"(low|medium|high)"/);
+    if (budgetMatch || complexityMatch) {
+        recovered.preferences = {};
+        if (budgetMatch) {
+            recovered.preferences.budget = budgetMatch[1];
+        }
+        if (complexityMatch) {
+            recovered.preferences.complexity = complexityMatch[1];
+        }
+    }
+    return recovered;
+}
+function recoveredFieldSummary(cfg) {
+    const keys = [];
+    for (const k of Object.keys(cfg)) {
+        if (k === "preferences" && cfg.preferences) {
+            for (const pk of Object.keys(cfg.preferences)) {
+                keys.push(`preferences.${pk}`);
+            }
+        }
+        else if (k !== "preferences") {
+            keys.push(k);
+        }
+    }
+    return keys.join(", ");
+}
 export function loadConfig() {
+    if (!fs.existsSync(SHARED_CONFIG_PATH)) {
+        return {};
+    }
+    let raw;
     try {
-        if (fs.existsSync(SHARED_CONFIG_PATH)) {
-            const data = fs.readFileSync(SHARED_CONFIG_PATH, "utf-8");
-            return JSON.parse(data);
-        }
+        raw = fs.readFileSync(SHARED_CONFIG_PATH, "utf-8");
     }
     catch {
-        // Return empty config on error
+        console.error(`Warning: ${SHARED_CONFIG_PATH} exists but could not be read.`);
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const recovered = recoverPartialConfig(raw);
+        const summary = recoveredFieldSummary(recovered);
+        if (summary.length > 0) {
+            console.error(`Warning: ${SHARED_CONFIG_PATH} is corrupted (invalid JSON). Recovered fields: ${summary}.`);
+            saveConfig(recovered);
+            console.error("Repaired config saved. Fields that did not match known keys may have been lost.");
+            return recovered;
+        }
+        console.error(`Warning: ${SHARED_CONFIG_PATH} is corrupted (invalid JSON) and could not be recovered.`);
+        console.error('Run Helius MCP config helpers or edit the file manually; see CLI `helius config clear` if you use helius-cli.');
+        return {};
     }
-    return {};
 }
 export function saveConfig(config) {
     ensureDir();

package/dist/utils/errors.d.ts

@@ -5,8 +5,14 @@ type McpToolResponse = {
     }];
     isError?: boolean;
 };
+export type ErrorMeta = {
+    type: 'VALIDATION' | 'NOT_FOUND' | 'AUTH' | 'RATE_LIMIT' | 'INSUFFICIENT_FUNDS' | 'UNSUPPORTED' | 'HTTP' | 'API';
+    code: string;
+    retryable: boolean;
+    recovery: string;
+};
 export declare function mcpText(text: string): McpToolResponse;
-export declare function mcpError(text: string): McpToolResponse;
+export declare function mcpError(text: string, meta?: ErrorMeta): McpToolResponse;
 export declare function getErrorMessage(err: unknown): string;
 export declare function isAddressError(msg: string): boolean;
 export declare function isPaginationError(msg: string): boolean;
@@ -29,4 +35,7 @@ export declare function isValidAddressFormat(address: string): boolean;
 export declare function warnInvalidAddresses(paramName: string, addresses: string[]): string[];
 export declare function warnInvalidAddress(paramName: string, address: string): string | null;
 export declare function warnAddressConflicts(includeName: string, includeAddresses: string[] | undefined, excludeName: string, excludeAddresses: string[] | undefined): string | null;
+export declare function missingParamError(toolName: string, recovery: string): McpToolResponse;
+export declare function exclusiveParamError(toolName: string, paramA: string, paramB: string): McpToolResponse;
+export declare function batchLimitError(toolName: string, max: number, actual: number): McpToolResponse;
 export type { ErrorHandler, McpToolResponse };

package/dist/utils/errors.js

@@ -2,8 +2,11 @@
 export function mcpText(text) {
     return { content: [{ type: 'text', text }] };
 }
-export function mcpError(text) {
-    return { content: [{ type: 'text', text }], isError: true };
+export function mcpError(text, meta) {
+    const body = meta
+        ? '```json\n' + JSON.stringify(meta) + '\n```\n\n' + text
+        : text;
+    return { content: [{ type: 'text', text: body }], isError: true };
 }
 // ─── Error Message Extraction ───
 export function getErrorMessage(err) {
@@ -48,14 +51,14 @@ export function parseHttp400Messages(msg) {
 // ─── Enum Validation ───
 export function validateEnum(value, validOptions, context, fieldName) {
     if (!validOptions.includes(value)) {
-        return mcpText(`**${context}**\n\nInvalid ${fieldName} "${value}". Valid options: ${validOptions.join(', ')}`);
+        return mcpError(`**${context}**\n\nInvalid ${fieldName} "${value}". Valid options: ${validOptions.join(', ')}`, { type: 'VALIDATION', code: 'INVALID_ENUM', retryable: false, recovery: `Use one of: ${validOptions.join(', ')}` });
     }
     return null;
 }
 // ─── HTTP Status Guidance ───
 const HTTP_GUIDANCE = {
     '401': 'API key is invalid or expired. Call `setHeliusApiKey` with a valid key, or call `getAccountStatus` to check your current auth state.',
-    '403': 'This endpoint is restricted on your current plan. Call `getAccountStatus` to check your plan tier and remaining credits. Some endpoints (Enhanced Transactions, Token API) require Developer plan or higher. Call `getHeliusPlanInfo` to compare plans, or `previewUpgrade` to see upgrade pricing.',
+    '403': 'This endpoint is restricted on your current plan. Call `getAccountPlan` for a quick plan/feature check, or `getAccountStatus` for full details. Some endpoints require Developer plan or higher. Call `getHeliusPlanInfo` to compare plans, or `previewUpgrade` to see upgrade pricing.',
     '429': 'Rate limited. Call `getAccountStatus` to check your remaining credits and rate limits. Back off and retry, or call `previewUpgrade` to see upgrade options for higher limits.',
     '502': 'Backend temporarily unavailable. Retry after a few seconds.',
     '504': 'Gateway timeout — the request took too long. Try reducing the query scope (fewer addresses, smaller limit, narrower time range).',
@@ -68,6 +71,21 @@ function extractHttpGuidance(msg) {
     }
     return null;
 }
+const HTTP_META = {
+    '401': { type: 'AUTH', code: 'HTTP_401', retryable: false, recovery: HTTP_GUIDANCE['401'] },
+    '403': { type: 'AUTH', code: 'HTTP_403', retryable: false, recovery: HTTP_GUIDANCE['403'] },
+    '429': { type: 'RATE_LIMIT', code: 'HTTP_429', retryable: true, recovery: HTTP_GUIDANCE['429'] },
+    '502': { type: 'HTTP', code: 'HTTP_502', retryable: true, recovery: HTTP_GUIDANCE['502'] },
+    '504': { type: 'HTTP', code: 'HTTP_504', retryable: true, recovery: HTTP_GUIDANCE['504'] },
+};
+function extractHttpMeta(msg, _guidance) {
+    for (const [status, meta] of Object.entries(HTTP_META)) {
+        if (msg.includes(`HTTP ${status}`) || msg.includes(`status: ${status}`) || msg.includes(`(${status})`)) {
+            return meta;
+        }
+    }
+    return { type: 'API', code: 'UNKNOWN', retryable: false, recovery: 'Check the error message for details' };
+}
 export function handleToolError(err, fallbackPrefix, handlers) {
     const msg = getErrorMessage(err);
     if (handlers) {
@@ -78,33 +96,37 @@ export function handleToolError(err, fallbackPrefix, handlers) {
     }
     const guidance = extractHttpGuidance(msg);
     if (guidance) {
-        return mcpError(`**${fallbackPrefix}:** ${msg}\n\n${guidance}`);
+        const meta = extractHttpMeta(msg, guidance);
+        return mcpError(`**${fallbackPrefix}:** ${msg}\n\n${guidance}`, meta);
     }
-    return mcpError(`**${fallbackPrefix}:** ${msg}`);
+    return mcpError(`**${fallbackPrefix}:** ${msg}`, { type: 'API', code: 'UNKNOWN', retryable: false, recovery: 'Check the error message for details' });
 }
 // ─── Pre-built Handler Factories ───
 export function addressError(header, detail) {
+    const recovery = detail || 'Invalid Solana address. Please provide a valid base58-encoded address.';
     return {
         match: isAddressError,
-        respond: () => mcpText(`**${header}**\n\n${detail || 'Invalid Solana address. Please provide a valid base58-encoded address.'}`),
+        respond: () => mcpError(`**${header}**\n\n${recovery}`, { type: 'VALIDATION', code: 'INVALID_ADDRESS', retryable: false, recovery }),
     };
 }
 export function paginationError(header, detail) {
+    const recovery = detail || 'Invalid pagination parameters. Page must be at least 1 and limit must be between 1 and 1000.';
     return {
         match: isPaginationError,
-        respond: () => mcpText(`**${header}**\n\n${detail || 'Invalid pagination parameters. Page must be at least 1 and limit must be between 1 and 1000.'}`),
+        respond: () => mcpError(`**${header}**\n\n${recovery}`, { type: 'VALIDATION', code: 'INVALID_PAGINATION', retryable: false, recovery }),
     };
 }
 export function notFoundError(header, detail) {
+    const recovery = detail || 'Asset not found. This mint address does not exist or has not been indexed.';
     return {
         match: isNotFoundError,
-        respond: () => mcpText(`**${header}**\n\n${detail || 'Asset not found. This mint address does not exist or has not been indexed.'}`),
+        respond: () => mcpError(`**${header}**\n\n${recovery}`, { type: 'NOT_FOUND', code: 'RESOURCE_NOT_FOUND', retryable: false, recovery }),
     };
 }
 export function http404Error(header, detail) {
     return {
         match: isHttp404Error,
-        respond: () => header ? mcpText(`**${header}**\n\n${detail}`) : mcpText(detail),
+        respond: () => mcpError(header ? `**${header}**\n\n${detail}` : detail, { type: 'NOT_FOUND', code: 'HTTP_404', retryable: false, recovery: detail }),
     };
 }
 export function http400Error(header) {
@@ -113,9 +135,9 @@ export function http400Error(header) {
         respond: (msg) => {
             const messages = parseHttp400Messages(msg);
             if (messages) {
-                return mcpText(`**${header}**\n\n${messages.map((m) => `- ${m}`).join('\n')}`);
+                return mcpError(`**${header}**\n\n${messages.map((m) => `- ${m}`).join('\n')}`, { type: 'API', code: 'BAD_REQUEST', retryable: false, recovery: 'Fix the request parameters' });
             }
-            return mcpError(`**${header}:** ${msg}`);
+            return mcpError(`**${header}:** ${msg}`, { type: 'API', code: 'BAD_REQUEST', retryable: false, recovery: 'Fix the request parameters' });
         },
     };
 }
@@ -155,3 +177,15 @@ export function warnAddressConflicts(includeName, includeAddresses, excludeName,
     }
     return null;
 }
+// ─── Convenience Error Helpers ───
+export function missingParamError(toolName, recovery) {
+    return mcpError(`**${toolName} Error**\n\n${recovery}`, { type: 'VALIDATION', code: 'MISSING_PARAM', retryable: false, recovery });
+}
+export function exclusiveParamError(toolName, paramA, paramB) {
+    const recovery = `Provide either \`${paramA}\` or \`${paramB}\`, not both.`;
+    return mcpError(`**${toolName} Error**\n\n${recovery}`, { type: 'VALIDATION', code: 'EXCLUSIVE_PARAMS', retryable: false, recovery });
+}
+export function batchLimitError(toolName, max, actual) {
+    const recovery = `Reduce batch to ${max} or fewer items.`;
+    return mcpError(`**${toolName} Error**\n\nMaximum ${max} items per request. You provided ${actual}.`, { type: 'VALIDATION', code: 'TOO_MANY_ITEMS', retryable: false, recovery });
+}

package/dist/utils/feedback.js

@@ -8,7 +8,6 @@ const POSTHOG_API_KEY = 'phc_aLmID5mMwUZi3pVhG4HomDeZaWZ1PqAEkWTempDogzi';
 const HELIUS_DIR = path.join(os.homedir(), '.helius');
 const ANON_ID_PATH = path.join(HELIUS_DIR, 'anon-id');
 let clientInfo = null;
-let feedbackEnabled = true;
 let walletAddress = null;
 let identifySent = false;
 // Persistent anonymous ID shared with helius-cli.
@@ -47,8 +46,6 @@ function getDistinctId() {
     return walletAddress || sessionId;
 }
 function posthogCapture(event, properties) {
-    if (!feedbackEnabled)
-        return;
     fetch(POSTHOG_ENDPOINT, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -58,7 +55,7 @@ function posthogCapture(event, properties) {
             properties,
         }),
     }).catch(() => {
-        feedbackEnabled = false;
+        /* ignore delivery failure */
     });
 }
 export function sendFeedbackEvent(event) {

package/dist/utils/helius.js

@@ -59,7 +59,8 @@ export function getEnhancedWebSocketUrl() {
     return `wss://atlas-mainnet.helius-rpc.com/?api-key=${apiKey}`;
 }
 export function getLaserstreamUrl(region) {
-    const apiKey = getApiKey();
+    // Endpoint host is public; clients pass apiKey separately (e.g. @helius/laserstream subscribe options).
+    // Do not call getApiKey() here or docs tools like getLaserstreamInfo fail unnecessarily.
     const network = getNetwork();
     if (network === 'devnet') {
         return `https://laserstream-devnet-ewr.helius-rpc.com`;

package/dist/utils/ows.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Open Wallet Standard (OWS) integration.
+ *
+ * Provides an optional, additive signing path that delegates to the `ows` CLI
+ * for policy-gated, key-isolated transaction signing.  When an `owsWallet`
+ * parameter is supplied, transfers and staking tools use an OWS-backed signer
+ * instead of the local keypair.  If OWS is not installed, callers get a clear
+ * error — existing keypair flows are unaffected.
+ *
+ * The adapter implements the same duck-typed signer interface that @solana/kit
+ * expects ({ address, signTransactions, signMessages }), so it plugs directly
+ * into the Helius SDK's sendTransactionWithSender / sendSmartTransaction
+ * without losing priority-fee estimation, SWQoS routing, or Jito tips.
+ *
+ * NOTE: The CLI helpers (isOwsInstalled, getOwsSolanaAddress) are mirrored in
+ * helius-cli/src/lib/ows.ts.  Keep the two copies in sync when changing
+ * argument handling, CAIP-2 lookup logic, or OWS CLI flags.
+ */
+import { type Address } from '@solana/kit';
+import { mcpError } from './errors.js';
+/**
+ * True when the `ows` binary is reachable on PATH.
+ */
+export declare function isOwsInstalled(): Promise<boolean>;
+/**
+ * Return the Solana address for the named OWS wallet.
+ * Uses the current MCP session network (mainnet or devnet) to select
+ * the correct CAIP-2 chain key.
+ */
+export declare function getOwsSolanaAddress(walletName: string): Promise<string>;
+/**
+ * A duck-typed @solana/kit TransactionPartialSigner backed by OWS.
+ *
+ * Passes `isTransactionSigner()` checks and works with
+ * `setTransactionMessageFeePayerSigner`, `signTransactionMessageWithSigners`,
+ * `sendTransactionWithSender`, and `sendSmartTransaction`.
+ *
+ * IMPORTANT: `signTransactions` and `signMessages` return **partial signature
+ * maps** (`{ [address]: signatureBytes }`), NOT full transaction/message objects.
+ * This matches the contract that `@solana/kit`'s `signTransactionMessageWithSigners`
+ * expects — it merges the partial maps back into the compiled transaction itself.
+ */
+export interface OwsSigner {
+    address: Address;
+    signTransactions: (transactions: readonly {
+        messageBytes: Uint8Array;
+    }[]) => Promise<readonly Record<string, Uint8Array>[]>;
+    signMessages: (messages: readonly {
+        content: Uint8Array;
+    }[]) => Promise<readonly Record<string, Uint8Array>[]>;
+}
+/**
+ * Resolve a signer from an OWS wallet name or the local Helius keypair.
+ * Returns a result-union so callers can return the MCP error directly.
+ *
+ * The returned `signer` is typed as `any` to avoid @solana/kit branded-type
+ * friction — it satisfies `isTransactionSigner()` at runtime.
+ *
+ * ⚠ If @solana/kit changes its signer interface (signTransactions /
+ * signMessages argument or return shapes), these casts will pass type-checking
+ * but fail at runtime.  After any @solana/kit upgrade, verify the OWS signer
+ * still passes `isTransactionSigner()` and produces valid signatures in the
+ * full `signTransactionMessageWithSigners` pipeline.
+ */
+export declare function resolveOwsOrKeypairSigner(owsWallet?: string): Promise<{
+    ok: true;
+    signer: any;
+    walletAddress: string;
+    owsWallet?: string;
+} | {
+    ok: false;
+    error: ReturnType<typeof mcpError>;
+}>;
+export declare function createOwsSigner(walletName: string): Promise<OwsSigner>;

package/dist/utils/ows.js

@@ -0,0 +1,155 @@
+/**
+ * Open Wallet Standard (OWS) integration.
+ *
+ * Provides an optional, additive signing path that delegates to the `ows` CLI
+ * for policy-gated, key-isolated transaction signing.  When an `owsWallet`
+ * parameter is supplied, transfers and staking tools use an OWS-backed signer
+ * instead of the local keypair.  If OWS is not installed, callers get a clear
+ * error — existing keypair flows are unaffected.
+ *
+ * The adapter implements the same duck-typed signer interface that @solana/kit
+ * expects ({ address, signTransactions, signMessages }), so it plugs directly
+ * into the Helius SDK's sendTransactionWithSender / sendSmartTransaction
+ * without losing priority-fee estimation, SWQoS routing, or Jito tips.
+ *
+ * NOTE: The CLI helpers (isOwsInstalled, getOwsSolanaAddress) are mirrored in
+ * helius-cli/src/lib/ows.ts.  Keep the two copies in sync when changing
+ * argument handling, CAIP-2 lookup logic, or OWS CLI flags.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { address, createKeyPairSignerFromBytes } from '@solana/kit';
+import { loadSignerOrFail, getNetwork } from './helius.js';
+import { mcpError } from './errors.js';
+const execFileAsync = promisify(execFile);
+// CAIP-2 chain identifiers for Solana networks.
+// See OWS spec 07-supported-chains.md.
+const SOLANA_CAIP2_MAINNET = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';
+const SOLANA_CAIP2_DEVNET = 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG';
+/** Alphanumeric, hyphens, and underscores — matches OWS wallet naming rules. */
+const WALLET_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+// ── CLI helpers ──
+/**
+ * True when the `ows` binary is reachable on PATH.
+ */
+export async function isOwsInstalled() {
+    try {
+        await execFileAsync('ows', ['--version'], { timeout: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate wallet name format before passing to execFile.
+ * While execFile prevents shell injection, a garbage name produces
+ * confusing OWS CLI errors — better to catch it early.
+ */
+function validateWalletName(name) {
+    if (!WALLET_NAME_RE.test(name)) {
+        throw new Error(`Invalid OWS wallet name "${name}". ` +
+            `Names must be 1-64 characters using letters, digits, hyphens, or underscores.`);
+    }
+}
+/**
+ * Return the Solana address for the named OWS wallet.
+ * Uses the current MCP session network (mainnet or devnet) to select
+ * the correct CAIP-2 chain key.
+ */
+export async function getOwsSolanaAddress(walletName) {
+    validateWalletName(walletName);
+    const { stdout } = await execFileAsync('ows', ['wallet', 'info', '--wallet', walletName, '--json'], { timeout: 10_000 });
+    const info = JSON.parse(stdout);
+    // The CLI outputs accounts keyed by CAIP-2 chain id.
+    // Pick the key matching the active network.
+    const network = getNetwork();
+    const primaryKey = network === 'devnet' ? SOLANA_CAIP2_DEVNET : SOLANA_CAIP2_MAINNET;
+    const account = info.accounts?.[primaryKey] ??
+        info.accounts?.solana ??
+        // Fallback: scan for any key containing "solana"
+        Object.entries(info.accounts ?? {}).find(([k]) => k.includes('solana'))?.[1];
+    if (!account) {
+        throw new Error(`OWS wallet "${walletName}" has no Solana account.  ` +
+            `Run \`ows wallet info --wallet ${walletName}\` to inspect.`);
+    }
+    // Account may be a string (address) or an object with an address field.
+    const addr = typeof account === 'string' ? account : account.address;
+    if (!addr) {
+        throw new Error(`Could not extract Solana address from OWS wallet "${walletName}".`);
+    }
+    return addr;
+}
+/**
+ * Sign raw message bytes via OWS.  Returns the 64-byte Ed25519 signature.
+ * Assumes walletName was already validated by the caller (createOwsSigner).
+ */
+async function owsSignBytes(walletName, messageHex) {
+    const { stdout } = await execFileAsync('ows', ['sign', 'message', '--wallet', walletName, '--chain', 'solana', '--message', messageHex, '--encoding', 'hex', '--json'], { timeout: 30_000 });
+    const result = JSON.parse(stdout);
+    const sigHex = result.signature;
+    if (!sigHex) {
+        throw new Error('OWS sign returned no signature');
+    }
+    return Uint8Array.from(Buffer.from(sigHex, 'hex'));
+}
+// ── Shared signer resolution ──
+/**
+ * Resolve a signer from an OWS wallet name or the local Helius keypair.
+ * Returns a result-union so callers can return the MCP error directly.
+ *
+ * The returned `signer` is typed as `any` to avoid @solana/kit branded-type
+ * friction — it satisfies `isTransactionSigner()` at runtime.
+ *
+ * ⚠ If @solana/kit changes its signer interface (signTransactions /
+ * signMessages argument or return shapes), these casts will pass type-checking
+ * but fail at runtime.  After any @solana/kit upgrade, verify the OWS signer
+ * still passes `isTransactionSigner()` and produces valid signatures in the
+ * full `signTransactionMessageWithSigners` pipeline.
+ */
+export async function resolveOwsOrKeypairSigner(owsWallet) {
+    if (owsWallet) {
+        if (!WALLET_NAME_RE.test(owsWallet)) {
+            return { ok: false, error: mcpError(`Invalid OWS wallet name "${owsWallet}". Names must be 1-64 characters using letters, digits, hyphens, or underscores.`, { type: 'VALIDATION', code: 'INVALID_WALLET_NAME', retryable: false, recovery: 'Provide a valid wallet name (letters, digits, hyphens, underscores).' }) };
+        }
+        if (!await isOwsInstalled()) {
+            return { ok: false, error: mcpError('OWS CLI is not installed. Install it with `curl -fsSL https://docs.openwallet.sh/install.sh | bash` or `npm install -g @open-wallet-standard/core`.', { type: 'AUTH', code: 'OWS_NOT_INSTALLED', retryable: false, recovery: 'Install the OWS CLI, then retry.' }) };
+        }
+        try {
+            const signer = await createOwsSigner(owsWallet);
+            return { ok: true, signer, walletAddress: signer.address, owsWallet };
+        }
+        catch (err) {
+            return { ok: false, error: mcpError(`Failed to load OWS wallet "${owsWallet}": ${err.message}`, { type: 'AUTH', code: 'OWS_WALLET_ERROR', retryable: false, recovery: 'Run `ows wallet list` to see available wallets.' }) };
+        }
+    }
+    try {
+        const signerData = await loadSignerOrFail();
+        const signer = await createKeyPairSignerFromBytes(signerData.secretKey);
+        return { ok: true, signer, walletAddress: signerData.walletAddress };
+    }
+    catch {
+        return { ok: false, error: mcpError('No keypair found. Call `generateKeypair` first to create a wallet.', { type: 'AUTH', code: 'NO_KEYPAIR', retryable: false, recovery: 'Call `generateKeypair` to create a wallet.' }) };
+    }
+}
+export async function createOwsSigner(walletName) {
+    const solAddress = await getOwsSolanaAddress(walletName);
+    const addr = address(solAddress);
+    return {
+        address: addr,
+        async signTransactions(transactions) {
+            return Promise.all(transactions.map(async (tx) => {
+                const msgHex = Buffer.from(tx.messageBytes).toString('hex');
+                const sig = await owsSignBytes(walletName, msgHex);
+                return { [addr]: sig };
+            }));
+        },
+        async signMessages(messages) {
+            return Promise.all(messages.map(async (msg) => {
+                const hex = Buffer.from(msg.content).toString('hex');
+                const sig = await owsSignBytes(walletName, hex);
+                return { [addr]: sig };
+            }));
+        },
+    };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.3.0";
+export declare const version = "2.0.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '1.3.0';
+export const version = '2.0.0';

package/package.json

@@ -1,64 +1,64 @@
-{
-  "name": "helius-mcp",
-  "version": "1.3.0",
-  "description": "Official Helius MCP Server - Complete Solana blockchain data access for AI assistants",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "helius-mcp": "dist/index.js"
-  },
-  "scripts": {
-    "prebuild": "node -p \"'export const version = \\'' + require('./package.json').version + '\\';'\" > src/version.ts",
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "start": "node dist/index.js",
-    "validate": "node dist/scripts/validate-catalog.js",
-    "test": "pnpm build && pnpm validate && vitest run",
-    "changelog": "auto-changelog --tag-prefix helius-mcp@",
-    "prepublishOnly": "pnpm build"
-  },
-  "keywords": [
-    "helius",
-    "solana",
-    "blockchain",
-    "mcp",
-    "model-context-protocol",
-    "ai",
-    "llm",
-    "claude",
-    "web3",
-    "nft",
-    "defi",
-    "websocket",
-    "laserstream"
-  ],
-  "author": "Helius Labs",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/helius-labs/core-ai"
-  },
-  "homepage": "https://github.com/helius-labs/core-ai#readme",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "@solana-program/system": "^0.10.0",
-    "@solana-program/token": "^0.9.0",
-    "@solana/kit": "^5.0.0",
-    "bs58": "^6.0.0",
-    "helius-sdk": "^2.2.2",
-    "zod": "^3.23.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "auto-changelog": "^2.5.0",
-    "typescript": "^5.4.0",
-    "vitest": "^2.0.0"
-  },
-  "files": [
-    "dist",
-    "system-prompts",
-    "CHANGELOG.md",
-    "README.md",
-    "LICENSE"
-  ]
-}
+{
+  "name": "helius-mcp",
+  "version": "2.0.0",
+  "description": "Official Helius MCP Server - Complete Solana blockchain data access for AI assistants",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "helius-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "prebuild": "node -p \"'export const version = \\'' + require('./package.json').version + '\\';'\" > src/version.ts",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "validate": "node dist/scripts/validate-catalog.js",
+    "test": "pnpm build && pnpm validate && vitest run",
+    "changelog": "auto-changelog --tag-prefix helius-mcp@",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "helius",
+    "solana",
+    "blockchain",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "llm",
+    "claude",
+    "web3",
+    "nft",
+    "defi",
+    "websocket",
+    "laserstream"
+  ],
+  "author": "Helius Labs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/helius-labs/core-ai"
+  },
+  "homepage": "https://github.com/helius-labs/core-ai#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@solana-program/system": "^0.10.0",
+    "@solana-program/token": "^0.9.0",
+    "@solana/kit": "^5.0.0",
+    "bs58": "^6.0.0",
+    "helius-sdk": "^3.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "auto-changelog": "^2.5.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "files": [
+    "dist",
+    "system-prompts",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ]
+}