@manifest-network/manifest-mcp-browser 0.1.1 → 0.1.5

package/src/modules.ts

@@ -1,4 +1,66 @@
-import { ModuleInfo, AvailableModules, ManifestMCPError, ManifestMCPErrorCode } from './types.js';
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { ModuleInfo, AvailableModules, ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, QueryResult } from './types.js';
+import { ManifestQueryClient } from './client.js';
+
+// Import query handlers
+import { routeBankQuery } from './queries/bank.js';
+import { routeStakingQuery } from './queries/staking.js';
+import { routeDistributionQuery } from './queries/distribution.js';
+import { routeGovQuery } from './queries/gov.js';
+import { routeAuthQuery } from './queries/auth.js';
+import { routeBillingQuery } from './queries/billing.js';
+
+// Import transaction handlers
+import { routeBankTransaction } from './transactions/bank.js';
+import { routeStakingTransaction } from './transactions/staking.js';
+import { routeDistributionTransaction } from './transactions/distribution.js';
+import { routeGovTransaction } from './transactions/gov.js';
+import { routeBillingTransaction } from './transactions/billing.js';
+import { routeManifestTransaction } from './transactions/manifest.js';
+
+/**
+ * Handler function type for query modules
+ */
+export type QueryHandler = (
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+) => Promise<QueryResult>;
+
+/**
+ * Handler function type for transaction modules
+ */
+export type TxHandler = (
+  signingClient: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  waitForConfirmation: boolean
+) => Promise<CosmosTxResult>;
+
+/**
+ * Throw an error for an unsupported subcommand.
+ * Automatically looks up available subcommands from the module registry.
+ *
+ * @param type - 'query' or 'tx'
+ * @param module - The module name (e.g., 'bank', 'staking')
+ * @param subcommand - The unsupported subcommand that was requested
+ */
+export function throwUnsupportedSubcommand(
+  type: 'query' | 'tx',
+  module: string,
+  subcommand: string
+): never {
+  const registry = type === 'query' ? QUERY_MODULES : TX_MODULES;
+  const moduleInfo = registry[module];
+  const availableSubcommands = moduleInfo?.subcommands.map(s => s.name) ?? [];
+
+  throw new ManifestMCPError(
+    type === 'query' ? ManifestMCPErrorCode.UNSUPPORTED_QUERY : ManifestMCPErrorCode.UNSUPPORTED_TX,
+    `Unsupported ${module} ${type === 'query' ? 'query' : 'transaction'} subcommand: ${subcommand}`,
+    { availableSubcommands }
+  );
+}
 
 /**
  * Static module registry for browser-compatible module discovery
@@ -11,19 +73,30 @@ interface SubcommandInfo {
   args?: string; // Usage hint for arguments
 }
 
-interface ModuleRegistry {
+interface QueryModuleRegistry {
   [moduleName: string]: {
     description: string;
     subcommands: SubcommandInfo[];
+    handler: QueryHandler;
+  };
+}
+
+interface TxModuleRegistry {
+  [moduleName: string]: {
+    description: string;
+    subcommands: SubcommandInfo[];
+    handler: TxHandler;
   };
 }
 
 /**
  * Query modules registry
+ * Each module includes metadata and its handler function
  */
