@manifest-network/manifest-mcp-core 0.1.0

package/dist/retry.d.ts

@@ -0,0 +1,48 @@
+import { RetryConfig } from "./types.js";
+
+//#region src/retry.d.ts
+/** Default retry configuration */
+declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
+/**
+ * Determine if an error is retryable
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Calculate delay with exponential backoff and jitter
+ * @param attempt - Current attempt number (0-indexed)
+ * @param baseDelayMs - Base delay in milliseconds
+ * @param maxDelayMs - Maximum delay cap
+ * @returns Delay in milliseconds
+ */
+declare function calculateBackoff(attempt: number, baseDelayMs: number, maxDelayMs: number): number;
+/**
+ * Options for the retry wrapper
+ */
+interface RetryOptions {
+  /** Retry configuration */
+  config?: RetryConfig;
+  /** Operation name for error messages */
+  operationName?: string;
+  /** Callback invoked before each retry attempt */
+  onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
+}
+/**
+ * Execute an async operation with retry logic for transient failures
+ *
+ * @param operation - Async function to execute
+ * @param options - Retry options
+ * @returns Result of the operation
+ * @throws The last error if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => fetchData(),
+ *   { config: { maxRetries: 3 }, operationName: 'fetchData' }
+ * );
+ * ```
+ */
+declare function withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//#endregion
+export { DEFAULT_RETRY_CONFIG, RetryOptions, calculateBackoff, isRetryableError, withRetry };
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","names":[],"sources":["../src/retry.ts"],"mappings":";;;;cAOa,oBAAA,EAAsB,QAAA,CAAS,WAAA;AAA5C;;;AAAA,iBAqFgB,gBAAA,CAAiB,KAAA;;AAAjC;;;;;AA0BA;iBAAgB,gBAAA,CACd,OAAA,UACA,WAAA,UACA,UAAA;;;;UAwBe,YAAA;EAxBf;EA0BA,MAAA,GAAS,WAAA;EA1BS;EA4BlB,aAAA;EAJ2B;EAM3B,OAAA,IAAW,KAAA,WAAgB,OAAA,UAAiB,OAAA;AAAA;;;;;;;;;;AAmB9C;;;;;;;iBAAsB,SAAA,GAAA,CACpB,SAAA,QAAiB,OAAA,CAAQ,CAAA,GACzB,OAAA,GAAS,YAAA,GACR,OAAA,CAAQ,CAAA"}

package/dist/retry.js

@@ -0,0 +1,106 @@
+import { ManifestMCPError, ManifestMCPErrorCode } from "./types.js";
+//#region src/retry.ts
+/** Default retry configuration */
+const DEFAULT_RETRY_CONFIG = {
+	maxRetries: 3,
+	baseDelayMs: 1e3,
+	maxDelayMs: 1e4
+};
+/**
+* Error codes that should NOT be retried (permanent failures)
+*/
+const NON_RETRYABLE_ERROR_CODES = [
+	ManifestMCPErrorCode.INVALID_CONFIG,
+	ManifestMCPErrorCode.MISSING_CONFIG,
+	ManifestMCPErrorCode.WALLET_NOT_CONNECTED,
+	ManifestMCPErrorCode.WALLET_CONNECTION_FAILED,
+	ManifestMCPErrorCode.INVALID_MNEMONIC,
+	ManifestMCPErrorCode.INVALID_ADDRESS,
+	ManifestMCPErrorCode.UNSUPPORTED_TX,
+	ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+	ManifestMCPErrorCode.UNKNOWN_MODULE,
+	ManifestMCPErrorCode.TX_FAILED,
+	ManifestMCPErrorCode.TX_BROADCAST_FAILED,
+	ManifestMCPErrorCode.INSUFFICIENT_FUNDS
+];
+/**
+* Check if an error message indicates a transient failure that should be retried.
+*
+* Uses specific patterns to avoid false positives (e.g. "proposal 500" matching
+* bare "500", or "connection to validator not authorized" matching "connection").
+*/
+function isTransientErrorMessage(message) {
+	const lowerMessage = message.toLowerCase();
+	if (lowerMessage.includes("econnrefused") || lowerMessage.includes("econnreset") || lowerMessage.includes("etimedout") || lowerMessage.includes("enotfound") || lowerMessage.includes("epipe") || lowerMessage.includes("socket hang up") || lowerMessage.includes("timed out") || lowerMessage.includes("network request failed") || lowerMessage.includes("fetch failed")) return true;
+	if (/\b(?:http|status)\s*5\d{2}\b/.test(lowerMessage)) return true;
+	if (lowerMessage.includes("internal server error") || lowerMessage.includes("bad gateway") || lowerMessage.includes("service unavailable") || lowerMessage.includes("gateway timeout")) return true;
+	if (/\b429\b/.test(lowerMessage) || lowerMessage.includes("too many requests")) return true;
+	return false;
+}
+/**
+* Determine if an error is retryable
+*/
+function isRetryableError(error) {
+	if (error instanceof ManifestMCPError) {
+		if (NON_RETRYABLE_ERROR_CODES.includes(error.code)) return false;
+		return isTransientErrorMessage(error.message);
+	}
+	if (error instanceof Error) return isTransientErrorMessage(error.message);
+	return false;
+}
+/**
+* Calculate delay with exponential backoff and jitter
+* @param attempt - Current attempt number (0-indexed)
+* @param baseDelayMs - Base delay in milliseconds
+* @param maxDelayMs - Maximum delay cap
+* @returns Delay in milliseconds
+*/
+function calculateBackoff(attempt, baseDelayMs, maxDelayMs) {
+	const exponentialDelay = baseDelayMs * 2 ** attempt;
+	const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+	const jitter = cappedDelay * .25 * (Math.random() * 2 - 1);
+	return Math.floor(cappedDelay + jitter);
+}
+/**
+* Sleep for a given number of milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Execute an async operation with retry logic for transient failures
+*
+* @param operation - Async function to execute
+* @param options - Retry options
+* @returns Result of the operation
+* @throws The last error if all retries are exhausted
+*
+* @example
+* ```typescript
+* const result = await withRetry(
+*   () => fetchData(),
+*   { config: { maxRetries: 3 }, operationName: 'fetchData' }
+* );
+* ```
+*/
+async function withRetry(operation, options = {}) {
+	const config = {
+		...DEFAULT_RETRY_CONFIG,
+		...options.config
+	};
+	let lastError;
+	for (let attempt = 0; attempt <= config.maxRetries; attempt++) try {
+		return await operation();
+	} catch (error) {
+		lastError = error;
+		if (!(!(attempt === config.maxRetries) && isRetryableError(error))) throw error;
+		const delayMs = calculateBackoff(attempt, config.baseDelayMs, config.maxDelayMs);
+		if (options.onRetry) options.onRetry(error, attempt + 1, delayMs);
+		await sleep(delayMs);
+	}
+	throw lastError;
+}
+//#endregion
+export { DEFAULT_RETRY_CONFIG, calculateBackoff, isRetryableError, withRetry };
+
+//# sourceMappingURL=retry.js.map

