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

package/src/transactions/bank.ts

@@ -1,7 +1,8 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { cosmos } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, validateAddress, validateMemo, validateArgsLength } from './utils.js';
+import { CosmosTxResult } from '../types.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+import { parseAmount, buildTxResult, validateAddress, validateMemo, validateArgsLength, extractFlag, parseColonPair, requireArgs } from './utils.js';
 
 const { MsgSend, MsgMultiSend } = cosmos.bank.v1beta1;
 
@@ -13,29 +14,20 @@ export async function routeBankTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'bank transaction');
 
   switch (subcommand) {
     case 'send': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'send requires recipient-address and amount arguments'
-        );
-      }
-
+      requireArgs(args, 2, ['recipient-address', 'amount'], 'bank send');
       const [recipientAddress, amountStr] = args;
       validateAddress(recipientAddress, 'recipient address');
       const { amount, denom } = parseAmount(amountStr);
 
       // Extract optional memo from args
-      let memo = '';
-      const memoIndex = args.indexOf('--memo');
-      if (memoIndex !== -1 && args[memoIndex + 1]) {
-        memo = args[memoIndex + 1];
+      const { value: memo = '' } = extractFlag(args, '--memo', 'bank send');
+      if (memo) {
         validateMemo(memo);
       }
 
@@ -53,22 +45,10 @@ export async function routeBankTransaction(
     }
 
     case 'multi-send': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'multi-send requires at least one recipient:amount pair'
-        );
-      }
-
+      requireArgs(args, 1, ['recipient:amount'], 'bank multi-send');
       // Parse format: multi-send recipient1:amount1 recipient2:amount2 ...
       const outputs = args.map((arg) => {
-        const [address, amountStr] = arg.split(':');
-        if (!address || !amountStr) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            `Invalid multi-send format: ${arg}. Expected format: address:amount`
-          );
-        }
+        const [address, amountStr] = parseColonPair(arg, 'address', 'amount', 'multi-send');
         validateAddress(address, 'recipient address');
         const { amount, denom } = parseAmount(amountStr);
         return { address, coins: [{ denom, amount }] };
@@ -101,10 +81,6 @@ export async function routeBankTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported bank transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['send', 'multi-send'] }
-      );
+      throwUnsupportedSubcommand('tx', 'bank', subcommand);
   }
 }

package/src/transactions/billing.ts

@@ -1,11 +1,14 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { liftedinit } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, parseBigInt, validateAddress, validateArgsLength } from './utils.js';
-import { getSubcommandUsage } from '../modules.js';
+import { CosmosTxResult, ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseAmount, buildTxResult, parseBigInt, validateAddress, validateArgsLength, extractFlag, filterConsumedArgs, parseColonPair, requireArgs, parseHexBytes } from './utils.js';
+import { getSubcommandUsage, throwUnsupportedSubcommand } from '../modules.js';
 
 const { MsgFundCredit, MsgCreateLease, MsgCloseLease, MsgWithdraw } = liftedinit.billing.v1;
 
+/** Maximum meta hash length in bytes (64 bytes for SHA-512) */
+const MAX_META_HASH_BYTES = 64;
+
 /**
  * Route billing transaction to appropriate handler
  */