-const QUERY_MODULES: ModuleRegistry = {
+const QUERY_MODULES: QueryModuleRegistry = {
   bank: {
     description: 'Querying commands for the bank module',
+    handler: routeBankQuery,
     subcommands: [
       { name: 'balance', description: 'Query account balance for a specific denom' },
       { name: 'balances', description: 'Query all balances for an account' },
@@ -39,6 +112,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   staking: {
     description: 'Querying commands for the staking module',
+    handler: routeStakingQuery,
     subcommands: [
       { name: 'delegation', description: 'Query a delegation' },
       { name: 'delegations', description: 'Query all delegations for a delegator' },
@@ -56,6 +130,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   distribution: {
     description: 'Querying commands for the distribution module',
+    handler: routeDistributionQuery,
     subcommands: [
       { name: 'rewards', description: 'Query distribution rewards for a delegator' },
       { name: 'commission', description: 'Query validator commission' },
@@ -69,6 +144,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   gov: {
     description: 'Querying commands for the governance module',
+    handler: routeGovQuery,
     subcommands: [
       { name: 'proposal', description: 'Query a proposal by ID' },
       { name: 'proposals', description: 'Query all proposals' },
@@ -82,6 +158,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   auth: {
     description: 'Querying commands for the auth module',
+    handler: routeAuthQuery,
     subcommands: [
       { name: 'account', description: 'Query account by address' },
       { name: 'accounts', description: 'Query all accounts' },
@@ -96,6 +173,7 @@ const QUERY_MODULES: ModuleRegistry = {
   },
   billing: {
     description: 'Querying commands for the Manifest billing module',
+    handler: routeBillingQuery,
     subcommands: [
       { name: 'params', description: 'Query billing parameters' },
       { name: 'lease', description: 'Query a lease by UUID' },
@@ -115,10 +193,12 @@ const QUERY_MODULES: ModuleRegistry = {
 
 /**
  * Transaction modules registry
+ * Each module includes metadata and its handler function
  */
-const TX_MODULES: ModuleRegistry = {
+const TX_MODULES: TxModuleRegistry = {
   bank: {
     description: 'Bank transaction subcommands',
+    handler: routeBankTransaction,
     subcommands: [
       { name: 'send', description: 'Send tokens to another account', args: '<to-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
       { name: 'multi-send', description: 'Send tokens to multiple accounts', args: '<to-address:amount>... (e.g., manifest1a:1000umfx manifest1b:2000umfx)' },
@@ -126,6 +206,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   staking: {
     description: 'Staking transaction subcommands',
+    handler: routeStakingTransaction,
     subcommands: [
       { name: 'delegate', description: 'Delegate tokens to a validator' },
       { name: 'unbond', description: 'Unbond tokens from a validator' },
@@ -135,6 +216,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   distribution: {
     description: 'Distribution transaction subcommands',
+    handler: routeDistributionTransaction,
     subcommands: [
       { name: 'withdraw-rewards', description: 'Withdraw rewards from a validator' },
       { name: 'set-withdraw-addr', description: 'Set withdraw address' },
@@ -143,6 +225,7 @@ const TX_MODULES: ModuleRegistry = {
   },
   gov: {
     description: 'Governance transaction subcommands',
+    handler: routeGovTransaction,
     subcommands: [
       { name: 'vote', description: 'Vote on a proposal' },
       { name: 'weighted-vote', description: 'Weighted vote on a proposal' },
@@ -151,15 +234,17 @@ const TX_MODULES: ModuleRegistry = {
   },
   billing: {
     description: 'Manifest billing transaction subcommands',
+    handler: routeBillingTransaction,
     subcommands: [
       { name: 'fund-credit', description: 'Fund credit for a tenant', args: '<tenant-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
       { name: 'create-lease', description: 'Create a new lease', args: '[--meta-hash <hex>] <sku-uuid:quantity>... (e.g., sku-123:1 sku-456:2)' },
-      { name: 'close-lease', description: 'Close one or more leases', args: '<lease-uuid>... (e.g., lease-123 lease-456)' },
+      { name: 'close-lease', description: 'Close one or more leases', args: '[--reason <text>] <lease-uuid>... (e.g., lease-123 lease-456)' },
       { name: 'withdraw', description: 'Withdraw earnings from leases', args: '<lease-uuid>... OR --provider <provider-uuid> [--limit <1-100>]' },
     ],
   },
   manifest: {
     description: 'Manifest module transaction subcommands',
+    handler: routeManifestTransaction,
     subcommands: [
       { name: 'payout', description: 'Execute a payout to multiple addresses' },
       { name: 'burn-held-balance', description: 'Burn held balance' },
@@ -276,3 +361,35 @@ export function getSupportedModules(): {
 
   return result;
 }
+
+/**
+ * Get the handler function for a query module
+ * @throws ManifestMCPError if module is not found
+ */
+export function getQueryHandler(module: string): QueryHandler {
+  const moduleInfo = QUERY_MODULES[module];
+  if (!moduleInfo) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.UNKNOWN_MODULE,
+      `Unknown query module: ${module}`,
+      { availableModules: Object.keys(QUERY_MODULES) }
+    );
+  }
+  return moduleInfo.handler;
+}
+
+/**
+ * Get the handler function for a transaction module
+ * @throws ManifestMCPError if module is not found
+ */
+export function getTxHandler(module: string): TxHandler {
+  const moduleInfo = TX_MODULES[module];
+  if (!moduleInfo) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.UNKNOWN_MODULE,
+      `Unknown tx module: ${module}`,
+      { availableModules: Object.keys(TX_MODULES) }
+    );
+  }
+  return moduleInfo.handler;
+}

package/src/queries/auth.ts

@@ -1,32 +1,50 @@
 import { ManifestQueryClient } from '../client.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { defaultPagination } from './utils.js';
+import {
+  ManifestMCPErrorCode,
+  AuthAccountResult, AuthAccountsResult, AuthParamsResult, ModuleAccountsResult,
+  AddressBytesToStringResult, AddressStringToBytesResult, Bech32PrefixResult, AccountInfoResult
+} from '../types.js';
+import { requireArgs, extractPaginationArgs } from './utils.js';
+import { parseHexBytes, bytesToHex } from '../transactions/utils.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+
+/** Maximum address bytes length (256 bytes, more than enough for any address) */
+const MAX_ADDRESS_BYTES = 256;
+
+/** Auth query result union type */
+type AuthQueryResult =
+  | AuthAccountResult
+  | AuthAccountsResult
+  | AuthParamsResult
+  | ModuleAccountsResult
+  | AddressBytesToStringResult
+  | AddressStringToBytesResult
+  | Bech32PrefixResult
+  | AccountInfoResult;
 
 /**
  * Route auth query to manifestjs query client
+ *
+ * Paginated queries support --limit flag (default: 100, max: 1000)
  */
 export async function routeAuthQuery(
   queryClient: ManifestQueryClient,
   subcommand: string,
   args: string[]
-): Promise<Record<string, unknown>> {
+): Promise<AuthQueryResult> {
   const auth = queryClient.cosmos.auth.v1beta1;
 
   switch (subcommand) {
     case 'account': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'account requires address argument'
-        );
-      }
+      requireArgs(args, 1, ['address'], 'auth account');
       const [address] = args;
       const result = await auth.account({ address });
       return { account: result.account };
     }
 
     case 'accounts': {
-      const result = await auth.accounts({ pagination: defaultPagination });
+      const { pagination } = extractPaginationArgs(args, 'auth accounts');
+      const result = await auth.accounts({ pagination });
       return { accounts: result.accounts, pagination: result.pagination };
     }
 
@@ -41,60 +59,24 @@ export async function routeAuthQuery(
     }
 
     case 'module-account-by-name': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'module-account-by-name requires name argument'
-        );
-      }
+      requireArgs(args, 1, ['name'], 'auth module-account-by-name');
       const [name] = args;
       const result = await auth.moduleAccountByName({ name });
       return { account: result.account };
     }
 
     case 'address-bytes-to-string': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'address-bytes-to-string requires address-bytes argument'
-        );
-      }
-      const hexString = args[0];
-      // Validate hex format: must be valid hex characters with even length
-      if (!/^[0-9a-fA-F]*$/.test(hexString)) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          `Invalid hex string: "${hexString}". Must contain only hexadecimal characters (0-9, a-f, A-F)`
-        );
-      }
-      if (hexString.length % 2 !== 0) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          `Invalid hex string length: ${hexString.length}. Must have an even number of characters`
-        );
-      }
-      // Limit size to prevent DoS (256 bytes = 512 hex chars, more than enough for any address)
-      if (hexString.length > 512) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          `Hex string too long: ${hexString.length} characters. Maximum allowed: 512`
-        );
-      }
-      const addressBytes = new Uint8Array(Buffer.from(hexString, 'hex'));
+      requireArgs(args, 1, ['address-bytes'], 'auth address-bytes-to-string');
+      const addressBytes = parseHexBytes(args[0], 'address-bytes', MAX_ADDRESS_BYTES, ManifestMCPErrorCode.QUERY_FAILED);
       const result = await auth.addressBytesToString({ addressBytes });
       return { addressString: result.addressString };
     }
 
     case 'address-string-to-bytes': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'address-string-to-bytes requires address-string argument'
-        );
-      }
+      requireArgs(args, 1, ['address-string'], 'auth address-string-to-bytes');
       const [addressString] = args;
       const result = await auth.addressStringToBytes({ addressString });
-      return { addressBytes: Buffer.from(result.addressBytes).toString('hex') };
+      return { addressBytes: bytesToHex(result.addressBytes) };
     }
 
     case 'bech32-prefix': {
@@ -103,34 +85,13 @@ export async function routeAuthQuery(
     }
 
     case 'account-info': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'account-info requires address argument'
-        );
-      }
+      requireArgs(args, 1, ['address'], 'auth account-info');
       const [address] = args;
       const result = await auth.accountInfo({ address });
       return { info: result.info };
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
-        `Unsupported auth query subcommand: ${subcommand}`,
-        {
-          availableSubcommands: [
-            'account',
-            'accounts',
-            'params',
-            'module-accounts',
-            'module-account-by-name',
-            'address-bytes-to-string',
-            'address-string-to-bytes',
-            'bech32-prefix',
-            'account-info',
-          ],
-        }
-      );
+      throwUnsupportedSubcommand('query', 'auth', subcommand);
   }
 }

package/src/queries/bank.ts

@@ -1,67 +1,67 @@
 import { ManifestQueryClient } from '../client.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { defaultPagination } from './utils.js';
+import {
+  BalanceResult, BalancesResult, TotalSupplyResult, SupplyOfResult,
+  BankParamsResult, DenomMetadataResult, DenomsMetadataResult, SendEnabledResult
+} from '../types.js';
+import { requireArgs, extractPaginationArgs } from './utils.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+
+/** Bank query result union type */
+type BankQueryResult =
+  | BalanceResult
+  | BalancesResult
+  | TotalSupplyResult
+  | SupplyOfResult
+  | BankParamsResult
+  | DenomMetadataResult
+  | DenomsMetadataResult
+  | SendEnabledResult;
 
 /**
  * Route bank query to manifestjs query client
+ *
+ * Paginated queries support --limit flag (default: 100, max: 1000)
  */
 export async function routeBankQuery(
   queryClient: ManifestQueryClient,
   subcommand: string,
   args: string[]
-): Promise<Record<string, unknown>> {
+): Promise<BankQueryResult> {
   const bank = queryClient.cosmos.bank.v1beta1;
 
   switch (subcommand) {
     case 'balance': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'balance requires address and denom arguments'
-        );
-      }
+      requireArgs(args, 2, ['address', 'denom'], 'bank balance');
       const [address, denom] = args;
       const result = await bank.balance({ address, denom });
       return { balance: result.balance };
     }
 
     case 'balances': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'balances requires address argument'
-        );
-      }
-      const [address] = args;
-      const result = await bank.allBalances({ address, resolveDenom: false, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'bank balances');
+      requireArgs(remainingArgs, 1, ['address'], 'bank balances');
+      const [address] = remainingArgs;
+      const result = await bank.allBalances({ address, resolveDenom: false, pagination });
       return { balances: result.balances, pagination: result.pagination };
     }
 
     case 'spendable-balances': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'spendable-balances requires address argument'
-        );
-      }
-      const [address] = args;
-      const result = await bank.spendableBalances({ address, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'bank spendable-balances');
+      requireArgs(remainingArgs, 1, ['address'], 'bank spendable-balances');
+      const [address] = remainingArgs;
+      const result = await bank.spendableBalances({ address, pagination });
       return { balances: result.balances, pagination: result.pagination };
     }
 
     case 'total-supply':
     case 'total': {
-      const result = await bank.totalSupply({ pagination: defaultPagination });
+      const { pagination } = extractPaginationArgs(args, 'bank total-supply');
+      const result = await bank.totalSupply({ pagination });
       return { supply: result.supply, pagination: result.pagination };
     }
 
     case 'supply-of': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'supply-of requires denom argument'