package/dist/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","names":[],"sources":["../src/retry.ts"],"sourcesContent":["import {\n  ManifestMCPError,\n  ManifestMCPErrorCode,\n  type RetryConfig,\n} from './types.js';\n\n/** Default retry configuration */\nexport const DEFAULT_RETRY_CONFIG: Required<RetryConfig> = {\n  maxRetries: 3,\n  baseDelayMs: 1000,\n  maxDelayMs: 10000,\n};\n\n/**\n * Error codes that should NOT be retried (permanent failures)\n */\nconst NON_RETRYABLE_ERROR_CODES: ManifestMCPErrorCode[] = [\n  // Configuration errors - won't change on retry\n  ManifestMCPErrorCode.INVALID_CONFIG,\n  ManifestMCPErrorCode.MISSING_CONFIG,\n\n  // Wallet errors - require user action\n  ManifestMCPErrorCode.WALLET_NOT_CONNECTED,\n  ManifestMCPErrorCode.WALLET_CONNECTION_FAILED,\n  ManifestMCPErrorCode.INVALID_MNEMONIC,\n\n  // Validation errors - input is invalid\n  ManifestMCPErrorCode.INVALID_ADDRESS,\n  ManifestMCPErrorCode.UNSUPPORTED_TX,\n  ManifestMCPErrorCode.UNSUPPORTED_QUERY,\n  ManifestMCPErrorCode.UNKNOWN_MODULE,\n\n  // Transaction failures - on-chain rejection or broadcast failure\n  // Retrying could cause double-spend for non-idempotent operations\n  ManifestMCPErrorCode.TX_FAILED,\n  ManifestMCPErrorCode.TX_BROADCAST_FAILED,\n  ManifestMCPErrorCode.INSUFFICIENT_FUNDS,\n];\n\n/**\n * Check if an error message indicates a transient failure that should be retried.\n *\n * Uses specific patterns to avoid false positives (e.g. \"proposal 500\" matching\n * bare \"500\", or \"connection to validator not authorized\" matching \"connection\").\n */\nfunction isTransientErrorMessage(message: string): boolean {\n  const lowerMessage = message.toLowerCase();\n\n  // Node.js / system error codes (specific, no false positives)\n  if (\n    lowerMessage.includes('econnrefused') ||\n    lowerMessage.includes('econnreset') ||\n    lowerMessage.includes('etimedout') ||\n    lowerMessage.includes('enotfound') ||\n    lowerMessage.includes('epipe') ||\n    lowerMessage.includes('socket hang up') ||\n    lowerMessage.includes('timed out') ||\n    lowerMessage.includes('network request failed') ||\n    lowerMessage.includes('fetch failed')\n  ) {\n    return true;\n  }\n\n  // HTTP 5xx errors — match \"HTTP 5xx\" or \"status 5xx\" patterns, not bare numbers\n  if (/\\b(?:http|status)\\s*5\\d{2}\\b/.test(lowerMessage)) {\n    return true;\n  }\n\n  // HTTP 5xx descriptive strings\n  if (\n    lowerMessage.includes('internal server error') ||\n    lowerMessage.includes('bad gateway') ||\n    lowerMessage.includes('service unavailable') ||\n    lowerMessage.includes('gateway timeout')\n  ) {\n    return true;\n  }\n\n  // Rate limiting\n  if (\n    /\\b429\\b/.test(lowerMessage) ||\n    lowerMessage.includes('too many requests')\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determine if an error is retryable\n */\nexport function isRetryableError(error: unknown): boolean {\n  // ManifestMCPError with non-retryable code\n  if (error instanceof ManifestMCPError) {\n    if (NON_RETRYABLE_ERROR_CODES.includes(error.code)) {\n      return false;\n    }\n    // Check message for transient indicators\n    return isTransientErrorMessage(error.message);\n  }\n\n  // Standard Error - check message\n  if (error instanceof Error) {\n    return isTransientErrorMessage(error.message);\n  }\n\n  // Unknown error type - don't retry\n  return false;\n}\n\n/**\n * Calculate delay with exponential backoff and jitter\n * @param attempt - Current attempt number (0-indexed)\n * @param baseDelayMs - Base delay in milliseconds\n * @param maxDelayMs - Maximum delay cap\n * @returns Delay in milliseconds\n */\nexport function calculateBackoff(\n  attempt: number,\n  baseDelayMs: number,\n  maxDelayMs: number,\n): number {\n  // Exponential backoff: baseDelay * 2^attempt\n  const exponentialDelay = baseDelayMs * 2 ** attempt;\n\n  // Cap at max delay\n  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);\n\n  // Add jitter (±25% randomization to prevent thundering herd)\n  const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);\n\n  return Math.floor(cappedDelay + jitter);\n}\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Options for the retry wrapper\n */\nexport interface RetryOptions {\n  /** Retry configuration */\n  config?: RetryConfig;\n  /** Operation name for error messages */\n  operationName?: string;\n  /** Callback invoked before each retry attempt */\n  onRetry?: (error: unknown, attempt: number, delayMs: number) => void;\n}\n\n/**\n * Execute an async operation with retry logic for transient failures\n *\n * @param operation - Async function to execute\n * @param options - Retry options\n * @returns Result of the operation\n * @throws The last error if all retries are exhausted\n *\n * @example\n * ```typescript\n * const result = await withRetry(\n *   () => fetchData(),\n *   { config: { maxRetries: 3 }, operationName: 'fetchData' }\n * );\n * ```\n */\nexport async function withRetry<T>(\n  operation: () => Promise<T>,\n  options: RetryOptions = {},\n): Promise<T> {\n  const config = {\n    ...DEFAULT_RETRY_CONFIG,\n    ...options.config,\n  };\n\n  let lastError: unknown;\n\n  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {\n    try {\n      return await operation();\n    } catch (error) {\n      lastError = error;\n\n      // Check if we should retry\n      const isLastAttempt = attempt === config.maxRetries;\n      const shouldRetry = !isLastAttempt && isRetryableError(error);\n\n      if (!shouldRetry) {\n        throw error;\n      }\n\n      // Calculate backoff delay\n      const delayMs = calculateBackoff(\n        attempt,\n        config.baseDelayMs,\n        config.maxDelayMs,\n      );\n\n      // Notify callback if provided\n      if (options.onRetry) {\n        options.onRetry(error, attempt + 1, delayMs);\n      }\n\n      // Wait before retrying\n      await sleep(delayMs);\n    }\n  }\n\n  // This should never be reached, but TypeScript needs it\n  throw lastError;\n}\n"],"mappings":";;;AAOA,MAAa,uBAA8C;CACzD,YAAY;CACZ,aAAa;CACb,YAAY;CACb;;;;AAKD,MAAM,4BAAoD;CAExD,qBAAqB;CACrB,qBAAqB;CAGrB,qBAAqB;CACrB,qBAAqB;CACrB,qBAAqB;CAGrB,qBAAqB;CACrB,qBAAqB;CACrB,qBAAqB;CACrB,qBAAqB;CAIrB,qBAAqB;CACrB,qBAAqB;CACrB,qBAAqB;CACtB;;;;;;;AAQD,SAAS,wBAAwB,SAA0B;CACzD,MAAM,eAAe,QAAQ,aAAa;AAG1C,KACE,aAAa,SAAS,eAAe,IACrC,aAAa,SAAS,aAAa,IACnC,aAAa,SAAS,YAAY,IAClC,aAAa,SAAS,YAAY,IAClC,aAAa,SAAS,QAAQ,IAC9B,aAAa,SAAS,iBAAiB,IACvC,aAAa,SAAS,YAAY,IAClC,aAAa,SAAS,yBAAyB,IAC/C,aAAa,SAAS,eAAe,CAErC,QAAO;AAIT,KAAI,+BAA+B,KAAK,aAAa,CACnD,QAAO;AAIT,KACE,aAAa,SAAS,wBAAwB,IAC9C,aAAa,SAAS,cAAc,IACpC,aAAa,SAAS,sBAAsB,IAC5C,aAAa,SAAS,kBAAkB,CAExC,QAAO;AAIT,KACE,UAAU,KAAK,aAAa,IAC5B,aAAa,SAAS,oBAAoB,CAE1C,QAAO;AAGT,QAAO;;;;;AAMT,SAAgB,iBAAiB,OAAyB;AAExD,KAAI,iBAAiB,kBAAkB;AACrC,MAAI,0BAA0B,SAAS,MAAM,KAAK,CAChD,QAAO;AAGT,SAAO,wBAAwB,MAAM,QAAQ;;AAI/C,KAAI,iBAAiB,MACnB,QAAO,wBAAwB,MAAM,QAAQ;AAI/C,QAAO;;;;;;;;;AAUT,SAAgB,iBACd,SACA,aACA,YACQ;CAER,MAAM,mBAAmB,cAAc,KAAK;CAG5C,MAAM,cAAc,KAAK,IAAI,kBAAkB,WAAW;CAG1D,MAAM,SAAS,cAAc,OAAQ,KAAK,QAAQ,GAAG,IAAI;AAEzD,QAAO,KAAK,MAAM,cAAc,OAAO;;;;;AAMzC,SAAS,MAAM,IAA2B;AACxC,QAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;AA+B1D,eAAsB,UACpB,WACA,UAAwB,EAAE,EACd;CACZ,MAAM,SAAS;EACb,GAAG;EACH,GAAG,QAAQ;EACZ;CAED,IAAI;AAEJ,MAAK,IAAI,UAAU,GAAG,WAAW,OAAO,YAAY,UAClD,KAAI;AACF,SAAO,MAAM,WAAW;UACjB,OAAO;AACd,cAAY;AAMZ,MAAI,EAFgB,EADE,YAAY,OAAO,eACH,iBAAiB,MAAM,EAG3D,OAAM;EAIR,MAAM,UAAU,iBACd,SACA,OAAO,aACP,OAAO,WACR;AAGD,MAAI,QAAQ,QACV,SAAQ,QAAQ,OAAO,UAAU,GAAG,QAAQ;AAI9C,QAAM,MAAM,QAAQ;;AAKxB,OAAM"}

package/dist/server-utils.d.ts

@@ -0,0 +1,61 @@
+import { ManifestMCPConfig, ManifestMCPErrorCode, WalletProvider } from "./types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/server-utils.d.ts
+/**
+ * Error codes that indicate infrastructure-level failures (wallet, RPC, config).
+ * Used by tool implementations to distinguish infrastructure errors from
+ * provider/application errors so that infrastructure errors are always re-thrown.
+ */
+declare const INFRASTRUCTURE_ERROR_CODES: ReadonlySet<ManifestMCPErrorCode>;
+/**
+ * Sensitive field names that should be redacted from error responses
+ */
+declare const SENSITIVE_FIELDS: ReadonlySet<string>;
+/**
+ * JSON replacer that converts BigInt values to strings
+ */
+declare function bigIntReplacer(_key: string, value: unknown): unknown;
+/**
+ * Recursively sanitize an object by redacting sensitive fields
+ */
+declare function sanitizeForLogging(obj: unknown, depth?: number): unknown;
+/**
+ * Options for creating a chain, lease, or fred MCP server
+ */
+interface ManifestMCPServerOptions {
+  config: ManifestMCPConfig;
+  walletProvider: WalletProvider;
+}
+/**
+ * Wrap a tool handler with error handling that preserves the existing error format.
+ *
+ * Generic over the callback type so that Zod-inferred argument types from
+ * McpServer.registerTool flow through without requiring manual casts.
+ */
+declare function withErrorHandling<T extends (...args: any[]) => Promise<CallToolResult>>(toolName: string, fn: T): T;
+/**
+ * Helper to build a successful JSON text response
+ */
+declare function jsonResponse(data: unknown, replacer?: (key: string, value: any) => any): CallToolResult;
+/**
+ * Config shape accepted by createMnemonicServer.
+ */
+interface MnemonicServerConfig {
+  chainId: string;
+  rpcUrl?: string;
+  gasPrice?: string;
+  restUrl?: string;
+  addressPrefix?: string;
+  mnemonic: string;
+}
+/**
+ * Generic factory that creates any MCP server class with a mnemonic wallet.
+ *
+ * Eliminates duplicated createMnemonic*Server patterns -- callers pass the
+ * server constructor instead.
+ */
+declare function createMnemonicServer<T>(config: MnemonicServerConfig, ServerClass: new (opts: ManifestMCPServerOptions) => T): Promise<T>;
+//#endregion
+export { INFRASTRUCTURE_ERROR_CODES, ManifestMCPServerOptions, MnemonicServerConfig, SENSITIVE_FIELDS, bigIntReplacer, createMnemonicServer, jsonResponse, sanitizeForLogging, withErrorHandling };
+//# sourceMappingURL=server-utils.d.ts.map

package/dist/server-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-utils.d.ts","names":[],"sources":["../src/server-utils.ts"],"mappings":";;;;;;AAgBA;;;cAAa,0BAAA,EAA4B,WAAA,CAAY,oBAAA;;AAYrD;;cAAa,gBAAA,EAAkB,WAAA;;;AAwB/B;iBAAgB,cAAA,CAAe,IAAA,UAAc,KAAA;;;;iBAO7B,kBAAA,CAAmB,GAAA,WAAc,KAAA;;;;UAgDhC,wBAAA;EACf,MAAA,EAAQ,iBAAA;EACR,cAAA,EAAgB,cAAA;AAAA;;;;;;;iBAUF,iBAAA,eACA,IAAA,YAAgB,OAAA,CAAQ,cAAA,EAAA,CACtC,QAAA,UAAkB,EAAA,EAAI,CAAA,GAAI,CAAA;AAF5B;;;AAAA,iBAoFgB,YAAA,CACd,IAAA,WACA,QAAA,IAAY,GAAA,UAAa,KAAA,gBACxB,cAAA;;;;UAcc,oBAAA;EACf,OAAA;EACA,MAAA;EACA,QAAA;EACA,OAAA;EACA,aAAA;EACA,QAAA;AAAA;;;;;AAvBF;;iBAgCsB,oBAAA,GAAA,CACpB,MAAA,EAAQ,oBAAA,EACR,WAAA,OAAkB,IAAA,EAAM,wBAAA,KAA6B,CAAA,GACpD,OAAA,CAAQ,CAAA"}

package/dist/server-utils.js

@@ -0,0 +1,156 @@
+import { ManifestMCPError, ManifestMCPErrorCode } from "./types.js";
+import { createValidatedConfig } from "./config.js";
+import { logger } from "./logger.js";
+import { MnemonicWalletProvider } from "./wallet/mnemonic.js";
+import "./wallet/index.js";
+//#region src/server-utils.ts
+/**
+* Error codes that indicate infrastructure-level failures (wallet, RPC, config).
+* Used by tool implementations to distinguish infrastructure errors from
+* provider/application errors so that infrastructure errors are always re-thrown.
+*/
+const INFRASTRUCTURE_ERROR_CODES = new Set([
+	ManifestMCPErrorCode.WALLET_NOT_CONNECTED,
+	ManifestMCPErrorCode.WALLET_CONNECTION_FAILED,
+	ManifestMCPErrorCode.RPC_CONNECTION_FAILED,
+	ManifestMCPErrorCode.INVALID_MNEMONIC,
+	ManifestMCPErrorCode.INVALID_CONFIG
+]);
+/**
+* Sensitive field names that should be redacted from error responses
+*/
+const SENSITIVE_FIELDS = new Set([
+	"mnemonic",
+	"privatekey",
+	"private_key",
+	"secret",
+	"password",
+	"seed",
+	"secret_key",
+	"signing_key",
+	"apikey",
+	"api_key",
+	"auth_token",
+	"bearer_token",
+	"access_token",
+	"refresh_token"
+]);
+/**
+* JSON replacer that converts BigInt values to strings
+*/
+function bigIntReplacer(_key, value) {
+	return typeof value === "bigint" ? value.toString() : value;
+}
+/**
+* Recursively sanitize an object by redacting sensitive fields
+*/
+function sanitizeForLogging(obj, depth = 0) {
+	if (depth > 10) return "[max depth exceeded]";
+	if (obj === null || obj === void 0) return obj;
+	if (typeof obj === "string") {
+		const words = obj.trim().split(/\s+/);
+		const wordCount = words.length;
+		if (wordCount >= 12 && wordCount <= 24 && wordCount % 3 === 0) {
+			if (words.every((w) => /^[a-z]+$/.test(w))) return "[REDACTED - possible mnemonic]";
+		}
+		return obj;
+	}
+	if (Array.isArray(obj)) return obj.map((item) => sanitizeForLogging(item, depth + 1));
+	if (typeof obj === "object") {
+		const sanitized = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const lowerKey = key.toLowerCase();
+			if (SENSITIVE_FIELDS.has(lowerKey)) sanitized[key] = "[REDACTED]";
+			else sanitized[key] = sanitizeForLogging(value, depth + 1);
+		}
+		return sanitized;
+	}
+	return obj;
+}
+/**
+* Wrap a tool handler with error handling that preserves the existing error format.
+*
+* Generic over the callback type so that Zod-inferred argument types from
+* McpServer.registerTool flow through without requiring manual casts.
+*/
+function withErrorHandling(toolName, fn) {
+	const wrapped = async (...cbArgs) => {
+		const hasArgs = cbArgs.length >= 2;
+		const args = hasArgs ? cbArgs[0] ?? {} : {};
+		try {
+			return hasArgs ? await fn(args, cbArgs[1]) : await fn(cbArgs[0]);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const errorCode = error instanceof ManifestMCPError ? error.code : "UNKNOWN";
+			if (error instanceof ManifestMCPError) logger.error(`[${toolName}] Tool error [${errorCode}]: ${errorMessage}`);
+			else {
+				const stack = error instanceof Error && error.stack ? `\n${error.stack}` : "";
+				logger.error(`[${toolName}] Tool error [${errorCode}]: ${errorMessage}${stack}`);
+			}
+			const safeMessage = sanitizeForLogging(errorMessage);
+			let errorResponse = {
+				error: true,
+				tool: toolName,
+				input: sanitizeForLogging(args)
+			};
+			if (error instanceof ManifestMCPError) errorResponse = {
+				...errorResponse,
+				code: error.code,
+				message: sanitizeForLogging(error.message),
+				details: sanitizeForLogging(error.details)
+			};
+			else errorResponse = {
+				...errorResponse,
+				message: safeMessage
+			};
+			let responseText;
+			try {
+				responseText = JSON.stringify(errorResponse, bigIntReplacer, 2);
+			} catch (stringifyError) {
+				logger.error(`[${toolName}] Failed to serialize error response: ${stringifyError instanceof Error ? stringifyError.message : String(stringifyError)}`);
+				responseText = JSON.stringify({
+					error: true,
+					tool: toolName,
+					message: safeMessage
+				});
+			}
+			return {
+				content: [{
+					type: "text",
+					text: responseText
+				}],
+				isError: true
+			};
+		}
+	};
+	return wrapped;
+}
+/**
+* Helper to build a successful JSON text response
+*/
+function jsonResponse(data, replacer) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, replacer, 2)
+	}] };
+}
+/**
+* Generic factory that creates any MCP server class with a mnemonic wallet.
+*
+* Eliminates duplicated createMnemonic*Server patterns -- callers pass the
+* server constructor instead.
+*/
+async function createMnemonicServer(config, ServerClass) {
+	const { mnemonic, ...mcpConfig } = config;
+	const validatedConfig = createValidatedConfig(mcpConfig);
+	const walletProvider = new MnemonicWalletProvider(validatedConfig, mnemonic);
+	await walletProvider.connect();
+	return new ServerClass({
+		config: validatedConfig,
+		walletProvider
+	});
+}
+//#endregion
+export { INFRASTRUCTURE_ERROR_CODES, SENSITIVE_FIELDS, bigIntReplacer, createMnemonicServer, jsonResponse, sanitizeForLogging, withErrorHandling };
+
+//# sourceMappingURL=server-utils.js.map

