@manifest-network/manifest-mcp-browser 0.1.0

package/src/transactions/billing.ts

@@ -0,0 +1,160 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+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';
+
+const { MsgFundCredit, MsgCreateLease, MsgCloseLease, MsgWithdraw } = liftedinit.billing.v1;
+
+/**
+ * Route billing transaction to appropriate handler
+ */
+export async function routeBillingTransaction(
+  client: SigningStargateClient,
+  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 }
+        );
+      }
+
+      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': {
+      if (args.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 || '<sku-uuid:quantity>...'}`,
+          { usage }
+        );
+      }
+
+      // Parse items (format: sku-uuid:quantity ...)
+      const items = args.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`
+          );
+        }
+        return { skuUuid, quantity: parseBigInt(quantityStr, 'quantity') };
+      });
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgCreateLease',
+        value: MsgCreateLease.fromPartial({
+          tenant: senderAddress,
+          items,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'create-lease', result, waitForConfirmation);
+    }
+
+    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 }
+        );
+      }
+
+      // MsgCloseLease can close multiple leases at once
+      const leaseUuids = args;
+      const reason = ''; // Optional reason, could be added as a flag later
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgCloseLease',
+        value: MsgCloseLease.fromPartial({
+          sender: senderAddress,
+          leaseUuids,
+          reason,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'close-lease', result, waitForConfirmation);
+    }
+
+    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 || '<lease-uuid>... OR --provider <provider-uuid>'}`,
+          { usage }
+        );
+      }
+
+      // Check if using provider-wide withdrawal
+      const providerFlagIndex = args.indexOf('--provider');
+      let leaseUuids: string[] = [];
+      let providerUuid = '';
+
+      if (providerFlagIndex !== -1) {
+        // Provider-wide withdrawal mode
+        providerUuid = args[providerFlagIndex + 1] || '';
+        if (!providerUuid) {
+          throw new ManifestMCPError(
+            ManifestMCPErrorCode.TX_FAILED,
+            'withdraw with --provider flag requires provider-uuid argument'
+          );
+        }
+      } else {
+        // Lease-specific withdrawal mode
+        leaseUuids = args;
+      }
+
+      const msg = {
+        typeUrl: '/liftedinit.billing.v1.MsgWithdraw',
+        value: MsgWithdraw.fromPartial({
+          sender: senderAddress,
+          leaseUuids,
+          providerUuid,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('billing', 'withdraw', result, waitForConfirmation);
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported billing transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['fund-credit', 'create-lease', 'close-lease', 'withdraw'] }
+      );
+  }
+}

package/src/transactions/distribution.ts

@@ -0,0 +1,98 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { cosmos } from '@manifest-network/manifestjs';
+import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+
+const { MsgWithdrawDelegatorReward, MsgSetWithdrawAddress, MsgFundCommunityPool } = cosmos.distribution.v1beta1;
+
+/**
+ * Route distribution transaction to appropriate handler
+ */
+export async function routeDistributionTransaction(
+  client: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  _config: ManifestMCPConfig,
+  waitForConfirmation: boolean
+): Promise<CosmosTxResult> {
+  validateArgsLength(args, 'distribution transaction');
+
+  switch (subcommand) {
+    case 'withdraw-rewards': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'withdraw-rewards requires validator-address argument'
+        );
+      }
+
+      const [validatorAddress] = args;
+      validateAddress(validatorAddress, 'validator address');
+
+      const msg = {
+        typeUrl: '/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward',
+        value: MsgWithdrawDelegatorReward.fromPartial({
+          delegatorAddress: senderAddress,
+          validatorAddress,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('distribution', 'withdraw-rewards', result, waitForConfirmation);
+    }
+
+    case 'set-withdraw-addr': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'set-withdraw-addr requires withdraw-address argument'
+        );
+      }
+
+      const [withdrawAddress] = args;
+      validateAddress(withdrawAddress, 'withdraw address');
+
+      const msg = {
+        typeUrl: '/cosmos.distribution.v1beta1.MsgSetWithdrawAddress',
+        value: MsgSetWithdrawAddress.fromPartial({
+          delegatorAddress: senderAddress,
+          withdrawAddress,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('distribution', 'set-withdraw-addr', result, waitForConfirmation);
+    }
+
+    case 'fund-community-pool': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'fund-community-pool requires amount argument'
+        );
+      }
+
+      const [amountStr] = args;
+      const { amount, denom } = parseAmount(amountStr);
+
+      const msg = {
+        typeUrl: '/cosmos.distribution.v1beta1.MsgFundCommunityPool',
+        value: MsgFundCommunityPool.fromPartial({
+          depositor: senderAddress,
+          amount: [{ denom, amount }],
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('distribution', 'fund-community-pool', result, waitForConfirmation);
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported distribution transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['withdraw-rewards', 'set-withdraw-addr', 'fund-community-pool'] }
+      );
+  }
+}

package/src/transactions/gov.ts

@@ -0,0 +1,185 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { cosmos } from '@manifest-network/manifestjs';
+import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
+import { parseAmount, buildTxResult, parseBigInt, validateArgsLength } from './utils.js';
+
+const { MsgVote, MsgDeposit, MsgVoteWeighted, VoteOption } = cosmos.gov.v1;
+
+/**
+ * Parse a decimal weight string to an 18-decimal fixed-point string.
+ * Uses string manipulation to avoid floating-point precision loss.
+ *
+ * @param weightStr - Decimal string like "0.5", "0.333333333333333333", "1"
+ * @returns String representation of weight * 10^18
+ */
+function parseWeightToFixed18(weightStr: string): string {
+  // Validate format: must be a valid decimal number
+  if (!/^\d+(\.\d+)?$/.test(weightStr)) {
+    throw new ManifestMCPError(
+      ManifestMCPErrorCode.TX_FAILED,
+      `Invalid weight format: "${weightStr}". Expected decimal like "0.5" or "0.333333333333333333"`
+    );
+  }
+
+  const [intPart, decPart = ''] = weightStr.split('.');
+
+  // Pad or truncate decimal part to exactly 18 digits
+  const paddedDecimal = decPart.padEnd(18, '0').slice(0, 18);
+
+  // Combine integer and decimal parts
+  const combined = intPart + paddedDecimal;
+
+  // Remove leading zeros but keep at least one digit
+  const result = combined.replace(/^0+/, '') || '0';
+
+  return result;
+}
+
+/**
+ * Parse vote option string to VoteOption enum value from manifestjs
+ */
+function parseVoteOption(optionStr: string): number {
+  const option = optionStr.toLowerCase();
+  switch (option) {
+    case 'yes':
+    case '1':
+      return VoteOption.VOTE_OPTION_YES;
+    case 'abstain':
+    case '2':
+      return VoteOption.VOTE_OPTION_ABSTAIN;
+    case 'no':
+    case '3':
+      return VoteOption.VOTE_OPTION_NO;
+    case 'no_with_veto':
+    case 'nowithveto':
+    case '4':
+      return VoteOption.VOTE_OPTION_NO_WITH_VETO;
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.TX_FAILED,
+        `Invalid vote option: ${optionStr}. Expected: yes, no, abstain, or no_with_veto`
+      );
+  }
+}
+
+/**
+ * Route gov transaction to appropriate handler
+ */
+export async function routeGovTransaction(
+  client: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  _config: ManifestMCPConfig,
+  waitForConfirmation: boolean
+): Promise<CosmosTxResult> {
+  validateArgsLength(args, 'gov transaction');
+
+  switch (subcommand) {
+    case 'vote': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'vote requires proposal-id and option arguments'
+        );
+      }
+
+      const [proposalIdStr, optionStr] = args;
+      const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
+      const option = parseVoteOption(optionStr);
+
+      // Extract optional metadata from args
+      let metadata = '';
+      const metadataIndex = args.indexOf('--metadata');
+      if (metadataIndex !== -1 && args[metadataIndex + 1]) {
+        metadata = args[metadataIndex + 1];
+      }
+
+      const msg = {
+        typeUrl: '/cosmos.gov.v1.MsgVote',
+        value: MsgVote.fromPartial({
+          proposalId,
+          voter: senderAddress,
+          option,
+          metadata,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('gov', 'vote', result, waitForConfirmation);
+    }
+
+    case 'weighted-vote': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'weighted-vote requires proposal-id and options arguments (format: yes=0.5,no=0.5)'
+        );
+      }
+
+      const [proposalIdStr, optionsStr] = args;
+      const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
+
+      // Parse weighted options (format: yes=0.5,no=0.3,abstain=0.2)
+      const options = optionsStr.split(',').map((opt) => {
+        const [optName, weightStr] = opt.split('=');
+        if (!optName || !weightStr) {
+          throw new ManifestMCPError(
+            ManifestMCPErrorCode.TX_FAILED,
+            `Invalid weighted vote format: ${opt}. Expected format: option=weight`
+          );
+        }
+        const option = parseVoteOption(optName);
+        // Weight is a decimal string (e.g., "0.5" -> "500000000000000000" for 18 decimals)
+        // Use string-based conversion to avoid floating-point precision loss
+        const weight = parseWeightToFixed18(weightStr);
+        return { option, weight };
+      });
+
+      const msg = {
+        typeUrl: '/cosmos.gov.v1.MsgVoteWeighted',
+        value: MsgVoteWeighted.fromPartial({
+          proposalId,
+          voter: senderAddress,
+          options,
+          metadata: '',
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('gov', 'weighted-vote', result, waitForConfirmation);
+    }
+
+    case 'deposit': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'deposit requires proposal-id and amount arguments'
+        );
+      }
+
+      const [proposalIdStr, amountStr] = args;
+      const proposalId = parseBigInt(proposalIdStr, 'proposal-id');
+      const { amount, denom } = parseAmount(amountStr);
+
+      const msg = {
+        typeUrl: '/cosmos.gov.v1.MsgDeposit',
+        value: MsgDeposit.fromPartial({
+          proposalId,
+          depositor: senderAddress,
+          amount: [{ denom, amount }],
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('gov', 'deposit', result, waitForConfirmation);
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported gov transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['vote', 'weighted-vote', 'deposit'] }
+      );
+  }
+}

package/src/transactions/index.ts

@@ -0,0 +1,7 @@
+export { parseAmount, buildTxResult, parseBigInt } from './utils.js';
+export { routeBankTransaction } from './bank.js';
+export { routeStakingTransaction } from './staking.js';
+export { routeDistributionTransaction } from './distribution.js';
+export { routeGovTransaction } from './gov.js';
+export { routeBillingTransaction } from './billing.js';
+export { routeManifestTransaction } from './manifest.js';

package/src/transactions/manifest.ts

@@ -0,0 +1,89 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { liftedinit } from '@manifest-network/manifestjs';
+import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+
+const { MsgPayout, MsgBurnHeldBalance } = liftedinit.manifest.v1;
+
+/**
+ * Route manifest transaction to appropriate handler
+ */
+export async function routeManifestTransaction(
+  client: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  _config: ManifestMCPConfig,
+  waitForConfirmation: boolean
+): Promise<CosmosTxResult> {
+  validateArgsLength(args, 'manifest transaction');
+
+  switch (subcommand) {
+    case 'payout': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'payout requires at least one address:amount pair'
+        );
+      }
+
+      // Parse payout pairs (format: address:amount ...)
+      const payoutPairs = args.map((arg) => {
+        const [address, amountStr] = arg.split(':');
+        if (!address || !amountStr) {
+          throw new ManifestMCPError(
+            ManifestMCPErrorCode.TX_FAILED,
+            `Invalid payout pair format: ${arg}. Expected format: address:amount`
+          );
+        }
+        validateAddress(address, 'payout recipient address');
+        const { amount, denom } = parseAmount(amountStr);
+        return { address, coin: { denom, amount } };
+      });
+
+      const msg = {
+        typeUrl: '/liftedinit.manifest.v1.MsgPayout',
+        value: MsgPayout.fromPartial({
+          authority: senderAddress,
+          payoutPairs,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('manifest', 'payout', result, waitForConfirmation);
+    }
+
+    case 'burn-held-balance': {
+      if (args.length < 1) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'burn-held-balance requires at least one amount argument'
+        );
+      }
+
+      // Parse coins to burn
+      const burnCoins = args.map((amountStr) => {
+        const { amount, denom } = parseAmount(amountStr);
+        return { denom, amount };
+      });
+
+      const msg = {
+        typeUrl: '/liftedinit.manifest.v1.MsgBurnHeldBalance',
+        value: MsgBurnHeldBalance.fromPartial({
+          authority: senderAddress,
+          burnCoins,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('manifest', 'burn-held-balance', result, waitForConfirmation);
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported manifest transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['payout', 'burn-held-balance'] }
+      );
+  }
+}

package/src/transactions/staking.ts

@@ -0,0 +1,107 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { cosmos } from '@manifest-network/manifestjs';
+import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult, ManifestMCPConfig } from '../types.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength } from './utils.js';
+
+const { MsgDelegate, MsgUndelegate, MsgBeginRedelegate } = cosmos.staking.v1beta1;
+
+/**
+ * Route staking transaction to appropriate handler
+ */
+export async function routeStakingTransaction(
+  client: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  _config: ManifestMCPConfig,
+  waitForConfirmation: boolean
+): Promise<CosmosTxResult> {
+  validateArgsLength(args, 'staking transaction');
+
+  switch (subcommand) {
+    case 'delegate': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'delegate requires validator-address and amount arguments'
+        );
+      }
+
+      const [validatorAddress, amountStr] = args;
+      validateAddress(validatorAddress, 'validator address');
+      const { amount, denom } = parseAmount(amountStr);
+
+      const msg = {
+        typeUrl: '/cosmos.staking.v1beta1.MsgDelegate',
+        value: MsgDelegate.fromPartial({
+          delegatorAddress: senderAddress,
+          validatorAddress,
+          amount: { denom, amount },
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('staking', 'delegate', result, waitForConfirmation);
+    }
+
+    case 'unbond':
+    case 'undelegate': {
+      if (args.length < 2) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'unbond requires validator-address and amount arguments'
+        );
+      }
+
+      const [validatorAddress, amountStr] = args;
+      validateAddress(validatorAddress, 'validator address');
+      const { amount, denom } = parseAmount(amountStr);
+
+      const msg = {
+        typeUrl: '/cosmos.staking.v1beta1.MsgUndelegate',
+        value: MsgUndelegate.fromPartial({
+          delegatorAddress: senderAddress,
+          validatorAddress,
+          amount: { denom, amount },
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('staking', 'unbond', result, waitForConfirmation);
+    }
+
+    case 'redelegate': {
+      if (args.length < 3) {
+        throw new ManifestMCPError(
+          ManifestMCPErrorCode.TX_FAILED,
+          'redelegate requires src-validator, dst-validator, and amount arguments'
+        );
+      }
+
+      const [srcValidatorAddress, dstValidatorAddress, amountStr] = args;
+      validateAddress(srcValidatorAddress, 'source validator address');
+      validateAddress(dstValidatorAddress, 'destination validator address');
+      const { amount, denom } = parseAmount(amountStr);
+
+      const msg = {
+        typeUrl: '/cosmos.staking.v1beta1.MsgBeginRedelegate',
+        value: MsgBeginRedelegate.fromPartial({
+          delegatorAddress: senderAddress,
+          validatorSrcAddress: srcValidatorAddress,
+          validatorDstAddress: dstValidatorAddress,
+          amount: { denom, amount },
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('staking', 'redelegate', result, waitForConfirmation);
+    }
+
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.UNSUPPORTED_TX,
+        `Unsupported staking transaction subcommand: ${subcommand}`,
+        { availableSubcommands: ['delegate', 'unbond', 'redelegate'] }
+      );
+  }
+}