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

package/src/queries/utils.ts

@@ -1,20 +1,113 @@
 import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { parseBigIntWithCode } from '../transactions/utils.js';
+import { parseBigIntWithCode, requireArgs as requireArgsBase, extractFlag, filterConsumedArgs } from '../transactions/utils.js';
+
+/**
+ * Result from extracting a boolean (valueless) flag from args
+ */
+export interface ExtractedBooleanFlag {
+  /** Whether the flag was present */
+  value: boolean;
+  /** Args with the flag removed */
+  remainingArgs: string[];
+}
+
+/**
+ * Extract a valueless boolean flag from args array.
+ * Returns { value: true, remainingArgs } if flag is present, { value: false, remainingArgs: args } otherwise.
+ *
+ * @param args - The arguments array to search
+ * @param flagName - The flag to look for (e.g., '--active-only')
+ * @returns Object with boolean value and filtered args
+ */
+export function extractBooleanFlag(args: string[], flagName: string): ExtractedBooleanFlag {
+  const flagIndex = args.indexOf(flagName);
+  if (flagIndex === -1) {
+    return { value: false, remainingArgs: args };
+  }
+  const remainingArgs = args.filter((_, index) => index !== flagIndex);
+  return { value: true, remainingArgs };
+}
 
 /** Default page size limit for paginated queries to prevent resource exhaustion */
 export const DEFAULT_PAGE_LIMIT = BigInt(100);
 
+/** Maximum page size limit to prevent DoS */
+export const MAX_PAGE_LIMIT = BigInt(1000);
+
+/**
+ * Cosmos SDK pagination configuration
+ */
+export interface PaginationConfig {
+  readonly key: Uint8Array;
+  readonly offset: bigint;
+  readonly limit: bigint;
+  readonly countTotal: boolean;
+  readonly reverse: boolean;
+}
+
+/**
+ * Create pagination configuration with optional custom limit.
+ * Validates that limit is within acceptable bounds.
+ *
+ * @param limit - Optional custom limit (defaults to DEFAULT_PAGE_LIMIT)
+ * @returns Cosmos SDK pagination object
+ */
+export function createPagination(limit?: bigint): PaginationConfig {
+  let effectiveLimit = limit ?? DEFAULT_PAGE_LIMIT;
+
+  // Clamp to valid range
+  if (effectiveLimit < BigInt(1)) {
+    effectiveLimit = BigInt(1);
+  } else if (effectiveLimit > MAX_PAGE_LIMIT) {
+    effectiveLimit = MAX_PAGE_LIMIT;
+  }
+
+  return {
+    key: new Uint8Array(),
+    offset: BigInt(0),
+    limit: effectiveLimit,
+    countTotal: false,
+    reverse: false,
+  };
+}
+
+/**
+ * Default pagination configuration for queries (for backwards compatibility)
+ * @deprecated Use createPagination() instead for configurable limits
+ */
+export const defaultPagination = createPagination();
+
 /**
- * Default pagination configuration for queries
- * Uses Cosmos SDK pagination format
+ * Extract --limit flag from args and return pagination config with remaining args.
+ * Use this helper for paginated queries.
+ *
+ * @param args - The arguments array
+ * @param context - Context for error messages
+ * @returns Object with pagination config and filtered args
  */
-export const defaultPagination = {
-  key: new Uint8Array(),
-  offset: BigInt(0),
-  limit: DEFAULT_PAGE_LIMIT,
-  countTotal: false,
-  reverse: false,
-};
+export function extractPaginationArgs(
+  args: string[],
+  context: string
+): { pagination: PaginationConfig; remainingArgs: string[] } {
+  const { value: limitStr, consumedIndices } = extractFlag(args, '--limit', context);
+  const remainingArgs = filterConsumedArgs(args, consumedIndices);
+
+  let pagination: PaginationConfig;
+  if (limitStr) {
+    const limit = parseBigInt(limitStr, 'limit');
+    if (limit < BigInt(1) || limit > MAX_PAGE_LIMIT) {
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.QUERY_FAILED,
+        `Invalid limit: ${limit}. Must be between 1 and ${MAX_PAGE_LIMIT}.`
+      );
+    }
+    pagination = createPagination(limit);
+  } else {
+    pagination = createPagination();
+  }
+
+  return { pagination, remainingArgs };
+}
 
 /**
  * Safely parse a string to BigInt with proper error handling (for queries)
@@ -24,9 +117,10 @@ export function parseBigInt(value: string, fieldName: string): bigint {
 }
 
 /**
- * Safely parse a string to integer with proper error handling
+ * Safely parse a string to integer with proper error handling.
+ * Named parseInteger to avoid shadowing global parseInt.
  */
