@manifest-network/manifest-mcp-browser 0.1.0

package/src/queries/distribution.ts

@@ -0,0 +1,138 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseBigInt, defaultPagination } from './utils.js';
+
+/**
+ * Route distribution query to manifestjs query client
+ */
+export async function routeDistributionQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const distribution = queryClient.cosmos.distribution.v1beta1;
+
+  switch (subcommand) {
+    case 'rewards': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'rewards requires delegator-address argument'
+        );
+      }
+      const [delegatorAddress] = args;
+      const validatorAddress = args[1];
+
+      if (validatorAddress) {
+        // Get rewards from specific validator
+        const result = await distribution.delegationRewards({
+          delegatorAddress,
+          validatorAddress,
+        });
+        return { rewards: result.rewards };
+      } else {
+        // Get rewards from all validators
+        const result = await distribution.delegationTotalRewards({ delegatorAddress });
+        return {
+          rewards: result.rewards,
+          total: result.total,
+        };
+      }
+    }
+
+    case 'commission': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'commission requires validator-address argument'
+        );
+      }
+      const [validatorAddress] = args;
+      const result = await distribution.validatorCommission({ validatorAddress });
+      return { commission: result.commission };
+    }
+
+    case 'community-pool': {
+      const result = await distribution.communityPool({});
+      return { pool: result.pool };
+    }
+
+    case 'params': {
+      const result = await distribution.params({});
+      return { params: result.params };
+    }
+
+    case 'validator-outstanding-rewards': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'validator-outstanding-rewards requires validator-address argument'
+        );
+      }
+      const [validatorAddress] = args;
+      const result = await distribution.validatorOutstandingRewards({ validatorAddress });
+      return { rewards: result.rewards };
+    }
+
+    case 'slashes': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'slashes requires validator-address argument'
+        );
+      }
+      const [validatorAddress] = args;
+      const startingHeight = args[1] ? parseBigInt(args[1], 'starting-height') : BigInt(0);
+      const endingHeight = args[2] ? parseBigInt(args[2], 'ending-height') : BigInt(Number.MAX_SAFE_INTEGER);
+      const result = await distribution.validatorSlashes({
+        validatorAddress,
+        startingHeight,
+        endingHeight,
+        pagination: defaultPagination,
+      });
+      return { slashes: result.slashes, pagination: result.pagination };
+    }
+
+    case 'delegator-validators': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'delegator-validators requires delegator-address argument'
+        );
+      }
+      const [delegatorAddress] = args;
+      const result = await distribution.delegatorValidators({ delegatorAddress });
+      return { validators: result.validators };
+    }
+
+    case 'delegator-withdraw-address': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'delegator-withdraw-address requires delegator-address argument'
+        );
+      }
+      const [delegatorAddress] = args;
+      const result = await distribution.delegatorWithdrawAddress({ delegatorAddress });
+      return { withdrawAddress: result.withdrawAddress };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported distribution query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'rewards',
+            'commission',
+            'community-pool',
+            'params',
+            'validator-outstanding-rewards',
+            'slashes',
+            'delegator-validators',
+            'delegator-withdraw-address',
+          ],
+        }
+      );
+  }
+}

package/src/queries/gov.ts