@@ -14,22 +17,13 @@ export async function routeBillingTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'billing transaction');
 
   switch (subcommand) {
     case 'fund-credit': {
-      if (args.length < 2) {
-        const usage = getSubcommandUsage('tx', 'billing', 'fund-credit');
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          `fund-credit requires tenant-address and amount arguments. Received ${args.length} argument(s): [${args.map(a => `"${a}"`).join(', ')}]. Usage: fund-credit ${usage || '<tenant-address> <amount>'}`,
-          { receivedArgs: args, expectedArgs: ['tenant-address', 'amount'], usage }
-        );
-      }
-
+      requireArgs(args, 2, ['tenant-address', 'amount'], 'billing fund-credit');
       const [tenant, amountStr] = args;
       validateAddress(tenant, 'tenant address');
       const { amount, denom } = parseAmount(amountStr);
@@ -48,24 +42,17 @@ export async function routeBillingTransaction(
     }
 
     case 'create-lease': {
-      if (args.length < 1) {
-        const usage = getSubcommandUsage('tx', 'billing', 'create-lease');
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          `create-lease requires at least one sku-uuid:quantity pair. Usage: create-lease ${usage || '<sku-uuid:quantity>...'}`,
-          { usage }
-        );
-      }
+      // Parse optional --meta-hash flag (can appear anywhere in args)
+      const { value: metaHashHex, consumedIndices } = extractFlag(args, '--meta-hash', 'billing create-lease');
+      const metaHash = metaHashHex ? parseHexBytes(metaHashHex, 'meta-hash', MAX_META_HASH_BYTES) : undefined;
+
+      // Filter out --meta-hash and its value to get item args
+      const itemArgs = filterConsumedArgs(args, consumedIndices);
+      requireArgs(itemArgs, 1, ['sku-uuid:quantity'], 'billing create-lease');
 
       // Parse items (format: sku-uuid:quantity ...)
-      const items = args.map((arg) => {
-        const [skuUuid, quantityStr] = arg.split(':');
-        if (!skuUuid || !quantityStr) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            `Invalid lease item format: ${arg}. Expected format: sku-uuid:quantity`
-          );
-        }
+      const items = itemArgs.map((arg) => {
+        const [skuUuid, quantityStr] = parseColonPair(arg, 'sku-uuid', 'quantity', 'lease item');
         return { skuUuid, quantity: parseBigInt(quantityStr, 'quantity') };
       });
 
@@ -74,6 +61,7 @@ export async function routeBillingTransaction(
         value: MsgCreateLease.fromPartial({
           tenant: senderAddress,
           items,
+          metaHash: metaHash ?? new Uint8Array(),
         }),
       };
 
@@ -82,25 +70,20 @@ export async function routeBillingTransaction(
     }
 
     case 'close-lease': {
-      if (args.length < 1) {
-        const usage = getSubcommandUsage('tx', 'billing', 'close-lease');
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          `close-lease requires at least one lease-uuid argument. Usage: close-lease ${usage || '<lease-uuid>...'}`,
-          { usage }
-        );
-      }
+      // Parse optional --reason flag
+      const { value: reason, consumedIndices } = extractFlag(args, '--reason', 'billing close-lease');
+      const leaseArgs = filterConsumedArgs(args, consumedIndices);
+      requireArgs(leaseArgs, 1, ['lease-uuid'], 'billing close-lease');
 
       // MsgCloseLease can close multiple leases at once
-      const leaseUuids = args;
-      const reason = ''; // Optional reason, could be added as a flag later
+      const leaseUuids = leaseArgs;
 
       const msg = {
         typeUrl: '/liftedinit.billing.v1.MsgCloseLease',
         value: MsgCloseLease.fromPartial({
           sender: senderAddress,
           leaseUuids,
-          reason,
+          reason: reason ?? '',
         }),
       };
 
@@ -109,31 +92,56 @@ export async function routeBillingTransaction(
     }
 
     case 'withdraw': {
-      if (args.length < 1) {
-        const usage = getSubcommandUsage('tx', 'billing', 'withdraw');
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          `withdraw requires at least one lease-uuid argument or provider-uuid with --provider flag. Usage: withdraw ${usage || '<lease-uuid>... OR --provider <provider-uuid>'}`,
-          { usage }
-        );
-      }
+      requireArgs(args, 1, ['lease-uuid or --provider'], 'billing withdraw');
+
+      // Extract flags
+      const providerFlag = extractFlag(args, '--provider', 'billing withdraw');
+      const limitFlag = extractFlag(args, '--limit', 'billing withdraw');
 
-      // Check if using provider-wide withdrawal
-      const providerFlagIndex = args.indexOf('--provider');
       let leaseUuids: string[] = [];
       let providerUuid = '';
+      let limit = BigInt(0); // 0 means use default (50)
 
-      if (providerFlagIndex !== -1) {
+      if (providerFlag.value) {
         // Provider-wide withdrawal mode
-        providerUuid = args[providerFlagIndex + 1] || '';
-        if (!providerUuid) {
+        providerUuid = providerFlag.value;
+
+        // Parse optional --limit flag (only valid with --provider)
+        if (limitFlag.value) {
+          limit = parseBigInt(limitFlag.value, 'limit');
+          if (limit < BigInt(1) || limit > BigInt(100)) {
+            throw new ManifestMCPError(
+              ManifestMCPErrorCode.TX_FAILED,
+              `Invalid limit: ${limit}. Must be between 1 and 100.`
+            );
+          }
+        }
+
+        // Check for any extra arguments that weren't consumed
+        const allConsumed = [...providerFlag.consumedIndices, ...limitFlag.consumedIndices];
+        const extraArgs = filterConsumedArgs(args, allConsumed);
+        if (extraArgs.length > 0) {
+          const usage = getSubcommandUsage('tx', 'billing', 'withdraw');
           throw new ManifestMCPError(
             ManifestMCPErrorCode.TX_FAILED,
-            'withdraw with --provider flag requires provider-uuid argument'
+            `Provider-wide withdrawal does not accept additional arguments. ` +
+            `Got unexpected: ${extraArgs.map(a => `"${a}"`).join(', ')}. ` +
+            `For lease-specific withdrawal, omit --provider flag. Usage: withdraw ${usage ?? '<args>'}`
           );
         }
       } else {
         // Lease-specific withdrawal mode
+        // Check for unexpected flags (--limit without --provider is invalid)
+        const unexpectedFlags = args.filter(arg => arg.startsWith('--'));
+        if (unexpectedFlags.length > 0) {
+          const usage = getSubcommandUsage('tx', 'billing', 'withdraw');
+          throw new ManifestMCPError(
+            ManifestMCPErrorCode.TX_FAILED,
+            `Unexpected flag(s) in lease-specific withdrawal mode: ${unexpectedFlags.join(', ')}. ` +
+            `Use --provider for provider-wide withdrawal. Usage: withdraw ${usage ?? '<args>'}`
+          );
+        }
+
         leaseUuids = args;
       }
 
@@ -143,6 +151,7 @@ export async function routeBillingTransaction(
           sender: senderAddress,
           leaseUuids,
           providerUuid,
+          limit,
         }),
       };
 
@@ -151,10 +160,6 @@ export async function routeBillingTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported billing transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['fund-credit', 'create-lease', 'close-lease', 'withdraw'] }
-      );
+      throwUnsupportedSubcommand('tx', 'billing', subcommand);
   }
 }

