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

package/src/queries/staking.ts

@@ -1,154 +0,0 @@
-import { ManifestQueryClient } from '../client.js';
-import {
-  DelegationResult, DelegationsResult, UnbondingDelegationResult, UnbondingDelegationsResult,
-  RedelegationsResult, ValidatorResult, ValidatorsResult, StakingPoolResult,
-  StakingParamsResult, HistoricalInfoResult
-} from '../types.js';
-import { parseBigInt, requireArgs, extractPaginationArgs } from './utils.js';
-import { throwUnsupportedSubcommand } from '../modules.js';
-
-/** Staking query result union type */
-type StakingQueryResult =
-  | DelegationResult
-  | DelegationsResult
-  | UnbondingDelegationResult
-  | UnbondingDelegationsResult
-  | RedelegationsResult
-  | ValidatorResult
-  | ValidatorsResult
-  | StakingPoolResult
-  | StakingParamsResult
-  | HistoricalInfoResult;
-
-/**
- * Route staking query to manifestjs query client
- *
- * Paginated queries support --limit flag (default: 100, max: 1000)
- */
-export async function routeStakingQuery(
-  queryClient: ManifestQueryClient,
-  subcommand: string,
-  args: string[]
-): Promise<StakingQueryResult> {
-  const staking = queryClient.cosmos.staking.v1beta1;
-
-  switch (subcommand) {
-    case 'delegation': {
-      requireArgs(args, 2, ['delegator-address', 'validator-address'], 'staking delegation');
-      const [delegatorAddr, validatorAddr] = args;
-      const result = await staking.delegation({
-        delegatorAddr,
-        validatorAddr,
-      });
-      return { delegationResponse: result.delegationResponse };
-    }
-
-    case 'delegations': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking delegations');
-      requireArgs(remainingArgs, 1, ['delegator-address'], 'staking delegations');
-      const [delegatorAddr] = remainingArgs;
-      const result = await staking.delegatorDelegations({ delegatorAddr, pagination });
-      return {
-        delegationResponses: result.delegationResponses,
-        pagination: result.pagination,
-      };
-    }
-
-    case 'unbonding-delegation': {
-      requireArgs(args, 2, ['delegator-address', 'validator-address'], 'staking unbonding-delegation');
-      const [delegatorAddr, validatorAddr] = args;
-      const result = await staking.unbondingDelegation({
-        delegatorAddr,
-        validatorAddr,
-      });
-      return { unbond: result.unbond };
-    }
-
-    case 'unbonding-delegations': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking unbonding-delegations');
-      requireArgs(remainingArgs, 1, ['delegator-address'], 'staking unbonding-delegations');
-      const [delegatorAddr] = remainingArgs;
-      const result = await staking.delegatorUnbondingDelegations({ delegatorAddr, pagination });
-      return {
-        unbondingResponses: result.unbondingResponses,
-        pagination: result.pagination,
-      };
-    }
-
-    case 'redelegations': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking redelegations');
-      requireArgs(remainingArgs, 1, ['delegator-address'], 'staking redelegations');
-      const [delegatorAddr] = remainingArgs;
-      // Optional: src and dst validator addresses for filtering
-      const srcValidatorAddr = remainingArgs[1] || '';
-      const dstValidatorAddr = remainingArgs[2] || '';
-      const result = await staking.redelegations({
-        delegatorAddr,
-        srcValidatorAddr,
-        dstValidatorAddr,
-        pagination,
-      });
-      return {
-        redelegationResponses: result.redelegationResponses,
-        pagination: result.pagination,
-      };
-    }
-
-    case 'validator': {
-      requireArgs(args, 1, ['validator-address'], 'staking validator');
-      const [validatorAddr] = args;
-      const result = await staking.validator({ validatorAddr });
-      return { validator: result.validator };
-    }
-
-    case 'validators': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking validators');
-      // Optional: status filter
-      const status = remainingArgs[0] || '';
-      const result = await staking.validators({ status, pagination });
-      return { validators: result.validators, pagination: result.pagination };
-    }
-
-    case 'validator-delegations': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking validator-delegations');
-      requireArgs(remainingArgs, 1, ['validator-address'], 'staking validator-delegations');
-      const [validatorAddr] = remainingArgs;
-      const result = await staking.validatorDelegations({ validatorAddr, pagination });
-      return {
-        delegationResponses: result.delegationResponses,
-        pagination: result.pagination,
-      };
-    }
-
-    case 'validator-unbonding-delegations': {
-      const { pagination, remainingArgs } = extractPaginationArgs(args, 'staking validator-unbonding-delegations');
-      requireArgs(remainingArgs, 1, ['validator-address'], 'staking validator-unbonding-delegations');
-      const [validatorAddr] = remainingArgs;
-      const result = await staking.validatorUnbondingDelegations({ validatorAddr, pagination });
-      return {
-        unbondingResponses: result.unbondingResponses,
-        pagination: result.pagination,
-      };
-    }
-
-    case 'pool': {
-      const result = await staking.pool({});
-      return { pool: result.pool };
-    }
-
-    case 'params': {
-      const result = await staking.params({});
-      return { params: result.params };
-    }
-
-    case 'historical-info': {
-      requireArgs(args, 1, ['height'], 'staking historical-info');
-      const height = parseBigInt(args[0], 'height');
-      const result = await staking.historicalInfo({ height });
-      return { hist: result.hist };
-    }
-
-    default:
-      throwUnsupportedSubcommand('query', 'staking', subcommand);
-  }
-}

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,121 +0,0 @@
-import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
-import { parseBigIntWithCode, requireArgs as requireArgsBase, extractFlag, filterConsumedArgs, validateAddress, extractBooleanFlag } from '../transactions/utils.js';
-
-export { validateAddress, extractBooleanFlag };
-export type { ExtractedBooleanFlag } from '../transactions/utils.js';
-
-/** 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);
-  }
-}