@@ -0,0 +1,128 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseBigInt, parseInt, defaultPagination } from './utils.js';
+
+/**
+ * Route gov query to manifestjs query client
+ */
+export async function routeGovQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const gov = queryClient.cosmos.gov.v1;
+
+  switch (subcommand) {
+    case 'proposal': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'proposal requires proposal-id argument'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const result = await gov.proposal({ proposalId });
+      return { proposal: result.proposal };
+    }
+
+    case 'proposals': {
+      // Parse optional status filter
+      const proposalStatus = args[0] ? parseInt(args[0], 'status') : 0;
+      const voter = args[1] || '';
+      const depositor = args[2] || '';
+      const result = await gov.proposals({ proposalStatus, voter, depositor, pagination: defaultPagination });
+      return { proposals: result.proposals, pagination: result.pagination };
+    }
+
+    case 'vote': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'vote requires proposal-id and voter-address arguments'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const voter = args[1];
+      const result = await gov.vote({ proposalId, voter });
+      return { vote: result.vote };
+    }
+
+    case 'votes': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'votes requires proposal-id argument'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const result = await gov.votes({ proposalId, pagination: defaultPagination });
+      return { votes: result.votes, pagination: result.pagination };
+    }
+
+    case 'deposit': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'deposit requires proposal-id and depositor-address arguments'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const depositor = args[1];
+      const result = await gov.deposit({ proposalId, depositor });
+      return { deposit: result.deposit };
+    }
+
+    case 'deposits': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'deposits requires proposal-id argument'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const result = await gov.deposits({ proposalId, pagination: defaultPagination });
+      return { deposits: result.deposits, pagination: result.pagination };
+    }
+
+    case 'tally': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'tally requires proposal-id argument'
+        );
+      }
+      const proposalId = parseBigInt(args[0], 'proposal-id');
+      const result = await gov.tallyResult({ proposalId });
+      return { tally: result.tally };
+    }
+
+    case 'params': {
+      const paramsType = args[0] || 'tallying';
+      const result = await gov.params({ paramsType });
+      return {
+        votingParams: result.votingParams,
+        depositParams: result.depositParams,
+        tallyParams: result.tallyParams,
+        params: result.params,
+      };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported gov query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'proposal',
+            'proposals',
+            'vote',
+            'votes',
+            'deposit',
+            'deposits',
+            'tally',
+            'params',
+          ],
+        }
+      );
+  }
+}

package/src/queries/index.ts

@@ -0,0 +1,7 @@
+export { parseBigInt, parseInt, defaultPagination, DEFAULT_PAGE_LIMIT } from './utils.js';
+export { routeBankQuery } from './bank.js';
+export { routeStakingQuery } from './staking.js';
+export { routeDistributionQuery } from './distribution.js';
+export { routeGovQuery } from './gov.js';
+export { routeAuthQuery } from './auth.js';
+export { routeBillingQuery } from './billing.js';

package/src/queries/staking.ts