package/dist/server-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-utils.js","names":[],"sources":["../src/server-utils.ts"],"sourcesContent":["import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';\nimport { createValidatedConfig } from './config.js';\nimport { logger } from './logger.js';\nimport {\n  type ManifestMCPConfig,\n  ManifestMCPError,\n  ManifestMCPErrorCode,\n  type WalletProvider,\n} from './types.js';\nimport { MnemonicWalletProvider } from './wallet/index.js';\n\n/**\n * Error codes that indicate infrastructure-level failures (wallet, RPC, config).\n * Used by tool implementations to distinguish infrastructure errors from\n * provider/application errors so that infrastructure errors are always re-thrown.\n */\nexport const INFRASTRUCTURE_ERROR_CODES: ReadonlySet<ManifestMCPErrorCode> =\n  new Set([\n    ManifestMCPErrorCode.WALLET_NOT_CONNECTED,\n    ManifestMCPErrorCode.WALLET_CONNECTION_FAILED,\n    ManifestMCPErrorCode.RPC_CONNECTION_FAILED,\n    ManifestMCPErrorCode.INVALID_MNEMONIC,\n    ManifestMCPErrorCode.INVALID_CONFIG,\n  ]);\n\n/**\n * Sensitive field names that should be redacted from error responses\n */\nexport const SENSITIVE_FIELDS: ReadonlySet<string> = new Set([\n  'mnemonic',\n  'privatekey',\n  'private_key',\n  'secret',\n  'password',\n  'seed',\n  'secret_key',\n  'signing_key',\n  'apikey',\n  'api_key',\n  'auth_token',\n  'bearer_token',\n  'access_token',\n  'refresh_token',\n]);\n\n// Note: standalone \"key\" and \"token\" are intentionally excluded from SENSITIVE_FIELDS\n// because they are too generic — they would match pagination keys, map keys, and\n// non-sensitive token identifiers. Use compound names (api_key, auth_token, etc.) instead.\n\n/**\n * JSON replacer that converts BigInt values to strings\n */\nexport function bigIntReplacer(_key: string, value: unknown): unknown {\n  return typeof value === 'bigint' ? value.toString() : value;\n}\n\n/**\n * Recursively sanitize an object by redacting sensitive fields\n */\nexport function sanitizeForLogging(obj: unknown, depth = 0): unknown {\n  // Prevent infinite recursion\n  if (depth > 10) {\n    return '[max depth exceeded]';\n  }\n\n  if (obj === null || obj === undefined) {\n    return obj;\n  }\n\n  if (typeof obj === 'string') {\n    // Redact strings that look like BIP-39 mnemonics (12/15/18/21/24 words).\n    // BIP-39 words are all lowercase alphabetic, so require that to avoid\n    // false positives on error messages that happen to be 12/24 words.\n    const words = obj.trim().split(/\\s+/);\n    const wordCount = words.length;\n    if (wordCount >= 12 && wordCount <= 24 && wordCount % 3 === 0) {\n      const allLowercaseAlpha = words.every((w) => /^[a-z]+$/.test(w));\n      if (allLowercaseAlpha) {\n        return '[REDACTED - possible mnemonic]';\n      }\n    }\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sanitizeForLogging(item, depth + 1));\n  }\n\n  if (typeof obj === 'object') {\n    const sanitized: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(obj)) {\n      const lowerKey = key.toLowerCase();\n      if (SENSITIVE_FIELDS.has(lowerKey)) {\n        sanitized[key] = '[REDACTED]';\n      } else {\n        sanitized[key] = sanitizeForLogging(value, depth + 1);\n      }\n    }\n    return sanitized;\n  }\n\n  return obj;\n}\n\n/**\n * Options for creating a chain, lease, or fred MCP server\n */\nexport interface ManifestMCPServerOptions {\n  config: ManifestMCPConfig;\n  walletProvider: WalletProvider;\n}\n\n/**\n * Wrap a tool handler with error handling that preserves the existing error format.\n *\n * Generic over the callback type so that Zod-inferred argument types from\n * McpServer.registerTool flow through without requiring manual casts.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- preserves ToolCallback<Args> signature from McpServer\nexport function withErrorHandling<\n  T extends (...args: any[]) => Promise<CallToolResult>,\n>(toolName: string, fn: T): T {\n  // For tools with no inputSchema, McpServer calls cb(extra) with one arg.\n  // For tools with inputSchema, McpServer calls cb(parsedArgs, extra).\n  // We infer from cbArgs.length at call time (not fn.length) so default parameters are safe.\n  const wrapped = async (...cbArgs: any[]) => {\n    const hasArgs = cbArgs.length >= 2;\n    const args = hasArgs ? (cbArgs[0] ?? {}) : {};\n    try {\n      return hasArgs ? await fn(args, cbArgs[1]) : await fn(cbArgs[0]);\n    } catch (error) {\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      const errorCode =\n        error instanceof ManifestMCPError ? error.code : 'UNKNOWN';\n      if (error instanceof ManifestMCPError) {\n        logger.error(\n          `[${toolName}] Tool error [${errorCode}]: ${errorMessage}`,\n        );\n      } else {\n        const stack =\n          error instanceof Error && error.stack ? `\\n${error.stack}` : '';\n        logger.error(\n          `[${toolName}] Tool error [${errorCode}]: ${errorMessage}${stack}`,\n        );\n      }\n\n      // Sanitize error messages before including in the MCP response.\n      // This catches mnemonic-like strings in error messages and redacts them.\n      const safeMessage = sanitizeForLogging(errorMessage) as string;\n\n      let errorResponse: Record<string, unknown> = {\n        error: true,\n        tool: toolName,\n        input: sanitizeForLogging(args),\n      };\n\n      if (error instanceof ManifestMCPError) {\n        errorResponse = {\n          ...errorResponse,\n          code: error.code,\n          message: sanitizeForLogging(error.message) as string,\n          details: sanitizeForLogging(error.details),\n        };\n      } else {\n        errorResponse = {\n          ...errorResponse,\n          message: safeMessage,\n        };\n      }\n\n      let responseText: string;\n      try {\n        responseText = JSON.stringify(errorResponse, bigIntReplacer, 2);\n      } catch (stringifyError) {\n        logger.error(\n          `[${toolName}] Failed to serialize error response: ${stringifyError instanceof Error ? stringifyError.message : String(stringifyError)}`,\n        );\n        responseText = JSON.stringify({\n          error: true,\n          tool: toolName,\n          message: safeMessage,\n        });\n      }\n\n      return {\n        content: [\n          {\n            type: 'text' as const,\n            text: responseText,\n          },\n        ],\n        isError: true,\n      };\n    }\n  };\n  return wrapped as T;\n}\n\n/**\n * Helper to build a successful JSON text response\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches JSON.stringify's replacer signature\nexport function jsonResponse(\n  data: unknown,\n  replacer?: (key: string, value: any) => any,\n): CallToolResult {\n  return {\n    content: [\n      {\n        type: 'text' as const,\n        text: JSON.stringify(data, replacer, 2),\n      },\n    ],\n  };\n}\n\n/**\n * Config shape accepted by createMnemonicServer.\n */\nexport interface MnemonicServerConfig {\n  chainId: string;\n  rpcUrl?: string;\n  gasPrice?: string;\n  restUrl?: string;\n  addressPrefix?: string;\n  mnemonic: string;\n}\n\n/**\n * Generic factory that creates any MCP server class with a mnemonic wallet.\n *\n * Eliminates duplicated createMnemonic*Server patterns -- callers pass the\n * server constructor instead.\n */\nexport async function createMnemonicServer<T>(\n  config: MnemonicServerConfig,\n  ServerClass: new (opts: ManifestMCPServerOptions) => T,\n): Promise<T> {\n  const { mnemonic, ...mcpConfig } = config;\n  const validatedConfig = createValidatedConfig(mcpConfig);\n  const walletProvider = new MnemonicWalletProvider(validatedConfig, mnemonic);\n  await walletProvider.connect();\n\n  return new ServerClass({\n    config: validatedConfig,\n    walletProvider,\n  });\n}\n"],"mappings":"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"}

