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

package/src/transactions/sku.ts

@@ -0,0 +1,232 @@
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { liftedinit } from '@manifest-network/manifestjs';
+import { CosmosTxResult, ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
+import { parseAmount, buildTxResult, validateAddress, validateArgsLength, extractFlag, filterConsumedArgs, requireArgs, parseHexBytes, MAX_META_HASH_BYTES } from './utils.js';
+import { throwUnsupportedSubcommand } from '../modules.js';
+
+const {
+  MsgCreateProvider, MsgUpdateProvider, MsgDeactivateProvider,
+  MsgCreateSKU, MsgUpdateSKU, MsgDeactivateSKU,
+  MsgUpdateParams,
+  Unit,
+} = liftedinit.sku.v1;
+
+/**
+ * Parse a unit string to the Unit enum value.
+ * Accepts 'per-hour' or 'per-day'.
+ */
+function parseUnit(value: string): number {
+  switch (value.toLowerCase()) {
+    case 'per-hour':
+      return Unit.UNIT_PER_HOUR;
+    case 'per-day':
+      return Unit.UNIT_PER_DAY;
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.TX_FAILED,
+        `Invalid unit: "${value}". Expected "per-hour" or "per-day".`
+      );
+  }
+}
+
+/**
+ * Parse a boolean string ('true' or 'false').
+ */
+function parseBooleanString(value: string, fieldName: string): boolean {
+  const lower = value.toLowerCase();
+  if (lower === 'true') return true;
+  if (lower === 'false') return false;
+  throw new ManifestMCPError(
+    ManifestMCPErrorCode.TX_FAILED,
+    `Invalid ${fieldName}: "${value}". Expected "true" or "false".`
+  );
+}
+
+/**
+ * Route SKU transaction to appropriate handler
+ */
+export async function routeSkuTransaction(
+  client: SigningStargateClient,
+  senderAddress: string,
+  subcommand: string,
+  args: string[],
+  waitForConfirmation: boolean
+): Promise<CosmosTxResult> {
+  validateArgsLength(args, 'sku transaction');
+
+  switch (subcommand) {
+    case 'create-provider': {
+      // Parse optional --meta-hash flag
+      const { value: metaHashHex, consumedIndices } = extractFlag(args, '--meta-hash', 'sku create-provider');
+      const metaHash = metaHashHex ? parseHexBytes(metaHashHex, 'meta-hash', MAX_META_HASH_BYTES) : new Uint8Array();
+      const positionalArgs = filterConsumedArgs(args, consumedIndices);
+
+      requireArgs(positionalArgs, 3, ['address', 'payout-address', 'api-url'], 'sku create-provider');
+      const [address, payoutAddress, apiUrl] = positionalArgs;
+      validateAddress(address, 'address');
+      validateAddress(payoutAddress, 'payout address');
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgCreateProvider',
+        value: MsgCreateProvider.fromPartial({
+          authority: senderAddress,
+          address,
+          payoutAddress,
+          metaHash,
+          apiUrl,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'create-provider', result, waitForConfirmation);
+    }
+
+    case 'update-provider': {
+      // Parse optional flags
+      const metaHashFlag = extractFlag(args, '--meta-hash', 'sku update-provider');
+      const activeFlag = extractFlag(args, '--active', 'sku update-provider');
+      const allConsumed = [...metaHashFlag.consumedIndices, ...activeFlag.consumedIndices];
+      const positionalArgs = filterConsumedArgs(args, allConsumed);
+
+      requireArgs(positionalArgs, 4, ['provider-uuid', 'address', 'payout-address', 'api-url'], 'sku update-provider');
+      const [uuid, address, payoutAddress, apiUrl] = positionalArgs;
+      validateAddress(address, 'address');
+      validateAddress(payoutAddress, 'payout address');
+
+      const metaHash = metaHashFlag.value ? parseHexBytes(metaHashFlag.value, 'meta-hash', MAX_META_HASH_BYTES) : new Uint8Array();
+      const active = activeFlag.value ? parseBooleanString(activeFlag.value, 'active') : true;
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgUpdateProvider',
+        value: MsgUpdateProvider.fromPartial({
+          authority: senderAddress,
+          uuid,
+          address,
+          payoutAddress,
+          metaHash,
+          active,
+          apiUrl,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'update-provider', result, waitForConfirmation);
+    }
+
+    case 'deactivate-provider': {
+      requireArgs(args, 1, ['provider-uuid'], 'sku deactivate-provider');
+      const [uuid] = args;
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgDeactivateProvider',
+        value: MsgDeactivateProvider.fromPartial({
+          authority: senderAddress,
+          uuid,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'deactivate-provider', result, waitForConfirmation);
+    }
+
+    case 'create-sku': {
+      // Parse optional --meta-hash flag
+      const { value: metaHashHex, consumedIndices } = extractFlag(args, '--meta-hash', 'sku create-sku');
+      const metaHash = metaHashHex ? parseHexBytes(metaHashHex, 'meta-hash', MAX_META_HASH_BYTES) : new Uint8Array();
+      const positionalArgs = filterConsumedArgs(args, consumedIndices);
+
+      requireArgs(positionalArgs, 4, ['provider-uuid', 'name', 'unit', 'base-price'], 'sku create-sku');
+      const [providerUuid, name, unitStr, basePriceStr] = positionalArgs;
+
+      const unit = parseUnit(unitStr);
+      const { amount, denom } = parseAmount(basePriceStr);
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgCreateSKU',
+        value: MsgCreateSKU.fromPartial({
+          authority: senderAddress,
+          providerUuid,
+          name,
+          unit,
+          basePrice: { denom, amount },
+          metaHash,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'create-sku', result, waitForConfirmation);
+    }
+
+    case 'update-sku': {
+      // Parse optional flags
+      const metaHashFlag = extractFlag(args, '--meta-hash', 'sku update-sku');
+      const activeFlag = extractFlag(args, '--active', 'sku update-sku');
+      const allConsumed = [...metaHashFlag.consumedIndices, ...activeFlag.consumedIndices];
+      const positionalArgs = filterConsumedArgs(args, allConsumed);
+
+      requireArgs(positionalArgs, 5, ['sku-uuid', 'provider-uuid', 'name', 'unit', 'base-price'], 'sku update-sku');
+      const [uuid, providerUuid, name, unitStr, basePriceStr] = positionalArgs;
+
+      const unit = parseUnit(unitStr);
+      const { amount, denom } = parseAmount(basePriceStr);
+      const metaHash = metaHashFlag.value ? parseHexBytes(metaHashFlag.value, 'meta-hash', MAX_META_HASH_BYTES) : new Uint8Array();
+      const active = activeFlag.value ? parseBooleanString(activeFlag.value, 'active') : true;
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgUpdateSKU',
+        value: MsgUpdateSKU.fromPartial({
+          authority: senderAddress,
+          uuid,
+          providerUuid,
+          name,
+          unit,
+          basePrice: { denom, amount },
+          metaHash,
+          active,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'update-sku', result, waitForConfirmation);
+    }
+
+    case 'deactivate-sku': {
+      requireArgs(args, 1, ['sku-uuid'], 'sku deactivate-sku');
+      const [uuid] = args;
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgDeactivateSKU',
+        value: MsgDeactivateSKU.fromPartial({
+          authority: senderAddress,
+          uuid,
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'deactivate-sku', result, waitForConfirmation);
+    }
+
+    case 'update-params': {
+      requireArgs(args, 1, ['allowed-address'], 'sku update-params');
+      for (const addr of args) {
+        validateAddress(addr, 'allowed address');
+      }
+
+      const msg = {
+        typeUrl: '/liftedinit.sku.v1.MsgUpdateParams',
+        value: MsgUpdateParams.fromPartial({
+          authority: senderAddress,
+          params: {
+            allowedList: args,
+          },
+        }),
+      };
+
+      const result = await client.signAndBroadcast(senderAddress, [msg], 'auto');
+      return buildTxResult('sku', 'update-params', result, waitForConfirmation);
+    }
+
+    default:
+      throwUnsupportedSubcommand('tx', 'sku', subcommand);
+  }
+}

package/src/transactions/utils.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { toBech32 } from '@cosmjs/encoding';
-import { parseAmount, parseBigInt, extractFlag, filterConsumedArgs, parseColonPair, validateAddress, validateMemo, validateArgsLength, requireArgs, parseHexBytes, bytesToHex } from './utils.js';
+import { parseAmount, parseBigInt, extractFlag, extractBooleanFlag, filterConsumedArgs, parseColonPair, validateAddress, validateMemo, validateArgsLength, requireArgs, parseHexBytes, bytesToHex, parseVoteOption } from './utils.js';
 import { ManifestMCPError, ManifestMCPErrorCode } from '../types.js';
 
 describe('parseAmount', () => {
@@ -516,3 +516,111 @@ describe('bytesToHex', () => {
     expect(bytesToHex(bytes)).toBe(original);
   });
 });
+
+describe('extractBooleanFlag', () => {
+  it('should return true and filtered args when flag is present', () => {
+    const result = extractBooleanFlag(['arg1', '--active-only', 'arg2'], '--active-only');
+    expect(result.value).toBe(true);
+    expect(result.remainingArgs).toEqual(['arg1', 'arg2']);
+  });
+
+  it('should return false and original args when flag is absent', () => {
+    const args = ['arg1', 'arg2'];
+    const result = extractBooleanFlag(args, '--active-only');
+    expect(result.value).toBe(false);
+    expect(result.remainingArgs).toEqual(['arg1', 'arg2']);
+  });
+
+  it('should handle flag at the beginning', () => {
+    const result = extractBooleanFlag(['--flag', 'a', 'b'], '--flag');
+    expect(result.value).toBe(true);
+    expect(result.remainingArgs).toEqual(['a', 'b']);
+  });
+
+  it('should handle flag at the end', () => {
+    const result = extractBooleanFlag(['a', 'b', '--flag'], '--flag');
+    expect(result.value).toBe(true);
+    expect(result.remainingArgs).toEqual(['a', 'b']);
+  });
+
+  it('should handle flag as only argument', () => {
+    const result = extractBooleanFlag(['--flag'], '--flag');
+    expect(result.value).toBe(true);
+    expect(result.remainingArgs).toEqual([]);
+  });
+
+  it('should handle empty args', () => {
+    const result = extractBooleanFlag([], '--flag');
+    expect(result.value).toBe(false);
+    expect(result.remainingArgs).toEqual([]);
+  });
+
+  it('should only remove the first occurrence', () => {
+    const result = extractBooleanFlag(['--flag', 'a', '--flag'], '--flag');
+    expect(result.value).toBe(true);
+    // indexOf finds the first occurrence at index 0, only that is removed
+    expect(result.remainingArgs).toEqual(['a', '--flag']);
+  });
+});
+
+describe('parseVoteOption', () => {
+  // Mock VoteOption enum matching the cosmos.gov.v1 / cosmos.group.v1 shape
+  const mockVoteOption = {
+    VOTE_OPTION_YES: 1,
+    VOTE_OPTION_ABSTAIN: 2,
+    VOTE_OPTION_NO: 3,
+    VOTE_OPTION_NO_WITH_VETO: 4,
+  };
+
+  it('should parse string vote options (case-insensitive)', () => {
+    expect(parseVoteOption('yes', mockVoteOption)).toBe(1);
+    expect(parseVoteOption('YES', mockVoteOption)).toBe(1);
+    expect(parseVoteOption('Yes', mockVoteOption)).toBe(1);
+    expect(parseVoteOption('no', mockVoteOption)).toBe(3);
+    expect(parseVoteOption('abstain', mockVoteOption)).toBe(2);
+    expect(parseVoteOption('no_with_veto', mockVoteOption)).toBe(4);
+    expect(parseVoteOption('nowithveto', mockVoteOption)).toBe(4);
+  });
+
+  it('should parse numeric vote options', () => {
+    expect(parseVoteOption('1', mockVoteOption)).toBe(1);
+    expect(parseVoteOption('2', mockVoteOption)).toBe(2);
+    expect(parseVoteOption('3', mockVoteOption)).toBe(3);
+    expect(parseVoteOption('4', mockVoteOption)).toBe(4);
+  });
+
+  it('should use enum values from the provided object', () => {
+    // Verify it actually uses the enum values, not hardcoded numbers
+    const customEnum = {
+      VOTE_OPTION_YES: 10,
+      VOTE_OPTION_ABSTAIN: 20,
+      VOTE_OPTION_NO: 30,
+      VOTE_OPTION_NO_WITH_VETO: 40,
+    };
+    expect(parseVoteOption('yes', customEnum)).toBe(10);
+    expect(parseVoteOption('no', customEnum)).toBe(30);
+  });
+
+  it('should throw ManifestMCPError for invalid option', () => {
+    expect(() => parseVoteOption('invalid', mockVoteOption)).toThrow(ManifestMCPError);
+    expect(() => parseVoteOption('maybe', mockVoteOption)).toThrow(ManifestMCPError);
+    expect(() => parseVoteOption('0', mockVoteOption)).toThrow(ManifestMCPError);
+    expect(() => parseVoteOption('5', mockVoteOption)).toThrow(ManifestMCPError);
+  });
+
+  it('should use TX_FAILED error code', () => {
+    try {
+      parseVoteOption('invalid', mockVoteOption);
+    } catch (error) {
+      expect((error as ManifestMCPError).code).toBe(ManifestMCPErrorCode.TX_FAILED);
+    }
+  });
+
+  it('should include the invalid option in error message', () => {
+    try {
+      parseVoteOption('badvalue', mockVoteOption);
+    } catch (error) {
+      expect((error as ManifestMCPError).message).toContain('badvalue');
+    }
+  });
+});

package/src/transactions/utils.ts

@@ -5,6 +5,9 @@ import { ManifestMCPError, ManifestMCPErrorCode, CosmosTxResult } from '../types
 /** Maximum number of arguments allowed */
 export const MAX_ARGS = 100;
 
+/** Maximum meta hash length in bytes (64 bytes for SHA-512) */
+export const MAX_META_HASH_BYTES = 64;
+
 /**
  * Result from extracting a flag from args
  */
@@ -45,6 +48,33 @@ export function extractFlag(
   return { value, consumedIndices: [flagIndex, flagIndex + 1] };
 }
 
+/**
+ * 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 };
+}
+
 /**
  * Filter args to remove consumed flag indices
  */
@@ -284,6 +314,48 @@ export function parseBigInt(value: string, fieldName: string): bigint {
   return parseBigIntWithCode(value, fieldName, ManifestMCPErrorCode.TX_FAILED);
 }
 
+/**
+ * Interface for VoteOption-like enums from cosmos protobuf modules.
+ * Both cosmos.gov.v1.VoteOption and cosmos.group.v1.VoteOption share this shape.
+ */
+interface VoteOptionEnum {
+  VOTE_OPTION_YES: number;
+  VOTE_OPTION_ABSTAIN: number;
+  VOTE_OPTION_NO: number;
+  VOTE_OPTION_NO_WITH_VETO: number;
+}
+
+/**
+ * Parse a vote option string to its numeric enum value.
+ * Accepts case-insensitive strings or numeric identifiers.
+ *
+ * @param optionStr - Vote option string (yes, no, abstain, no_with_veto, or 1-4)
+ * @param voteOptionEnum - The VoteOption enum object from the relevant cosmos module
+ */
+export function parseVoteOption(optionStr: string, voteOptionEnum: VoteOptionEnum): number {
+  const option = optionStr.toLowerCase();
+  switch (option) {
+    case 'yes':
+    case '1':
+      return voteOptionEnum.VOTE_OPTION_YES;
+    case 'abstain':
+    case '2':
+      return voteOptionEnum.VOTE_OPTION_ABSTAIN;
+    case 'no':
+    case '3':
+      return voteOptionEnum.VOTE_OPTION_NO;
+    case 'no_with_veto':
+    case 'nowithveto':
+    case '4':
+      return voteOptionEnum.VOTE_OPTION_NO_WITH_VETO;
+    default:
+      throw new ManifestMCPError(
+        ManifestMCPErrorCode.TX_FAILED,
+        `Invalid vote option: ${optionStr}. Expected: yes, no, abstain, or no_with_veto`
+      );
+  }
+}
+
 /**
  * Parse amount string into coin (e.g., "1000umfx" -> { amount: "1000", denom: "umfx" })
  * Supports simple denoms (umfx), IBC denoms (ibc/...), and factory denoms (factory/creator/subdenom)

package/src/types.ts

@@ -405,6 +405,68 @@ export interface CreditEstimateResult {
   readonly estimate: unknown;
 }
 
+// Group query results
+export interface GroupInfoResult {
+  readonly info?: unknown;
+}
+
+export interface GroupPolicyInfoResult {
+  readonly info?: unknown;
+}
+
+export interface GroupMembersResult extends PaginatedResult {
+  readonly members: readonly unknown[];
+}
+
+export interface GroupsResult extends PaginatedResult {
+  readonly groups: readonly unknown[];
+}
+
+export interface GroupPoliciesResult extends PaginatedResult {
+  readonly groupPolicies: readonly unknown[];
+}
+
+export interface GroupProposalResult {
+  readonly proposal?: unknown;
+}
+
+export interface GroupProposalsResult extends PaginatedResult {
+  readonly proposals: readonly unknown[];
+}
+
+export interface GroupVoteResult {
+  readonly vote?: unknown;
+}
+
+export interface GroupVotesResult extends PaginatedResult {
+  readonly votes: readonly unknown[];
+}
+
+export interface GroupTallyResult {
+  readonly tally?: unknown;
+}
+
+// SKU query results
+export interface SkuParamsResult {
+  readonly params?: unknown;
+}
+
+export interface ProviderResult {
+  readonly provider?: unknown;
+}
+
+export interface ProvidersResult extends PaginatedResult {
+  readonly providers: readonly unknown[];
+}
+
+export interface SkuResult {
+  readonly sku?: unknown;
+}
+
+export interface SkusResult extends PaginatedResult {
+  readonly skus: readonly unknown[];
+}
+
 /**
  * Union type of all query results for type-safe handling
  */
@@ -459,7 +521,22 @@ export type QueryResult =
   | CreditAddressResult
   | WithdrawableAmountResult
   | ProviderWithdrawableResult
-  | CreditEstimateResult;
+  | CreditEstimateResult
+  | SkuParamsResult
+  | ProviderResult
+  | ProvidersResult
+  | SkuResult
+  | SkusResult
+  | GroupInfoResult
+  | GroupPolicyInfoResult
+  | GroupMembersResult
+  | GroupsResult
+  | GroupPoliciesResult
+  | GroupProposalResult
+  | GroupProposalsResult
+  | GroupVoteResult
+  | GroupVotesResult
+  | GroupTallyResult;
 
 /**
  * Result from a Cosmos query