@@ -0,0 +1,190 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseBigInt, defaultPagination } from './utils.js';
+
+/**
+ * Route staking query to manifestjs query client
+ */
+export async function routeStakingQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const staking = queryClient.cosmos.staking.v1beta1;
+
+  switch (subcommand) {
+    case 'delegation': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'delegation requires delegator-address and validator-address arguments'
+        );
+      }
+      const [delegatorAddr, validatorAddr] = args;
+      const result = await staking.delegation({
+        delegatorAddr,
+        validatorAddr,
+      });
+      return { delegationResponse: result.delegationResponse };
+    }
+
+    case 'delegations': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'delegations requires delegator-address argument'
+        );
+      }
+      const [delegatorAddr] = args;
+      const result = await staking.delegatorDelegations({ delegatorAddr, pagination: defaultPagination });
+      return {
+        delegationResponses: result.delegationResponses,
+        pagination: result.pagination,
+      };
+    }
+
+    case 'unbonding-delegation': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'unbonding-delegation requires delegator-address and validator-address arguments'
+        );
+      }
+      const [delegatorAddr, validatorAddr] = args;
+      const result = await staking.unbondingDelegation({
+        delegatorAddr,
+        validatorAddr,
+      });
+      return { unbond: result.unbond };
+    }
+
+    case 'unbonding-delegations': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'unbonding-delegations requires delegator-address argument'
+        );
+      }
+      const [delegatorAddr] = args;
+      const result = await staking.delegatorUnbondingDelegations({ delegatorAddr, pagination: defaultPagination });
+      return {
+        unbondingResponses: result.unbondingResponses,
+        pagination: result.pagination,
+      };
+    }
+
+    case 'redelegations': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'redelegations requires delegator-address argument'
+        );
+      }
+      const [delegatorAddr] = args;
+      const srcValidatorAddr = args[1] || '';
+      const dstValidatorAddr = args[2] || '';
+      const result = await staking.redelegations({
+        delegatorAddr,
+        srcValidatorAddr,
+        dstValidatorAddr,
+        pagination: defaultPagination,
+      });
+      return {
+        redelegationResponses: result.redelegationResponses,
+        pagination: result.pagination,
+      };
+    }
+
+    case 'validator': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'validator requires validator-address argument'
+        );
+      }
+      const [validatorAddr] = args;
+      const result = await staking.validator({ validatorAddr });
+      return { validator: result.validator };
+    }
+
+    case 'validators': {
+      const status = args[0] || '';
+      const result = await staking.validators({ status, pagination: defaultPagination });
+      return { validators: result.validators, pagination: result.pagination };
+    }
+
+    case 'validator-delegations': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'validator-delegations requires validator-address argument'
+        );
+      }
+      const [validatorAddr] = args;
+      const result = await staking.validatorDelegations({ validatorAddr, pagination: defaultPagination });
+      return {
+        delegationResponses: result.delegationResponses,
+        pagination: result.pagination,
+      };
+    }
+
+    case 'validator-unbonding-delegations': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'validator-unbonding-delegations requires validator-address argument'
+        );
+      }
+      const [validatorAddr] = args;
+      const result = await staking.validatorUnbondingDelegations({ validatorAddr, pagination: defaultPagination });
+      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': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'historical-info requires height argument'
+        );
+      }
+      const height = parseBigInt(args[0], 'height');
+      const result = await staking.historicalInfo({ height });
+      return { hist: result.hist };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported staking query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'delegation',
+            'delegations',
+            'unbonding-delegation',
+            'unbonding-delegations',
+            'redelegations',
+            'validator',
+            'validators',
+            'validator-delegations',
+            'validator-unbonding-delegations',
+            'pool',
+            'params',
+            'historical-info',
+          ],
+        }
+      );
+  }
+}

package/src/queries/utils.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { parseBigInt, parseInt } 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('parseInt', () => {
+  it('should parse valid integer strings', () => {
+    expect(parseInt('0', 'status')).toBe(0);
+    expect(parseInt('123', 'status')).toBe(123);
+    expect(parseInt('-5', 'status')).toBe(-5);
+  });
+
+  it('should throw ManifestMCPError for invalid integers', () => {
+    expect(() => parseInt('', 'status')).toThrow(ManifestMCPError);
+    expect(() => parseInt('abc', 'status')).toThrow(ManifestMCPError);
+  });
+
+  it('should have correct error code', () => {
+    try {
+      parseInt('invalid', 'status');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ManifestMCPError);
+      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.QUERY_FAILED);
+    }
+  });
+});

package/src/queries/utils.ts

@@ -0,0 +1,38 @@
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseBigIntWithCode } from '../transactions/utils.js';
+
+/** Default page size limit for paginated queries to prevent resource exhaustion */
+export const DEFAULT_PAGE_LIMIT = BigInt(100);
+
+/**
+ * Default pagination configuration for queries
+ * Uses Cosmos SDK pagination format
+ */
+export const defaultPagination = {
+  key: new Uint8Array(),
+  offset: BigInt(0),
+  limit: DEFAULT_PAGE_LIMIT,
+  countTotal: false,
+  reverse: false,
+};
+
+/**
+ * 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
+ */
+export function parseInt(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;
+}

package/src/transactions/bank.ts

@@ -0,0 +1,110 @@
+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';
+
+const { MsgSend, MsgMultiSend } = cosmos.bank.v1beta1;
+
+/**
+ * Route bank transaction to appropriate handler
+ */
+export async function routeBankTransaction(
+  client: SigningStargateClient,
+  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'
+        );
+      }
+
+      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];
+        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': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'multi-send requires at least one recipient:amount pair'
+        );
+      }
+
+      // 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`
+          );
+        }
+        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:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported bank transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['send', 'multi-send'] }
+      );
+  }
+}