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

package/src/queries/utils.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  parseBigInt,
-  parseInteger,
-  createPagination,
-  extractPaginationArgs,
-  DEFAULT_PAGE_LIMIT,
-  MAX_PAGE_LIMIT,
-} from './utils.js';
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-
-describe('parseBigInt', () => {
-  it('should parse valid integer strings', () => {
-    expect(parseBigInt('0', 'height')).toBe(BigInt(0));
-    expect(parseBigInt('123', 'height')).toBe(BigInt(123));
-    expect(parseBigInt('9999999999999999999', 'height')).toBe(BigInt('9999999999999999999'));
-  });
-
-  it('should throw ManifestMCPError for invalid integers', () => {
-    expect(() => parseBigInt('abc', 'height')).toThrow(ManifestMCPError);
-    expect(() => parseBigInt('12.34', 'height')).toThrow(ManifestMCPError);
-  });
-
-  it('should throw ManifestMCPError for empty string', () => {
-    // Empty string should be rejected for security (prevents accidental 0 values)
-    expect(() => parseBigInt('', 'height')).toThrow(ManifestMCPError);
-    expect(() => parseBigInt('   ', 'height')).toThrow(ManifestMCPError);
-  });
-
-  it('should have correct error code', () => {
-    try {
-      parseBigInt('invalid', 'height');
-    } catch (error) {
-      expect(error).toBeInstanceOf(ManifestMCPError);
-      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.QUERY_FAILED);
-    }
-  });
-
-  it('should include field name in error message', () => {
-    try {
-      parseBigInt('invalid', 'block-height');
-    } catch (error) {
-      expect((error as ManifestMCPError).message).toContain('block-height');
-    }
-  });
-});
-
-describe('parseInteger', () => {
-  it('should parse valid integer strings', () => {
-    expect(parseInteger('0', 'status')).toBe(0);
-    expect(parseInteger('123', 'status')).toBe(123);
-    expect(parseInteger('-5', 'status')).toBe(-5);
-  });
-
-  it('should throw ManifestMCPError for invalid integers', () => {
-    expect(() => parseInteger('', 'status')).toThrow(ManifestMCPError);
-    expect(() => parseInteger('abc', 'status')).toThrow(ManifestMCPError);
-  });
-
-  it('should have correct error code', () => {
-    try {
-      parseInteger('invalid', 'status');
-    } catch (error) {
-      expect(error).toBeInstanceOf(ManifestMCPError);
-      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.QUERY_FAILED);
-    }
-  });
-});
-
-describe('createPagination', () => {
-  it('should use default limit when none provided', () => {
-    const pagination = createPagination();
-    expect(pagination.limit).toBe(DEFAULT_PAGE_LIMIT);
-    expect(pagination.offset).toBe(BigInt(0));
-    expect(pagination.countTotal).toBe(false);
-    expect(pagination.reverse).toBe(false);
-    expect(pagination.key).toEqual(new Uint8Array());
-  });
-
-  it('should use provided limit', () => {
-    const pagination = createPagination(BigInt(50));
-    expect(pagination.limit).toBe(BigInt(50));
-  });
-
-  it('should clamp limit to minimum of 1', () => {
-    const pagination = createPagination(BigInt(0));
-    expect(pagination.limit).toBe(BigInt(1));
-
-    const paginationNegative = createPagination(BigInt(-10));
-    expect(paginationNegative.limit).toBe(BigInt(1));
-  });
-
-  it('should clamp limit to maximum', () => {
-    const pagination = createPagination(BigInt(9999));
-    expect(pagination.limit).toBe(MAX_PAGE_LIMIT);
-  });
-});
-
-describe('extractPaginationArgs', () => {
-  it('should return default pagination when no --limit flag', () => {
-    const { pagination, remainingArgs } = extractPaginationArgs(['arg1', 'arg2'], 'test');
-    expect(pagination.limit).toBe(DEFAULT_PAGE_LIMIT);
-    expect(remainingArgs).toEqual(['arg1', 'arg2']);
-  });
-
-  it('should extract --limit flag and value', () => {
-    const { pagination, remainingArgs } = extractPaginationArgs(
-      ['arg1', '--limit', '50', 'arg2'],
-      'test'
-    );
-    expect(pagination.limit).toBe(BigInt(50));
-    expect(remainingArgs).toEqual(['arg1', 'arg2']);
-  });
-
-  it('should handle --limit at end of args', () => {
-    const { pagination, remainingArgs } = extractPaginationArgs(
-      ['arg1', '--limit', '25'],
-      'test'
-    );
-    expect(pagination.limit).toBe(BigInt(25));
-    expect(remainingArgs).toEqual(['arg1']);
-  });
-
-  it('should handle --limit at start of args', () => {
-    const { pagination, remainingArgs } = extractPaginationArgs(
-      ['--limit', '75', 'arg1'],
-      'test'
-    );
-    expect(pagination.limit).toBe(BigInt(75));
-    expect(remainingArgs).toEqual(['arg1']);
-  });
-
-  it('should throw for invalid limit value', () => {
-    expect(() =>
-      extractPaginationArgs(['--limit', 'abc'], 'test')
-    ).toThrow(ManifestMCPError);
-  });
-
-  it('should throw for limit below minimum', () => {
-    expect(() =>
-      extractPaginationArgs(['--limit', '0'], 'test')
-    ).toThrow(ManifestMCPError);
-  });
-
-  it('should throw for limit above maximum', () => {
-    expect(() =>
-      extractPaginationArgs(['--limit', '9999'], 'test')
-    ).toThrow(ManifestMCPError);
-  });
-
-  it('should handle empty args array', () => {
-    const { pagination, remainingArgs } = extractPaginationArgs([], 'test');
-    expect(pagination.limit).toBe(DEFAULT_PAGE_LIMIT);
-    expect(remainingArgs).toEqual([]);
-  });
-});