-        );
-      }
+      requireArgs(args, 1, ['denom'], 'bank supply-of');
       const [denom] = args;
       const result = await bank.supplyOf({ denom });
       return { amount: result.amount };
@@ -73,45 +73,27 @@ export async function routeBankQuery(
     }
 
     case 'denom-metadata': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'denom-metadata requires denom argument'
-        );
-      }
+      requireArgs(args, 1, ['denom'], 'bank denom-metadata');
       const [denom] = args;
       const result = await bank.denomMetadata({ denom });
       return { metadata: result.metadata };
     }
 
     case 'denoms-metadata': {
-      const result = await bank.denomsMetadata({ pagination: defaultPagination });
+      const { pagination } = extractPaginationArgs(args, 'bank denoms-metadata');
+      const result = await bank.denomsMetadata({ pagination });
       return { metadatas: result.metadatas, pagination: result.pagination };
     }
 
     case 'send-enabled': {
-      const denoms = args.length > 0 ? args : [];
-      const result = await bank.sendEnabled({ denoms, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'bank send-enabled');
+      // Optional: denoms can be empty to query all
+      const denoms = remainingArgs.length > 0 ? remainingArgs : [];
+      const result = await bank.sendEnabled({ denoms, pagination });
       return { sendEnabled: result.sendEnabled, pagination: result.pagination };
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
-        `Unsupported bank query subcommand: ${subcommand}`,
-        {
-          availableSubcommands: [
-            'balance',
-            'balances',
-            'spendable-balances',
-            'total-supply',
-            'supply-of',
-            'params',
-            'denom-metadata',
-            'denoms-metadata',
-            'send-enabled',
-          ],
-        }
-      );
+      throwUnsupportedSubcommand('query', 'bank', subcommand);
   }
 }