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

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);
   }
 }

package/src/queries/billing.ts

@@ -1,15 +1,34 @@
 import { ManifestQueryClient } from '../client.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { parseBigInt, defaultPagination } from './utils.js';
+import {
+  BillingParamsResult, LeaseResult, LeasesResult, CreditAccountResult,
+  CreditAccountsResult, CreditAddressResult, WithdrawableAmountResult,
+  ProviderWithdrawableResult, CreditEstimateResult
+} from '../types.js';
+import { parseBigInt, requireArgs, extractPaginationArgs } from './utils.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+
+/** Billing query result union type */
+type BillingQueryResult =
+  | BillingParamsResult
+  | LeaseResult
+  | LeasesResult
+  | CreditAccountResult
+  | CreditAccountsResult
+  | CreditAddressResult
+  | WithdrawableAmountResult
+  | ProviderWithdrawableResult
+  | CreditEstimateResult;
 
 /**
  * Route billing module query to manifestjs query client
+ *
+ * Paginated queries support --limit flag (default: 100, max: 1000)
  */
 export async function routeBillingQuery(
   queryClient: ManifestQueryClient,
   subcommand: string,
   args: string[]
-): Promise<Record<string, unknown>> {
+): Promise<BillingQueryResult> {
   const billing = queryClient.liftedinit.billing.v1;
 
   switch (subcommand) {
@@ -19,146 +38,87 @@ export async function routeBillingQuery(
     }
 
     case 'lease': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'lease requires lease-uuid argument'
-        );
-      }
+      requireArgs(args, 1, ['lease-uuid'], 'billing lease');
       const [leaseUuid] = args;
       const result = await billing.lease({ leaseUuid });
       return { lease: result.lease };
     }
 
     case 'leases': {
+      const { pagination } = extractPaginationArgs(args, 'billing leases');
       // stateFilter: 0 = LEASE_STATE_UNSPECIFIED (returns all)
-      const result = await billing.leases({ stateFilter: 0, pagination: defaultPagination });
+      const result = await billing.leases({ stateFilter: 0, pagination });
       return { leases: result.leases, pagination: result.pagination };
     }
 
     case 'leases-by-tenant': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'leases-by-tenant requires tenant-address argument'
-        );
-      }
-      const [tenant] = args;
-      const result = await billing.leasesByTenant({ tenant, stateFilter: 0, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'billing leases-by-tenant');
+      requireArgs(remainingArgs, 1, ['tenant-address'], 'billing leases-by-tenant');
+      const [tenant] = remainingArgs;
+      const result = await billing.leasesByTenant({ tenant, stateFilter: 0, pagination });
       return { leases: result.leases, pagination: result.pagination };
     }
 
     case 'leases-by-provider': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'leases-by-provider requires provider-uuid argument'
-        );
-      }
-      const [providerUuid] = args;
-      const result = await billing.leasesByProvider({ providerUuid, stateFilter: 0, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'billing leases-by-provider');
+      requireArgs(remainingArgs, 1, ['provider-uuid'], 'billing leases-by-provider');
+      const [providerUuid] = remainingArgs;
+      const result = await billing.leasesByProvider({ providerUuid, stateFilter: 0, pagination });
       return { leases: result.leases, pagination: result.pagination };
     }
 
     case 'leases-by-sku': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'leases-by-sku requires sku-uuid argument'
-        );
-      }
-      const [skuUuid] = args;
-      const result = await billing.leasesBySKU({ skuUuid, stateFilter: 0, pagination: defaultPagination });
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'billing leases-by-sku');
+      requireArgs(remainingArgs, 1, ['sku-uuid'], 'billing leases-by-sku');
+      const [skuUuid] = remainingArgs;
+      const result = await billing.leasesBySKU({ skuUuid, stateFilter: 0, pagination });
       return { leases: result.leases, pagination: result.pagination };
     }
 
     case 'credit-account': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'credit-account requires tenant-address argument'
-        );
-      }
+      requireArgs(args, 1, ['tenant-address'], 'billing credit-account');
       const [tenant] = args;
       const result = await billing.creditAccount({ tenant });
       return { creditAccount: result.creditAccount };
     }
 
     case 'credit-accounts': {
-      const result = await billing.creditAccounts({ pagination: defaultPagination });
+      const { pagination } = extractPaginationArgs(args, 'billing credit-accounts');
+      const result = await billing.creditAccounts({ pagination });
       return { creditAccounts: result.creditAccounts, pagination: result.pagination };
     }
 
     case 'credit-address': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'credit-address requires tenant-address argument'
-        );
-      }
+      requireArgs(args, 1, ['tenant-address'], 'billing credit-address');
       const [tenant] = args;
       const result = await billing.creditAddress({ tenant });
       return { creditAddress: result.creditAddress };
     }
 
     case 'withdrawable-amount': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'withdrawable-amount requires lease-uuid argument'
-        );
-      }
+      requireArgs(args, 1, ['lease-uuid'], 'billing withdrawable-amount');
       const [leaseUuid] = args;
       const result = await billing.withdrawableAmount({ leaseUuid });
       return { amounts: result.amounts };
     }
 
     case 'provider-withdrawable': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'provider-withdrawable requires provider-uuid argument'
-        );
-      }
+      requireArgs(args, 1, ['provider-uuid'], 'billing provider-withdrawable');
       const [providerUuid] = args;
-      // limit: max leases to process (default 100, max 1000)
+      // Optional: limit for max leases to process (default 100, max 1000)
       const limit = args[1] ? parseBigInt(args[1], 'limit') : BigInt(100);
       const result = await billing.providerWithdrawable({ providerUuid, limit });
       return { amounts: result.amounts };
     }
 
     case 'credit-estimate': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'credit-estimate requires tenant-address argument'