-export function parseInt(value: string, fieldName: string): number {
+export function parseInteger(value: string, fieldName: string): number {
   const parsed = Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) {
     throw new ManifestMCPError(
@@ -36,3 +130,16 @@ export function parseInt(value: string, fieldName: string): number {
   }
   return parsed;
 }
+
+/**
+ * Validate that required arguments are present (for queries).
+ * Uses QUERY_FAILED error code by default.
+ */
+export function requireArgs(
+  args: string[],
+  minCount: number,
+  expectedNames: string[],
+  context: string
+): void {
+  requireArgsBase(args, minCount, expectedNames, context, ManifestMCPErrorCode.QUERY_FAILED);
+}

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,46 +1,14 @@
 import { SigningStargateClient } from '@cosmjs/stargate';
-import { fromHex } from '@cosmjs/encoding';
 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, MAX_META_HASH_BYTES } 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;
-
-/**
- * Validate and parse a hex string into Uint8Array
- * Uses @cosmjs/encoding for hex validation and conversion
- */
-function parseMetaHash(hexString: string): Uint8Array {
-  // Check even length first to avoid fractional byte counts in error messages
-  if (hexString.length % 2 !== 0) {
-    throw new ManifestMCPError(
-      ManifestMCPErrorCode.TX_FAILED,
-      `Invalid meta-hash: hex string must have even length. Got ${hexString.length} characters.`
-    );
-  }
-
-  // Check max length (64 bytes = 128 hex chars)
-  const byteLength = hexString.length / 2;
-  if (byteLength > MAX_META_HASH_BYTES) {
-    throw new ManifestMCPError(
-      ManifestMCPErrorCode.TX_FAILED,
-      `Invalid meta-hash: exceeds maximum ${MAX_META_HASH_BYTES} bytes. Got ${byteLength} bytes (${hexString.length} hex chars).`
-    );
-  }
-
-  try {
-    return fromHex(hexString);
-  } catch (error) {
-    throw new ManifestMCPError(
-      ManifestMCPErrorCode.TX_FAILED,
-      `Invalid meta-hash: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
+const {
+  MsgFundCredit, MsgCreateLease, MsgCloseLease, MsgWithdraw,
+  MsgCreateLeaseForTenant, MsgAcknowledgeLease, MsgRejectLease, MsgCancelLease,
+  MsgUpdateParams,
+} = liftedinit.billing.v1;
 
 /**
  * Route billing transaction to appropriate handler
@@ -50,22 +18,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);
@@ -84,42 +43,17 @@ export async function routeBillingTransaction(
     }
 
     case 'create-lease': {
-      // Parse optional --meta-hash flag
-      let metaHash: Uint8Array | undefined;
-      let itemArgs = args;
+      // 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;
 
-      if (args[0] === '--meta-hash') {
-        if (args.length < 2 || args[1].startsWith('--')) {
-          const usage = getSubcommandUsage('tx', 'billing', 'create-lease');
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            `--meta-hash flag requires a hex value. Usage: create-lease ${usage ?? '<args>'}`
-          );
-        }
-        const hexHash = args[1];
-        // Validate and convert hex string to Uint8Array (max 64 bytes)
-        metaHash = parseMetaHash(hexHash);
-        itemArgs = args.slice(2);
-      }
-
-      if (itemArgs.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 ?? '<args>'}`,
-          { usage }
-        );
-      }
+      // 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 = itemArgs.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 [skuUuid, quantityStr] = parseColonPair(arg, 'sku-uuid', 'quantity', 'lease item');
         return { skuUuid, quantity: parseBigInt(quantityStr, 'quantity') };
       });
 
@@ -137,25 +71,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 ?? '',
         }),
       };
 
@@ -164,57 +93,34 @@ 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 ?? '<args>'}`,
-          { 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');
-      const limitFlagIndex = args.indexOf('--limit');
       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.startsWith('--')) {
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            'withdraw with --provider flag requires provider-uuid argument'
-          );
-        }
-
-        // Track consumed arg indices to detect extra arguments
-        const consumedIndices = new Set<number>([providerFlagIndex, providerFlagIndex + 1]);
+        providerUuid = providerFlag.value;
 
         // Parse optional --limit flag (only valid with --provider)
-        if (limitFlagIndex !== -1) {
-          const limitStr = args[limitFlagIndex + 1] || '';
-          if (!limitStr || limitStr.startsWith('--')) {
-            throw new ManifestMCPError(
-              ManifestMCPErrorCode.TX_FAILED,
-              'withdraw with --limit flag requires a number argument (1-100)'
-            );
-          }
-          limit = parseBigInt(limitStr, 'limit');
+        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.`
             );
           }
-          consumedIndices.add(limitFlagIndex);
-          consumedIndices.add(limitFlagIndex + 1);
         }
 
         // Check for any extra arguments that weren't consumed