package/dist/tools/fundCredits.d.ts

@@ -0,0 +1,8 @@
+import { CosmosTxResult } from "../types.js";
+import { CosmosClientManager } from "../client.js";
+
+//#region src/tools/fundCredits.d.ts
+declare function fundCredits(clientManager: CosmosClientManager, amount: string): Promise<CosmosTxResult>;
+//#endregion
+export { fundCredits };
+//# sourceMappingURL=fundCredits.d.ts.map

package/dist/tools/fundCredits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fundCredits.d.ts","names":[],"sources":["../../src/tools/fundCredits.ts"],"mappings":";;;;iBAIsB,WAAA,CACpB,aAAA,EAAe,mBAAA,EACf,MAAA,WACC,OAAA,CAAQ,cAAA"}

package/dist/tools/fundCredits.js

@@ -0,0 +1,9 @@
+import { cosmosTx } from "../cosmos.js";
+//#region src/tools/fundCredits.ts
+async function fundCredits(clientManager, amount) {
+	return cosmosTx(clientManager, "billing", "fund-credit", [await clientManager.getAddress(), amount], true);
+}
+//#endregion
+export { fundCredits };
+
+//# sourceMappingURL=fundCredits.js.map

package/dist/tools/fundCredits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fundCredits.js","names":[],"sources":["../../src/tools/fundCredits.ts"],"sourcesContent":["import type { CosmosClientManager } from '../client.js';\nimport { cosmosTx } from '../cosmos.js';\nimport type { CosmosTxResult } from '../types.js';\n\nexport async function fundCredits(\n  clientManager: CosmosClientManager,\n  amount: string,\n): Promise<CosmosTxResult> {\n  const address = await clientManager.getAddress();\n  return cosmosTx(\n    clientManager,\n    'billing',\n    'fund-credit',\n    [address, amount],\n    true,\n  );\n}\n"],"mappings":";;AAIA,eAAsB,YACpB,eACA,QACyB;AAEzB,QAAO,SACL,eACA,WACA,eACA,CALc,MAAM,cAAc,YAAY,EAKpC,OAAO,EACjB,KACD"}

