@manifest-network/manifest-mcp-browser 0.1.0

package/src/modules.ts

@@ -0,0 +1,278 @@
+import { ModuleInfo, AvailableModules, ManifestMCPError, ManifestMCPErrorCode } from './types.js';
+
+/**
+ * Static module registry for browser-compatible module discovery
+ * All modules use manifestjs for full protobuf support
+ */
+
+interface SubcommandInfo {
+  name: string;
+  description: string;
+  args?: string; // Usage hint for arguments
+}
+
+interface ModuleRegistry {
+  [moduleName: string]: {
+    description: string;
+    subcommands: SubcommandInfo[];
+  };
+}
+
+/**
+ * Query modules registry
+ */
+const QUERY_MODULES: ModuleRegistry = {
+  bank: {
+    description: 'Querying commands for the bank module',
+    subcommands: [
+      { name: 'balance', description: 'Query account balance for a specific denom' },
+      { name: 'balances', description: 'Query all balances for an account' },
+      { name: 'spendable-balances', description: 'Query spendable balances for an account' },
+      { name: 'total-supply', description: 'Query total supply of all tokens' },
+      { name: 'total', description: 'Query total supply of all tokens (alias for total-supply)' },
+      { name: 'supply-of', description: 'Query supply of a specific denom' },
+      { name: 'params', description: 'Query bank parameters' },
+      { name: 'denom-metadata', description: 'Query metadata for a specific denom' },
+      { name: 'denoms-metadata', description: 'Query metadata for all denoms' },
+      { name: 'send-enabled', description: 'Query send enabled status for denoms' },
+    ],
+  },
+  staking: {
+    description: 'Querying commands for the staking module',
+    subcommands: [
+      { name: 'delegation', description: 'Query a delegation' },
+      { name: 'delegations', description: 'Query all delegations for a delegator' },
+      { name: 'unbonding-delegation', description: 'Query an unbonding delegation' },
+      { name: 'unbonding-delegations', description: 'Query all unbonding delegations for a delegator' },
+      { name: 'redelegations', description: 'Query redelegations' },
+      { name: 'validator', description: 'Query a validator' },
+      { name: 'validators', description: 'Query all validators' },
+      { name: 'validator-delegations', description: 'Query all delegations to a validator' },
+      { name: 'validator-unbonding-delegations', description: 'Query all unbonding delegations from a validator' },
+      { name: 'pool', description: 'Query staking pool' },
+      { name: 'params', description: 'Query staking parameters' },
+      { name: 'historical-info', description: 'Query historical info at a height' },
+    ],
+  },
+  distribution: {
+    description: 'Querying commands for the distribution module',
+    subcommands: [
+      { name: 'rewards', description: 'Query distribution rewards for a delegator' },
+      { name: 'commission', description: 'Query validator commission' },
+      { name: 'community-pool', description: 'Query community pool coins' },
+      { name: 'params', description: 'Query distribution parameters' },
+      { name: 'validator-outstanding-rewards', description: 'Query validator outstanding rewards' },
+      { name: 'slashes', description: 'Query slashes for a validator' },
+      { name: 'delegator-validators', description: 'Query validators for a delegator' },
+      { name: 'delegator-withdraw-address', description: 'Query delegator withdraw address' },
+    ],
+  },
+  gov: {
+    description: 'Querying commands for the governance module',
+    subcommands: [
+      { name: 'proposal', description: 'Query a proposal by ID' },
+      { name: 'proposals', description: 'Query all proposals' },
+      { name: 'vote', description: 'Query a vote on a proposal' },
+      { name: 'votes', description: 'Query all votes on a proposal' },
+      { name: 'deposit', description: 'Query a deposit on a proposal' },
+      { name: 'deposits', description: 'Query all deposits on a proposal' },
+      { name: 'tally', description: 'Query tally of a proposal' },
+      { name: 'params', description: 'Query governance parameters' },
+    ],
+  },
+  auth: {
+    description: 'Querying commands for the auth module',
+    subcommands: [
+      { name: 'account', description: 'Query account by address' },
+      { name: 'accounts', description: 'Query all accounts' },
+      { name: 'params', description: 'Query auth parameters' },
+      { name: 'module-accounts', description: 'Query all module accounts' },
+      { name: 'module-account-by-name', description: 'Query module account by name' },
+      { name: 'address-bytes-to-string', description: 'Convert address bytes to string' },
+      { name: 'address-string-to-bytes', description: 'Convert address string to bytes' },
+      { name: 'bech32-prefix', description: 'Query bech32 prefix' },
+      { name: 'account-info', description: 'Query account info' },
+    ],
+  },
+  billing: {
+    description: 'Querying commands for the Manifest billing module',
+    subcommands: [
+      { name: 'params', description: 'Query billing parameters' },
+      { name: 'lease', description: 'Query a lease by UUID' },
+      { name: 'leases', description: 'Query all leases' },
+      { name: 'leases-by-tenant', description: 'Query leases by tenant address' },
+      { name: 'leases-by-provider', description: 'Query leases by provider' },
+      { name: 'leases-by-sku', description: 'Query leases by SKU UUID' },
+      { name: 'credit-account', description: 'Query credit account for a tenant' },
+      { name: 'credit-accounts', description: 'Query all credit accounts' },
+      { name: 'credit-address', description: 'Query credit address for a tenant' },
+      { name: 'withdrawable-amount', description: 'Query withdrawable amount for a lease' },
+      { name: 'provider-withdrawable', description: 'Query withdrawable amount for a provider' },
+      { name: 'credit-estimate', description: 'Query credit estimate for a tenant' },
+    ],
+  },
+};
+
+/**
+ * Transaction modules registry
+ */
+const TX_MODULES: ModuleRegistry = {
+  bank: {
+    description: 'Bank transaction subcommands',
+    subcommands: [
+      { name: 'send', description: 'Send tokens to another account', args: '<to-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
+      { name: 'multi-send', description: 'Send tokens to multiple accounts', args: '<to-address:amount>... (e.g., manifest1a:1000umfx manifest1b:2000umfx)' },
+    ],
+  },
+  staking: {
+    description: 'Staking transaction subcommands',
+    subcommands: [
+      { name: 'delegate', description: 'Delegate tokens to a validator' },
+      { name: 'unbond', description: 'Unbond tokens from a validator' },
+      { name: 'undelegate', description: 'Unbond tokens from a validator (alias for unbond)' },
+      { name: 'redelegate', description: 'Redelegate tokens from one validator to another' },
+    ],
+  },
+  distribution: {
+    description: 'Distribution transaction subcommands',
+    subcommands: [
+      { name: 'withdraw-rewards', description: 'Withdraw rewards from a validator' },
+      { name: 'set-withdraw-addr', description: 'Set withdraw address' },
+      { name: 'fund-community-pool', description: 'Fund the community pool' },
+    ],
+  },
+  gov: {
+    description: 'Governance transaction subcommands',
+    subcommands: [
+      { name: 'vote', description: 'Vote on a proposal' },
+      { name: 'weighted-vote', description: 'Weighted vote on a proposal' },
+      { name: 'deposit', description: 'Deposit tokens for a proposal' },
+    ],
+  },
+  billing: {
+    description: 'Manifest billing transaction subcommands',
+    subcommands: [
+      { name: 'fund-credit', description: 'Fund credit for a tenant', args: '<tenant-address> <amount> (e.g., manifest1abc... 1000000umfx)' },
+      { name: 'create-lease', description: 'Create a new lease', args: '<sku-uuid:quantity>... (e.g., sku-123:1 sku-456:2)' },
+      { name: 'close-lease', description: 'Close one or more leases', args: '<lease-uuid>... (e.g., lease-123 lease-456)' },
+      { name: 'withdraw', description: 'Withdraw earnings from leases', args: '<lease-uuid>... OR --provider <provider-uuid>' },
+    ],
+  },
+  manifest: {
+    description: 'Manifest module transaction subcommands',
+    subcommands: [
+      { name: 'payout', description: 'Execute a payout to multiple addresses' },
+      { name: 'burn-held-balance', description: 'Burn held balance' },
+    ],
+  },
+};
+
+/**
+ * Get all available query and transaction modules
+ */
+export function getAvailableModules(): AvailableModules {
+  const queryModules: ModuleInfo[] = Object.entries(QUERY_MODULES).map(
+    ([name, info]) => ({
+      name,
+      description: info.description,
+    })
+  );
+
+  const txModules: ModuleInfo[] = Object.entries(TX_MODULES).map(
+    ([name, info]) => ({
+      name,
+      description: info.description,
+    })
+  );
+
+  return {
+    queryModules,
+    txModules,
+  };
+}
+
+/**
+ * Get available subcommands for a specific module
+ */
+export function getModuleSubcommands(
+  type: 'query' | 'tx',
+  module: string
+): ModuleInfo[] {
+  const registry = type === 'query' ? QUERY_MODULES : TX_MODULES;
+  const moduleInfo = registry[module];
+
+  if (!moduleInfo) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.UNKNOWN_MODULE,
+      `Unknown ${type} module: ${module}`,
+      { availableModules: Object.keys(registry) }
+    );
+  }
+
+  return moduleInfo.subcommands.map((sub) => ({
+    name: sub.name,
+    description: sub.description,
+    args: sub.args,
+  }));
+}
+
+/**
+ * Check if a module/subcommand combination is supported
+ */
+export function isSubcommandSupported(
+  type: 'query' | 'tx',
+  module: string,
+  subcommand: string
+): boolean {
+  const registry = type === 'query' ? QUERY_MODULES : TX_MODULES;
+  const moduleInfo = registry[module];
+
+  if (!moduleInfo) {
+    return false;
+  }
+
+  return moduleInfo.subcommands.some((s) => s.name === subcommand);
+}
+
+/**
+ * Get usage help for a specific subcommand
+ * Returns the args string if available, or undefined
+ */
+export function getSubcommandUsage(
+  type: 'query' | 'tx',
+  module: string,
+  subcommand: string
+): string | undefined {
+  const registry = type === 'query' ? QUERY_MODULES : TX_MODULES;
+  const moduleInfo = registry[module];
+
+  if (!moduleInfo) {
+    return undefined;
+  }
+
+  const sub = moduleInfo.subcommands.find((s) => s.name === subcommand);
+  return sub?.args;
+}
+
+/**
+ * Get supported modules list
+ */
+export function getSupportedModules(): {
+  query: { [module: string]: string[] };
+  tx: { [module: string]: string[] };
+} {
+  const result = {
+    query: {} as { [module: string]: string[] },
+    tx: {} as { [module: string]: string[] },
+  };
+
+  for (const [module, info] of Object.entries(QUERY_MODULES)) {
+    result.query[module] = info.subcommands.map((s) => s.name);
+  }
+
+  for (const [module, info] of Object.entries(TX_MODULES)) {
+    result.tx[module] = info.subcommands.map((s) => s.name);
+  }
+
+  return result;
+}