package/src/transactions/distribution.ts

@@ -1,7 +1,8 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { cosmos } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+import { CosmosTxResult } from '../types.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength, requireArgs } from './utils.js';
 
 const { MsgWithdrawDelegatorReward, MsgSetWithdrawAddress, MsgFundCommunityPool } = cosmos.distribution.v1beta1;
 
@@ -13,20 +14,13 @@ export async function routeDistributionTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'distribution transaction');
 
   switch (subcommand) {
     case 'withdraw-rewards': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'withdraw-rewards requires validator-address argument'
-        );
-      }
-
+      requireArgs(args, 1, ['validator-address'], 'distribution withdraw-rewards');
       const [validatorAddress] = args;
       validateAddress(validatorAddress, 'validator address');
 
@@ -43,13 +37,7 @@ export async function routeDistributionTransaction(
     }
 
     case 'set-withdraw-addr': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'set-withdraw-addr requires withdraw-address argument'
-        );
-      }
-
+      requireArgs(args, 1, ['withdraw-address'], 'distribution set-withdraw-addr');
       const [withdrawAddress] = args;
       validateAddress(withdrawAddress, 'withdraw address');
 
@@ -66,13 +54,7 @@ export async function routeDistributionTransaction(
     }
 
     case 'fund-community-pool': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'fund-community-pool requires amount argument'
-        );
-      }
-
+      requireArgs(args, 1, ['amount'], 'distribution fund-community-pool');
       const [amountStr] = args;
       const { amount, denom } = parseAmount(amountStr);
 
@@ -89,10 +71,6 @@ export async function routeDistributionTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported distribution transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['withdraw-rewards', 'set-withdraw-addr', 'fund-community-pool'] }
-      );
+      throwUnsupportedSubcommand('tx', 'distribution', subcommand);
   }
 }

package/src/transactions/gov.ts

@@ -1,10 +1,34 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { cosmos } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, parseBigInt, validateArgsLength } from './utils.js';
+import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult } from '../types.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+import { parseAmount, buildTxResult, parseBigInt, validateArgsLength, extractFlag, requireArgs } from './utils.js';
 
 const { MsgVote, MsgDeposit, MsgVoteWeighted, VoteOption } = cosmos.gov.v1;
 