package/dist/tools/getBalance.d.ts

@@ -0,0 +1,26 @@
+import { ManifestQueryClient } from "../client.js";
+
+//#region src/tools/getBalance.d.ts
+declare function getBalance(queryClient: ManifestQueryClient, address: string): Promise<{
+  balances: {
+    denom: string;
+    amount: string;
+  }[];
+  spending_per_hour?: {
+    denom: string;
+    amount: string;
+  }[] | undefined;
+  hours_remaining?: string | undefined;
+  running_apps?: string | undefined;
+  credits: {
+    active_leases: string;
+    pending_leases: string;
+    reserved_amounts: {
+      denom: string;
+      amount: string;
+    }[];
+  } | null;
+}>;
+//#endregion
+export { getBalance };
+//# sourceMappingURL=getBalance.d.ts.map

package/dist/tools/getBalance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBalance.d.ts","names":[],"sources":["../../src/tools/getBalance.ts"],"mappings":";;;iBAqBsB,UAAA,CACpB,WAAA,EAAa,mBAAA,EACb,OAAA,WAAe,OAAA"}

package/dist/tools/getBalance.js

@@ -0,0 +1,59 @@
+import { ManifestMCPError } from "../types.js";
+//#region src/tools/getBalance.ts
+function catchNotFound(promise) {
+	return promise.catch((err) => {
+		if (err instanceof ManifestMCPError) throw err;
+		if (!(err instanceof Error)) throw err;
+		const msg = err.message;
+		if (/key not found/i.test(msg) || /account.*not found/i.test(msg) || /credit.*not found/i.test(msg)) return null;
+		throw err;
+	});
+}
+async function getBalance(queryClient, address) {
+	const bank = queryClient.cosmos.bank.v1beta1;
+	const billing = queryClient.liftedinit.billing.v1;
+	const [balancesResult, creditResult, estimateResult] = await Promise.all([
+		bank.allBalances({
+			address,
+			resolveDenom: false
+		}),
+		catchNotFound(billing.creditAccount({ tenant: address })),
+		catchNotFound(billing.creditEstimate({ tenant: address }))
+	]);
+	const credits = creditResult?.creditAccount ? {
+		active_leases: creditResult.creditAccount.activeLeaseCount.toString(),
+		pending_leases: creditResult.creditAccount.pendingLeaseCount.toString(),
+		reserved_amounts: creditResult.creditAccount.reservedAmounts.map((c) => ({
+			denom: c.denom,
+			amount: c.amount
+		}))
+	} : null;
+	const estimate = estimateResult ? {
+		current_balance: estimateResult.currentBalance.map((c) => ({
+			denom: c.denom,
+			amount: c.amount
+		})),
+		spending_per_hour: estimateResult.totalRatePerSecond.map((c) => ({
+			denom: c.denom,
+			amount: (BigInt(c.amount) * 3600n).toString()
+		})),
+		hours_remaining: estimateResult.estimatedDurationSeconds > 0n ? (Number(estimateResult.estimatedDurationSeconds) / 3600).toFixed(1) : "0",
+		running_apps: estimateResult.activeLeaseCount.toString()
+	} : null;
+	return {
+		credits,
+		...estimate && {
+			spending_per_hour: estimate.spending_per_hour,
+			hours_remaining: estimate.hours_remaining,
+			running_apps: estimate.running_apps
+		},
+		balances: balancesResult.balances.map((c) => ({
+			denom: c.denom,
+			amount: c.amount
+		}))
+	};
+}
+//#endregion
+export { getBalance };
+
+//# sourceMappingURL=getBalance.js.map