package/src/queries/auth.ts

@@ -0,0 +1,136 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { defaultPagination } from './utils.js';
+
+/**
+ * Route auth query to manifestjs query client
+ */
+export async function routeAuthQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const auth = queryClient.cosmos.auth.v1beta1;
+
+  switch (subcommand) {
+    case 'account': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'account requires address argument'
+        );
+      }
+      const [address] = args;
+      const result = await auth.account({ address });
+      return { account: result.account };
+    }
+
+    case 'accounts': {
+      const result = await auth.accounts({ pagination: defaultPagination });
+      return { accounts: result.accounts, pagination: result.pagination };
+    }
+
+    case 'params': {
+      const result = await auth.params({});
+      return { params: result.params };
+    }
+
+    case 'module-accounts': {
+      const result = await auth.moduleAccounts({});
+      return { accounts: result.accounts };
+    }
+
+    case 'module-account-by-name': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'module-account-by-name requires name argument'
+        );
+      }
+      const [name] = args;
+      const result = await auth.moduleAccountByName({ name });
+      return { account: result.account };
+    }
+
+    case 'address-bytes-to-string': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'address-bytes-to-string requires address-bytes argument'
+        );
+      }
+      const hexString = args[0];
+      // Validate hex format: must be valid hex characters with even length
+      if (!/^[0-9a-fA-F]*$/.test(hexString)) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          `Invalid hex string: "${hexString}". Must contain only hexadecimal characters (0-9, a-f, A-F)`
+        );
+      }
+      if (hexString.length % 2 !== 0) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          `Invalid hex string length: ${hexString.length}. Must have an even number of characters`
+        );
+      }
+      // Limit size to prevent DoS (256 bytes = 512 hex chars, more than enough for any address)
+      if (hexString.length > 512) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          `Hex string too long: ${hexString.length} characters. Maximum allowed: 512`
+        );
+      }
+      const addressBytes = new Uint8Array(Buffer.from(hexString, 'hex'));
+      const result = await auth.addressBytesToString({ addressBytes });
+      return { addressString: result.addressString };
+    }
+
+    case 'address-string-to-bytes': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'address-string-to-bytes requires address-string argument'
+        );
+      }
+      const [addressString] = args;
+      const result = await auth.addressStringToBytes({ addressString });
+      return { addressBytes: Buffer.from(result.addressBytes).toString('hex') };
+    }
+
+    case 'bech32-prefix': {
+      const result = await auth.bech32Prefix({});
+      return { bech32Prefix: result.bech32Prefix };
+    }
+
+    case 'account-info': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'account-info requires address argument'
+        );
+      }
+      const [address] = args;
+      const result = await auth.accountInfo({ address });
+      return { info: result.info };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported auth query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'account',
+            'accounts',
+            'params',
+            'module-accounts',
+            'module-account-by-name',
+            'address-bytes-to-string',
+            'address-string-to-bytes',
+            'bech32-prefix',
+            'account-info',
+          ],
+        }
+      );
+  }
+}