-        const extraArgs = args.filter((_, index) => !consumedIndices.has(index));
+        const allConsumed = [...providerFlag.consumedIndices, ...limitFlag.consumedIndices];
+        const extraArgs = filterConsumedArgs(args, allConsumed);
         if (extraArgs.length > 0) {
           const usage = getSubcommandUsage('tx', 'billing', 'withdraw');
           throw new ManifestMCPError(
@@ -226,7 +132,7 @@ export async function routeBillingTransaction(
         }
       } else {
         // Lease-specific withdrawal mode
-        // Check for unexpected flags
+        // 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');
@@ -238,14 +144,6 @@ export async function routeBillingTransaction(
         }
 
         leaseUuids = args;
-
-        if (leaseUuids.length === 0) {
-          const usage = getSubcommandUsage('tx', 'billing', 'withdraw');
-          throw new ManifestMCPError(
-            ManifestMCPErrorCode.TX_FAILED,
-            `withdraw requires at least one lease-uuid. Usage: withdraw ${usage ?? '<args>'}`
-          );
-        }
       }
 
       const msg = {
@@ -262,11 +160,127 @@ export async function routeBillingTransaction(
       return buildTxResult('billing', 'withdraw', result, waitForConfirmation);
     }
 
+    case 'create-lease-for-tenant': {
+      // Parse optional --meta-hash flag
+      const { value: metaHashHex, consumedIndices } = extractFlag(args, '--meta-hash', 'billing create-lease-for-tenant');
+      const metaHash = metaHashHex ? parseHexBytes(metaHashHex, 'meta-hash', MAX_META_HASH_BYTES) : undefined;
+
+      // Filter out --meta-hash and its value to get remaining args
+      const remainingArgs = filterConsumedArgs(args, consumedIndices);
+      requireArgs(remainingArgs, 2, ['tenant-address', 'sku-uuid:quantity'], 'billing create-lease-for-tenant');
+
+      const [tenant, ...itemArgs] = remainingArgs;
+      validateAddress(tenant, 'tenant address');
+
+      // Parse items (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') };
+      });
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgCreateLeaseForTenant',
+        value: MsgCreateLeaseForTenant.fromPartial({
+          authority: senderAddress,
+          tenant,
+          items,
+          metaHash: metaHash ?? new Uint8Array(),
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'create-lease-for-tenant', result, waitForConfirmation);
+    }
+
+    case 'acknowledge-lease': {
+      requireArgs(args, 1, ['lease-uuid'], 'billing acknowledge-lease');
+      const leaseUuids = args;
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgAcknowledgeLease',
+        value: MsgAcknowledgeLease.fromPartial({
+          sender: senderAddress,
+          leaseUuids,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'acknowledge-lease', result, waitForConfirmation);
+    }
+
+    case 'reject-lease': {
+      // Parse optional --reason flag
+      const { value: reason, consumedIndices } = extractFlag(args, '--reason', 'billing reject-lease');
+      const leaseArgs = filterConsumedArgs(args, consumedIndices);
+      requireArgs(leaseArgs, 1, ['lease-uuid'], 'billing reject-lease');
+
+      const leaseUuids = leaseArgs;
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgRejectLease',
+        value: MsgRejectLease.fromPartial({
+          sender: senderAddress,
+          leaseUuids,
+          reason: reason ?? '',
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'reject-lease', result, waitForConfirmation);
+    }
+
+    case 'cancel-lease': {
+      requireArgs(args, 1, ['lease-uuid'], 'billing cancel-lease');
+      const leaseUuids = args;
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgCancelLease',
+        value: MsgCancelLease.fromPartial({
+          tenant: senderAddress,
+          leaseUuids,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'cancel-lease', result, waitForConfirmation);
+    }
+
+    case 'update-params': {
+      requireArgs(args, 5, [
+        'max-leases-per-tenant', 'max-items-per-lease', 'min-lease-duration',
+        'max-pending-leases-per-tenant', 'pending-timeout',
+      ], 'billing update-params');
+
+      const [
+        maxLeasesPerTenantStr, maxItemsPerLeaseStr, minLeaseDurationStr,
+        maxPendingLeasesPerTenantStr, pendingTimeoutStr,
+        ...allowedAddresses
+      ] = args;
+
+      for (const addr of allowedAddresses) {
+        validateAddress(addr, 'allowed address');
+      }
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgUpdateParams',
+        value: MsgUpdateParams.fromPartial({
+          authority: senderAddress,
+          params: {
+            maxLeasesPerTenant: parseBigInt(maxLeasesPerTenantStr, 'max-leases-per-tenant'),
+            maxItemsPerLease: parseBigInt(maxItemsPerLeaseStr, 'max-items-per-lease'),
+            minLeaseDuration: parseBigInt(minLeaseDurationStr, 'min-lease-duration'),
+            maxPendingLeasesPerTenant: parseBigInt(maxPendingLeasesPerTenantStr, 'max-pending-leases-per-tenant'),
+            pendingTimeout: parseBigInt(pendingTimeoutStr, 'pending-timeout'),
+            allowedList: allowedAddresses,
+          },
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'update-params', result, waitForConfirmation);
+    }
+
     default:
-      throw new ManifestMCPError(
-        ManifestMCPErrorCode.UNSUPPORTED_TX,
-        `Unsupported billing transaction subcommand: ${subcommand}`,
-        { availableSubcommands: ['fund-credit', 'create-lease', 'close-lease', 'withdraw'] }
-      );
+      throwUnsupportedSubcommand('tx', 'billing', subcommand);
   }
 }