+/** 10^18 as BigInt for fixed-point math */
+const FIXED18_ONE = BigInt('1000000000000000000');
+
+/**
+ * Format a fixed-18 BigInt as a decimal string without precision loss.
+ * E.g., 500000000000000000n -> "0.5", 1000000000000000000n -> "1.0"
+ */
+function formatFixed18(value: bigint): string {
+  const isNegative = value < BigInt(0);
+  const absValue = isNegative ? -value : value;
+  const intPart = absValue / FIXED18_ONE;
+  const fracPart = absValue % FIXED18_ONE;
+
+  // Pad fraction to 18 digits, then trim trailing zeros
+  const fracStr = fracPart.toString().padStart(18, '0').replace(/0+$/, '');
+
+  const sign = isNegative ? '-' : '';
+  if (fracStr === '') {
+    return `${sign}${intPart}.0`;
+  }
+  return `${sign}${intPart}.${fracStr}`;
+}
+
 /**
  * Parse a decimal weight string to an 18-decimal fixed-point string.
  * Uses string manipulation to avoid floating-point precision loss.
@@ -70,30 +94,19 @@ export async function routeGovTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'gov transaction');
 
   switch (subcommand) {
     case 'vote': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'vote requires proposal-id and option arguments'
-        );
-      }
-
+      requireArgs(args, 2, ['proposal-id', 'option'], 'gov vote');
       const [proposalIdStr, optionStr] = args;
       const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
       const option = parseVoteOption(optionStr);
 
       // Extract optional metadata from args
-      let metadata = '';
-      const metadataIndex = args.indexOf('--metadata');
-      if (metadataIndex !== -1 && args[metadataIndex + 1]) {
-        metadata = args[metadataIndex + 1];
-      }
+      const { value: metadata = '' } = extractFlag(args, '--metadata', 'gov vote');
 
       const msg = {
         typeUrl: '/cosmos.gov.v1.MsgVote',
@@ -110,13 +123,7 @@ export async function routeGovTransaction(
     }
 
     case 'weighted-vote': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'weighted-vote requires proposal-id and options arguments (format: yes=0.5,no=0.5)'
-        );
-      }
-
+      requireArgs(args, 2, ['proposal-id', 'options'], 'gov weighted-vote');
       const [proposalIdStr, optionsStr] = args;
       const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
 
@@ -136,6 +143,15 @@ export async function routeGovTransaction(
         return { option, weight };
       });
 
+      // Validate that weights sum to exactly 1.0 (10^18 in fixed-point)
+      const totalWeight = options.reduce((sum, opt) => sum + BigInt(opt.weight), BigInt(0));
+      if (totalWeight !== FIXED18_ONE) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          `Weighted vote options must sum to exactly 1.0. Got ${formatFixed18(totalWeight)} (${options.map(o => o.weight).join(' + ')} = ${totalWeight})`
+        );
+      }
+
       const msg = {
         typeUrl: '/cosmos.gov.v1.MsgVoteWeighted',
         value: MsgVoteWeighted.fromPartial({
@@ -151,13 +167,7 @@ export async function routeGovTransaction(
     }
 
     case 'deposit': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'deposit requires proposal-id and amount arguments'
-        );
-      }
-
+      requireArgs(args, 2, ['proposal-id', 'amount'], 'gov deposit');
       const [proposalIdStr, amountStr] = args;
       const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
       const { amount, denom } = parseAmount(amountStr);
@@ -176,10 +186,6 @@ export async function routeGovTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported gov transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['vote', 'weighted-vote', 'deposit'] }
-      );
+      throwUnsupportedSubcommand('tx', 'gov', subcommand);
   }
 }

package/src/transactions/index.ts

@@ -1,4 +1,4 @@
-export { parseAmount, buildTxResult, parseBigInt } from './utils.js';
+export { parseAmount, buildTxResult, parseBigInt, parseHexBytes, bytesToHex } from './utils.js';
 export { routeBankTransaction } from './bank.js';
 export { routeStakingTransaction } from './staking.js';
 export { routeDistributionTransaction } from './distribution.js';

package/src/transactions/manifest.ts

@@ -1,7 +1,8 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { liftedinit } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+import { CosmosTxResult } from '../types.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength, parseColonPair, requireArgs } from './utils.js';
 
 const { MsgPayout, MsgBurnHeldBalance } = liftedinit.manifest.v1;
 
@@ -13,29 +14,16 @@ export async function routeManifestTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'manifest transaction');
 
   switch (subcommand) {
     case 'payout': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'payout requires at least one address:amount pair'
-        );
-      }
-
+      requireArgs(args, 1, ['address:amount'], 'manifest payout');
       // Parse payout pairs (format: address:amount ...)
       const payoutPairs = args.map((arg) => {
-        const [address, amountStr] = arg.split(':');
-        if (!address || !amountStr) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            `Invalid payout pair format: ${arg}. Expected format: address:amount`
-          );
-        }
+        const [address, amountStr] = parseColonPair(arg, 'address', 'amount', 'payout pair');
         validateAddress(address, 'payout recipient address');
         const { amount, denom } = parseAmount(amountStr);
         return { address, coin: { denom, amount } };
@@ -54,13 +42,7 @@ export async function routeManifestTransaction(
     }
 
     case 'burn-held-balance': {
-      if (args.length < 1) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'burn-held-balance requires at least one amount argument'
-        );
-      }
-
+      requireArgs(args, 1, ['amount'], 'manifest burn-held-balance');
       // Parse coins to burn
       const burnCoins = args.map((amountStr) => {
         const { amount, denom } = parseAmount(amountStr);
@@ -80,10 +62,6 @@ export async function routeManifestTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported manifest transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['payout', 'burn-held-balance'] }
-      );
+      throwUnsupportedSubcommand('tx', 'manifest', subcommand);
   }
 }

package/src/transactions/staking.ts

@@ -1,7 +1,8 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
 import { cosmos } from '@manifest-network/manifestjs';
-import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
-import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+import { CosmosTxResult } from '../types.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength, requireArgs } from './utils.js';
 
 const { MsgDelegate, MsgUndelegate, MsgBeginRedelegate } = cosmos.staking.v1beta1;
 
@@ -13,20 +14,13 @@ export async function routeStakingTransaction(
   senderAddress: string,
   subcommand: string,
   args: string[],
-  _config: ManifestMCPConfig,
   waitForConfirmation: boolean
 ): Promise<CosmosTxResult> {
   validateArgsLength(args, 'staking transaction');
 
   switch (subcommand) {
     case 'delegate': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'delegate requires validator-address and amount arguments'
-        );
-      }
-
+      requireArgs(args, 2, ['validator-address', 'amount'], 'staking delegate');
       const [validatorAddress, amountStr] = args;
       validateAddress(validatorAddress, 'validator address');
       const { amount, denom } = parseAmount(amountStr);
@@ -46,13 +40,7 @@ export async function routeStakingTransaction(
 
     case 'unbond':
     case 'undelegate': {
-      if (args.length < 2) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'unbond requires validator-address and amount arguments'
-        );
-      }
-
+      requireArgs(args, 2, ['validator-address', 'amount'], 'staking unbond');
       const [validatorAddress, amountStr] = args;
       validateAddress(validatorAddress, 'validator address');
       const { amount, denom } = parseAmount(amountStr);
@@ -71,13 +59,7 @@ export async function routeStakingTransaction(
     }
 
     case 'redelegate': {
-      if (args.length < 3) {
-        throw new ManifestMCPError(
-          ManifestMCPErrorCode.TX_FAILED,
-          'redelegate requires src-validator, dst-validator, and amount arguments'
-        );
-      }
-
+      requireArgs(args, 3, ['src-validator', 'dst-validator', 'amount'], 'staking redelegate');
       const [srcValidatorAddress, dstValidatorAddress, amountStr] = args;
       validateAddress(srcValidatorAddress, 'source validator address');
       validateAddress(dstValidatorAddress, 'destination validator address');
@@ -98,10 +80,6 @@ export async function routeStakingTransaction(
     }
 
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported staking transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['delegate', 'unbond', 'redelegate'] }
-      );
+      throwUnsupportedSubcommand('tx', 'staking', subcommand);
   }
 }