package/src/queries/bank.ts

@@ -0,0 +1,117 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { defaultPagination } from './utils.js';
+
+/**
+ * Route bank query to manifestjs query client
+ */
+export async function routeBankQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const bank = queryClient.cosmos.bank.v1beta1;
+
+  switch (subcommand) {
+    case 'balance': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'balance requires address and denom arguments'
+        );
+      }
+      const [address, denom] = args;
+      const result = await bank.balance({ address, denom });
+      return { balance: result.balance };
+    }
+
+    case 'balances': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'balances requires address argument'
+        );
+      }
+      const [address] = args;
+      const result = await bank.allBalances({ address, resolveDenom: false, pagination: defaultPagination });
+      return { balances: result.balances, pagination: result.pagination };
+    }
+
+    case 'spendable-balances': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'spendable-balances requires address argument'
+        );
+      }
+      const [address] = args;
+      const result = await bank.spendableBalances({ address, pagination: defaultPagination });
+      return { balances: result.balances, pagination: result.pagination };
+    }
+
+    case 'total-supply':
+    case 'total': {
+      const result = await bank.totalSupply({ pagination: defaultPagination });
+      return { supply: result.supply, pagination: result.pagination };
+    }
+
+    case 'supply-of': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'supply-of requires denom argument'
+        );
+      }
+      const [denom] = args;
+      const result = await bank.supplyOf({ denom });
+      return { amount: result.amount };
+    }
+
+    case 'params': {
+      const result = await bank.params({});
+      return { params: result.params };
+    }
+
+    case 'denom-metadata': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'denom-metadata requires denom argument'
+        );
+      }
+      const [denom] = args;
+      const result = await bank.denomMetadata({ denom });
+      return { metadata: result.metadata };
+    }
+
+    case 'denoms-metadata': {
+      const result = await bank.denomsMetadata({ pagination: defaultPagination });
+      return { metadatas: result.metadatas, pagination: result.pagination };
+    }
+
+    case 'send-enabled': {
+      const denoms = args.length > 0 ? args : [];
+      const result = await bank.sendEnabled({ denoms, pagination: defaultPagination });
+      return { sendEnabled: result.sendEnabled, pagination: result.pagination };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported bank query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'balance',
+            'balances',
+            'spendable-balances',
+            'total-supply',
+            'supply-of',
+            'params',
+            'denom-metadata',
+            'denoms-metadata',
+            'send-enabled',
+          ],
+        }
+      );
+  }
+}