package/dist/tools/getBalance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBalance.js","names":[],"sources":["../../src/tools/getBalance.ts"],"sourcesContent":["import type { ManifestQueryClient } from '../client.js';\nimport { ManifestMCPError } from '../types.js';\n\nfunction catchNotFound<T>(promise: Promise<T>): Promise<T | null> {\n  return promise.catch((err: unknown) => {\n    // Never suppress structured infrastructure errors\n    if (err instanceof ManifestMCPError) throw err;\n    if (!(err instanceof Error)) throw err;\n    const msg = err.message;\n    // Match Cosmos SDK / gRPC NOT_FOUND patterns (key not found, account not found, etc.)\n    if (\n      /key not found/i.test(msg) ||\n      /account.*not found/i.test(msg) ||\n      /credit.*not found/i.test(msg)\n    ) {\n      return null;\n    }\n    throw err;\n  });\n}\n\nexport async function getBalance(\n  queryClient: ManifestQueryClient,\n  address: string,\n) {\n  const bank = queryClient.cosmos.bank.v1beta1;\n  const billing = queryClient.liftedinit.billing.v1;\n\n  const [balancesResult, creditResult, estimateResult] = await Promise.all([\n    bank.allBalances({ address, resolveDenom: false }),\n    catchNotFound(billing.creditAccount({ tenant: address })),\n    catchNotFound(billing.creditEstimate({ tenant: address })),\n  ]);\n\n  const credits = creditResult?.creditAccount\n    ? {\n        active_leases: creditResult.creditAccount.activeLeaseCount.toString(),\n        pending_leases: creditResult.creditAccount.pendingLeaseCount.toString(),\n        reserved_amounts: creditResult.creditAccount.reservedAmounts.map(\n          (c) => ({\n            denom: c.denom,\n            amount: c.amount,\n          }),\n        ),\n      }\n    : null;\n\n  const estimate = estimateResult\n    ? {\n        current_balance: estimateResult.currentBalance.map((c) => ({\n          denom: c.denom,\n          amount: c.amount,\n        })),\n        spending_per_hour: estimateResult.totalRatePerSecond.map((c) => ({\n          denom: c.denom,\n          amount: (BigInt(c.amount) * 3600n).toString(),\n        })),\n        hours_remaining:\n          estimateResult.estimatedDurationSeconds > 0n\n            ? (Number(estimateResult.estimatedDurationSeconds) / 3600).toFixed(\n                1,\n              )\n            : '0',\n        running_apps: estimateResult.activeLeaseCount.toString(),\n      }\n    : null;\n\n  return {\n    credits,\n    ...(estimate && {\n      spending_per_hour: estimate.spending_per_hour,\n      hours_remaining: estimate.hours_remaining,\n      running_apps: estimate.running_apps,\n    }),\n    balances: balancesResult.balances.map((c) => ({\n      denom: c.denom,\n      amount: c.amount,\n    })),\n  };\n}\n"],"mappings":";;AAGA,SAAS,cAAiB,SAAwC;AAChE,QAAO,QAAQ,OAAO,QAAiB;AAErC,MAAI,eAAe,iBAAkB,OAAM;AAC3C,MAAI,EAAE,eAAe,OAAQ,OAAM;EACnC,MAAM,MAAM,IAAI;AAEhB,MACE,iBAAiB,KAAK,IAAI,IAC1B,sBAAsB,KAAK,IAAI,IAC/B,qBAAqB,KAAK,IAAI,CAE9B,QAAO;AAET,QAAM;GACN;;AAGJ,eAAsB,WACpB,aACA,SACA;CACA,MAAM,OAAO,YAAY,OAAO,KAAK;CACrC,MAAM,UAAU,YAAY,WAAW,QAAQ;CAE/C,MAAM,CAAC,gBAAgB,cAAc,kBAAkB,MAAM,QAAQ,IAAI;EACvE,KAAK,YAAY;GAAE;GAAS,cAAc;GAAO,CAAC;EAClD,cAAc,QAAQ,cAAc,EAAE,QAAQ,SAAS,CAAC,CAAC;EACzD,cAAc,QAAQ,eAAe,EAAE,QAAQ,SAAS,CAAC,CAAC;EAC3D,CAAC;CAEF,MAAM,UAAU,cAAc,gBAC1B;EACE,eAAe,aAAa,cAAc,iBAAiB,UAAU;EACrE,gBAAgB,aAAa,cAAc,kBAAkB,UAAU;EACvE,kBAAkB,aAAa,cAAc,gBAAgB,KAC1D,OAAO;GACN,OAAO,EAAE;GACT,QAAQ,EAAE;GACX,EACF;EACF,GACD;CAEJ,MAAM,WAAW,iBACb;EACE,iBAAiB,eAAe,eAAe,KAAK,OAAO;GACzD,OAAO,EAAE;GACT,QAAQ,EAAE;GACX,EAAE;EACH,mBAAmB,eAAe,mBAAmB,KAAK,OAAO;GAC/D,OAAO,EAAE;GACT,SAAS,OAAO,EAAE,OAAO,GAAG,OAAO,UAAU;GAC9C,EAAE;EACH,iBACE,eAAe,2BAA2B,MACrC,OAAO,eAAe,yBAAyB,GAAG,MAAM,QACvD,EACD,GACD;EACN,cAAc,eAAe,iBAAiB,UAAU;EACzD,GACD;AAEJ,QAAO;EACL;EACA,GAAI,YAAY;GACd,mBAAmB,SAAS;GAC5B,iBAAiB,SAAS;GAC1B,cAAc,SAAS;GACxB;EACD,UAAU,eAAe,SAAS,KAAK,OAAO;GAC5C,OAAO,EAAE;GACT,QAAQ,EAAE;GACX,EAAE;EACJ"}

package/dist/tools/stopApp.d.ts

@@ -0,0 +1,13 @@
+import { CosmosClientManager } from "../client.js";
+
+//#region src/tools/stopApp.d.ts
+interface StopAppResult {
+  readonly lease_uuid: string;
+  readonly status: 'stopped';
+  readonly transactionHash: string;
+  readonly code: number;
+}
+declare function stopApp(clientManager: CosmosClientManager, leaseUuid: string): Promise<StopAppResult>;
+//#endregion
+export { StopAppResult, stopApp };
+//# sourceMappingURL=stopApp.d.ts.map

package/dist/tools/stopApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopApp.d.ts","names":[],"sources":["../../src/tools/stopApp.ts"],"mappings":";;;UAGiB,aAAA;EAAA,SACN,UAAA;EAAA,SACA,MAAA;EAAA,SACA,eAAA;EAAA,SACA,IAAA;AAAA;AAAA,iBAGW,OAAA,CACpB,aAAA,EAAe,mBAAA,EACf,SAAA,WACC,OAAA,CAAQ,aAAA"}

package/dist/tools/stopApp.js

@@ -0,0 +1,15 @@
+import { cosmosTx } from "../cosmos.js";
+//#region src/tools/stopApp.ts
+async function stopApp(clientManager, leaseUuid) {
+	const result = await cosmosTx(clientManager, "billing", "close-lease", [leaseUuid], true);
+	return {
+		lease_uuid: leaseUuid,
+		status: "stopped",
+		transactionHash: result.transactionHash,
+		code: result.code
+	};
+}
+//#endregion
+export { stopApp };
+
+//# sourceMappingURL=stopApp.js.map

package/dist/tools/stopApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stopApp.js","names":[],"sources":["../../src/tools/stopApp.ts"],"sourcesContent":["import type { CosmosClientManager } from '../client.js';\nimport { cosmosTx } from '../cosmos.js';\n\nexport interface StopAppResult {\n  readonly lease_uuid: string;\n  readonly status: 'stopped';\n  readonly transactionHash: string;\n  readonly code: number;\n}\n\nexport async function stopApp(\n  clientManager: CosmosClientManager,\n  leaseUuid: string,\n): Promise<StopAppResult> {\n  const result = await cosmosTx(\n    clientManager,\n    'billing',\n    'close-lease',\n    [leaseUuid],\n    true,\n  );\n\n  return {\n    lease_uuid: leaseUuid,\n    status: 'stopped',\n    transactionHash: result.transactionHash,\n    code: result.code,\n  };\n}\n"],"mappings":";;AAUA,eAAsB,QACpB,eACA,WACwB;CACxB,MAAM,SAAS,MAAM,SACnB,eACA,WACA,eACA,CAAC,UAAU,EACX,KACD;AAED,QAAO;EACL,YAAY;EACZ,QAAQ;EACR,iBAAiB,OAAO;EACxB,MAAM,OAAO;EACd"}

package/dist/transactions/bank.d.ts

@@ -0,0 +1,11 @@
+import { CosmosTxResult } from "../types.js";
+import { SigningStargateClient } from "@cosmjs/stargate";
+
+//#region src/transactions/bank.d.ts
+/**
+ * Route bank transaction to appropriate handler
+ */
+declare function routeBankTransaction(client: SigningStargateClient, senderAddress: string, subcommand: string, args: string[], waitForConfirmation: boolean): Promise<CosmosTxResult>;
+//#endregion
+export { routeBankTransaction };
+//# sourceMappingURL=bank.d.ts.map

package/dist/transactions/bank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bank.d.ts","names":[],"sources":["../../src/transactions/bank.ts"],"mappings":";;;;;;AAqBA;iBAAsB,oBAAA,CACpB,MAAA,EAAQ,qBAAA,EACR,aAAA,UACA,UAAA,UACA,IAAA,YACA,mBAAA,YACC,OAAA,CAAQ,cAAA"}