package/src/queries/utils.ts

@@ -1,145 +0,0 @@
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.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();
-
-/**
- * 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 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)
- */
-export function parseBigInt(value: string, fieldName: string): bigint {
-  return parseBigIntWithCode(value, fieldName, ManifestMCPErrorCode.QUERY_FAILED);
-}
-
-/**
- * Safely parse a string to integer with proper error handling.
- * Named parseInteger to avoid shadowing global parseInt.
- */
-export function parseInteger(value: string, fieldName: string): number {
-  const parsed = Number.parseInt(value, 10);
-  if (Number.isNaN(parsed)) {
-    throw new ManifestMCPError(
-      ManifestMCPErrorCode.QUERY_FAILED,
-      `Invalid ${fieldName}: "${value}". Expected a valid integer.`
-    );
-  }
-  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,86 +0,0 @@
-import { SigningStargateClient } from '@cosmjs/stargate';
-import { cosmos } from '@manifest-network/manifestjs';
-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;
-
-/**
- * Route bank transaction to appropriate handler
- */
-export async function routeBankTransaction(
-  client: SigningStargateClient,
-  senderAddress: string,
-  subcommand: string,
-  args: string[],
-  waitForConfirmation: boolean
-): Promise<CosmosTxResult> {
-  validateArgsLength(args, 'bank transaction');
-
-  switch (subcommand) {
-    case 'send': {
-      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
-      const { value: memo = '' } = extractFlag(args, '--memo', 'bank send');
-      if (memo) {
-        validateMemo(memo);
-      }
-
-      const msg = {
-        typeUrl: '/cosmos.bank.v1beta1.MsgSend',
-        value: MsgSend.fromPartial({
-          fromAddress: senderAddress,
-          toAddress: recipientAddress,
-          amount: [{ denom, amount }],
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto', memo);
-      return buildTxResult('bank', 'send', result, waitForConfirmation);
-    }
-
-    case 'multi-send': {
-      requireArgs(args, 1, ['recipient:amount'], 'bank multi-send');
-      // Parse format: multi-send recipient1:amount1 recipient2:amount2 ...
-      const outputs = args.map((arg) => {
-        const [address, amountStr] = parseColonPair(arg, 'address', 'amount', 'multi-send');
-        validateAddress(address, 'recipient address');
-        const { amount, denom } = parseAmount(amountStr);
-        return { address, coins: [{ denom, amount }] };
-      });
-
-      // Calculate total input
-      const totalByDenom = new Map<string, bigint>();
-      for (const output of outputs) {
-        for (const coin of output.coins) {
-          const current = totalByDenom.get(coin.denom) || BigInt(0);
-          totalByDenom.set(coin.denom, current + BigInt(coin.amount));
-        }
-      }
-
-      const inputCoins = Array.from(totalByDenom.entries()).map(([denom, amount]) => ({
-        denom,
-        amount: amount.toString(),
-      }));
-
-      const msg = {
-        typeUrl: '/cosmos.bank.v1beta1.MsgMultiSend',
-        value: MsgMultiSend.fromPartial({
-          inputs: [{ address: senderAddress, coins: inputCoins }],
-          outputs,
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
-      return buildTxResult('bank', 'multi-send', result, waitForConfirmation);
-    }
-
-    default:
-      throwUnsupportedSubcommand('tx', 'bank', subcommand);
-  }
-}

package/src/transactions/billing.ts

@@ -1,286 +0,0 @@
-import { SigningStargateClient } from '@cosmjs/stargate';
-import { liftedinit } from '@manifest-network/manifestjs';
-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,
-  MsgCreateLeaseForTenant, MsgAcknowledgeLease, MsgRejectLease, MsgCancelLease,
-  MsgUpdateParams,
-} = liftedinit.billing.v1;
-
-/**
- * Route billing transaction to appropriate handler
- */
-export async function routeBillingTransaction(
-  client: SigningStargateClient,
-  senderAddress: string,
-  subcommand: string,
-  args: string[],
-  waitForConfirmation: boolean
-): Promise<CosmosTxResult> {
-  validateArgsLength(args, 'billing transaction');
-
-  switch (subcommand) {
-    case 'fund-credit': {
-      requireArgs(args, 2, ['tenant-address', 'amount'], 'billing fund-credit');
-      const [tenant, amountStr] = args;
-      validateAddress(tenant, 'tenant address');
-      const { amount, denom } = parseAmount(amountStr);
-
-      const msg = {
-        typeUrl: '/liftedinit.billing.v1.MsgFundCredit',
-        value: MsgFundCredit.fromPartial({
-          sender: senderAddress,
-          tenant,
-          amount: { denom, amount },
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
-      return buildTxResult('billing', 'fund-credit', result, waitForConfirmation);
-    }
-
-    case 'create-lease': {
-      // 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 = 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.MsgCreateLease',
-        value: MsgCreateLease.fromPartial({
-          tenant: senderAddress,
-          items,
-          metaHash: metaHash ?? new Uint8Array(),
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
-      return buildTxResult('billing', 'create-lease', result, waitForConfirmation);
-    }
-
-    case 'close-lease': {
-      // 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 = leaseArgs;
-
-      const msg = {
-        typeUrl: '/liftedinit.billing.v1.MsgCloseLease',
-        value: MsgCloseLease.fromPartial({
-          sender: senderAddress,
-          leaseUuids,
-          reason: reason ?? '',
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
-      return buildTxResult('billing', 'close-lease', result, waitForConfirmation);
-    }
-
-    case 'withdraw': {
-      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');
-
-      let leaseUuids: string[] = [];
-      let providerUuid = '';
-      let limit = BigInt(0); // 0 means use default (50)
-
-      if (providerFlag.value) {
-        // Provider-wide withdrawal mode
-        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,
-            `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;
-      }
-
-      const msg = {
-        typeUrl: '/liftedinit.billing.v1.MsgWithdraw',
-        value: MsgWithdraw.fromPartial({
-          sender: senderAddress,
-          leaseUuids,
-          providerUuid,
-          limit,
-        }),
-      };
-
-      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
-      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:
-      throwUnsupportedSubcommand('tx', 'billing', subcommand);
-  }
-}