package/src/queries/billing.ts

@@ -0,0 +1,164 @@
+import { ManifestQueryClient } from '../client.js';
+import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseBigInt, defaultPagination } from './utils.js';
+
+/**
+ * Route billing module query to manifestjs query client
+ */
+export async function routeBillingQuery(
+  queryClient: ManifestQueryClient,
+  subcommand: string,
+  args: string[]
+): Promise<Record<string, unknown>> {
+  const billing = queryClient.liftedinit.billing.v1;
+
+  switch (subcommand) {
+    case 'params': {
+      const result = await billing.params({});
+      return { params: result.params };
+    }
+
+    case 'lease': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'lease requires lease-uuid argument'
+        );
+      }
+      const [leaseUuid] = args;
+      const result = await billing.lease({ leaseUuid });
+      return { lease: result.lease };
+    }
+
+    case 'leases': {
+      // stateFilter: 0 = LEASE_STATE_UNSPECIFIED (returns all)
+      const result = await billing.leases({ stateFilter: 0, pagination: defaultPagination });
+      return { leases: result.leases, pagination: result.pagination };
+    }
+
+    case 'leases-by-tenant': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'leases-by-tenant requires tenant-address argument'
+        );
+      }
+      const [tenant] = args;
+      const result = await billing.leasesByTenant({ tenant, stateFilter: 0, pagination: defaultPagination });
+      return { leases: result.leases, pagination: result.pagination };
+    }
+
+    case 'leases-by-provider': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'leases-by-provider requires provider-uuid argument'
+        );
+      }
+      const [providerUuid] = args;
+      const result = await billing.leasesByProvider({ providerUuid, stateFilter: 0, pagination: defaultPagination });
+      return { leases: result.leases, pagination: result.pagination };
+    }
+
+    case 'leases-by-sku': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'leases-by-sku requires sku-uuid argument'
+        );
+      }
+      const [skuUuid] = args;
+      const result = await billing.leasesBySKU({ skuUuid, stateFilter: 0, pagination: defaultPagination });
+      return { leases: result.leases, pagination: result.pagination };
+    }
+
+    case 'credit-account': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'credit-account requires tenant-address argument'
+        );
+      }
+      const [tenant] = args;
+      const result = await billing.creditAccount({ tenant });
+      return { creditAccount: result.creditAccount };
+    }
+
+    case 'credit-accounts': {
+      const result = await billing.creditAccounts({ pagination: defaultPagination });
+      return { creditAccounts: result.creditAccounts, pagination: result.pagination };
+    }
+
+    case 'credit-address': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'credit-address requires tenant-address argument'
+        );
+      }
+      const [tenant] = args;
+      const result = await billing.creditAddress({ tenant });
+      return { creditAddress: result.creditAddress };
+    }
+
+    case 'withdrawable-amount': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'withdrawable-amount requires lease-uuid argument'
+        );
+      }
+      const [leaseUuid] = args;
+      const result = await billing.withdrawableAmount({ leaseUuid });
+      return { amounts: result.amounts };
+    }
+
+    case 'provider-withdrawable': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'provider-withdrawable requires provider-uuid argument'
+        );
+      }
+      const [providerUuid] = args;
+      // limit: max leases to process (default 100, max 1000)
+      const limit = args[1] ? parseBigInt(args[1], 'limit') : BigInt(100);
+      const result = await billing.providerWithdrawable({ providerUuid, limit });
+      return { amounts: result.amounts };
+    }
+
+    case 'credit-estimate': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.QUERY_FAILED,
+          'credit-estimate requires tenant-address argument'
+        );
+      }
+      const [tenant] = args;
+      const result = await billing.creditEstimate({ tenant });
+      return { estimate: result };
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_QUERY,
+        `Unsupported billing query subcommand: ${subcommand}`,
+        {
+          availableSubcommands: [
+            'params',
+            'lease',
+            'leases',
+            'leases-by-tenant',
+            'leases-by-provider',
+            'leases-by-sku',
+            'credit-account',
+            'credit-accounts',
+            'credit-address',
+            'withdrawable-amount',
+            'provider-withdrawable',
+            'credit-estimate',
+          ],
+        }
+      );
+  }
+}