-        );
-      }
+      requireArgs(args, 1, ['tenant-address'], 'billing credit-estimate');
       const [tenant] = args;
       const result = await billing.creditEstimate({ tenant });
       return { estimate: result };
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
-        `Unsupported billing query subcommand: ${subcommand}`,
-        {
-          availableSubcommands: [
-            'params',
-            'lease',
-            'leases',
-            'leases-by-tenant',
-            'leases-by-provider',
-            'leases-by-sku',
-            'credit-account',
-            'credit-accounts',
-            'credit-address',
-            'withdrawable-amount',
-            'provider-withdrawable',
-            'credit-estimate',
-          ],
-        }
-      );
+      throwUnsupportedSubcommand('query', 'billing', subcommand);
   }
 }

package/src/queries/distribution.ts

@@ -1,26 +1,40 @@
 import { ManifestQueryClient } from '../client.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { parseBigInt, defaultPagination } from './utils.js';
+import {
+  RewardsResult, CommissionResult, CommunityPoolResult, DistributionParamsResult,
+  ValidatorOutstandingRewardsResult, SlashesResult, DelegatorValidatorsResult,
+  DelegatorWithdrawAddressResult
+} from '../types.js';
+import { parseBigInt, requireArgs, extractPaginationArgs } from './utils.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+
+/** Distribution query result union type */
+type DistributionQueryResult =
+  | RewardsResult
+  | CommissionResult
+  | CommunityPoolResult
+  | DistributionParamsResult
+  | ValidatorOutstandingRewardsResult
+  | SlashesResult
+  | DelegatorValidatorsResult
+  | DelegatorWithdrawAddressResult;
 
 /**
  * Route distribution query to manifestjs query client
+ *
+ * Paginated queries support --limit flag (default: 100, max: 1000)
  */
 export async function routeDistributionQuery(
   queryClient: ManifestQueryClient,
   subcommand: string,
   args: string[]
-): Promise<Record<string, unknown>> {
+): Promise<DistributionQueryResult> {
   const distribution = queryClient.cosmos.distribution.v1beta1;
 
   switch (subcommand) {
     case 'rewards': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'rewards requires delegator-address argument'
-        );
-      }
+      requireArgs(args, 1, ['delegator-address'], 'distribution rewards');
       const [delegatorAddress] = args;
+      // Optional: validator address for specific validator rewards
       const validatorAddress = args[1];
 
       if (validatorAddress) {
@@ -41,12 +55,7 @@ export async function routeDistributionQuery(
     }
 
     case 'commission': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'commission requires validator-address argument'
-        );
-      }
+      requireArgs(args, 1, ['validator-address'], 'distribution commission');
       const [validatorAddress] = args;
       const result = await distribution.validatorCommission({ validatorAddress });
       return { commission: result.commission };
@@ -63,76 +72,43 @@ export async function routeDistributionQuery(
     }
 
     case 'validator-outstanding-rewards': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'validator-outstanding-rewards requires validator-address argument'
-        );
-      }
+      requireArgs(args, 1, ['validator-address'], 'distribution validator-outstanding-rewards');
       const [validatorAddress] = args;
       const result = await distribution.validatorOutstandingRewards({ validatorAddress });
       return { rewards: result.rewards };
     }
 
     case 'slashes': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'slashes requires validator-address argument'
-        );
-      }
-      const [validatorAddress] = args;
-      const startingHeight = args[1] ? parseBigInt(args[1], 'starting-height') : BigInt(0);
-      const endingHeight = args[2] ? parseBigInt(args[2], 'ending-height') : BigInt(Number.MAX_SAFE_INTEGER);
+      const { pagination, remainingArgs } = extractPaginationArgs(args, 'distribution slashes');
+      requireArgs(remainingArgs, 1, ['validator-address'], 'distribution slashes');
+      const [validatorAddress] = remainingArgs;
+      // Optional: starting and ending height for filtering
+      const startingHeight = remainingArgs[1] ? parseBigInt(remainingArgs[1], 'starting-height') : BigInt(0);
+      const endingHeight = remainingArgs[2] ? parseBigInt(remainingArgs[2], 'ending-height') : BigInt(Number.MAX_SAFE_INTEGER);
       const result = await distribution.validatorSlashes({
         validatorAddress,
         startingHeight,
         endingHeight,
-        pagination: defaultPagination,
+        pagination,
       });
       return { slashes: result.slashes, pagination: result.pagination };
     }
 
     case 'delegator-validators': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'delegator-validators requires delegator-address argument'
-        );
-      }
+      requireArgs(args, 1, ['delegator-address'], 'distribution delegator-validators');
       const [delegatorAddress] = args;
       const result = await distribution.delegatorValidators({ delegatorAddress });
       return { validators: result.validators };
     }
 
     case 'delegator-withdraw-address': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.QUERY_FAILED,
-          'delegator-withdraw-address requires delegator-address argument'
-        );
-      }
+      requireArgs(args, 1, ['delegator-address'], 'distribution delegator-withdraw-address');
       const [delegatorAddress] = args;
       const result = await distribution.delegatorWithdrawAddress({ delegatorAddress });
       return { withdrawAddress: result.withdrawAddress };
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
-        `Unsupported distribution query subcommand: ${subcommand}`,
-        {
-          availableSubcommands: [
-            'rewards',
-            'commission',
-            'community-pool',
-            'params',
-            'validator-outstanding-rewards',
-            'slashes',
-            'delegator-validators',
-            'delegator-withdraw-address',
-          ],
-        }
-      );
+      throwUnsupportedSubcommand('query', 'distribution', subcommand);
   }
 }