add fee and export

Author: Zetazzz

networks/cosmos/src/utils/fee.test.ts

@@ -0,0 +1,41 @@
+import Decimal from 'decimal.js';
+import { GasPrice, calculateFee } from './fee';
+
+describe('GasPrice', () => {
+  test('fromString parses valid gas price', () => {
+    const gp = GasPrice.fromString('0.025uatom');
+    expect(gp.denom).toBe('uatom');
+    expect(gp.amount.equals(new Decimal('0.025'))).toBe(true);
+  });
+
+  test('toString roundtrips', () => {
+    const gp = GasPrice.fromString('0.0125uosmo');
+    expect(gp.toString()).toBe('0.0125uosmo');
+  });
+
+  test('invalid string throws', () => {
+    expect(() => GasPrice.fromString('abc')).toThrow('Invalid gas price string');
+    expect(() => GasPrice.fromString('0.1')).toThrow('Invalid gas price string');
+    expect(() => GasPrice.fromString('0.1_foo')).toThrow('Invalid gas price string');
+  });
+});
+
+describe('calculateFee', () => {
+  test('works with number gasLimit', () => {
+    const fee = calculateFee(200000, '0.025uatom');
+    expect(fee.gas).toBe('200000');
+    expect(fee.amount).toEqual([{ denom: 'uatom', amount: '5000' }]);
+  });
+
+  test('works with bigint gasLimit', () => {
+    const fee = calculateFee(3n, '0.4ufoo');
+    expect(fee.gas).toBe('3');
+    expect(fee.amount).toEqual([{ denom: 'ufoo', amount: '2' }]); // ceil(1.2) = 2
+  });
+
+  test('rounds up small fractional result to 1', () => {
+    const fee = calculateFee(3, '0.0001utest');
+    expect(fee.amount).toEqual([{ denom: 'utest', amount: '1' }]);
+  });
+});
+

networks/cosmos/src/utils/fee.ts

@@ -0,0 +1,60 @@
+import Decimal from 'decimal.js';
+import { StdFee } from '@interchainjs/types';
+
+/**
+ * Minimal denom checker similar to CosmJS, permissive with basic safety.
+ */
+function checkDenom(denom: string): void {
+  if (!denom) throw new Error('denom must not be empty');
+  if (denom.length < 3 || denom.length > 128) {
+    throw new Error('Denom must be between 3 and 128 characters');
+  }
+}
+
+/**
+ * A gas price, i.e. the price of a single unit of gas. Typically a fraction of the smallest fee token unit.
+ */
+export class GasPrice {
+  public readonly amount: Decimal;
+  public readonly denom: string;
+
+  constructor(amount: Decimal, denom: string) {
+    checkDenom(denom);
+    this.amount = amount;
+    this.denom = denom;
+  }
+
+  /**
+   * Parses a gas price formatted as `<amount><denom>`, e.g. "0.012uatom".
+   * Separators are not supported.
+   */
+  public static fromString(gasPrice: string): GasPrice {
+    const match = gasPrice.match(/^([0-9]+(?:\.[0-9]+)?)([a-zA-Z][a-zA-Z0-9/:._-]*)$/);
+    if (!match) {
+      throw new Error('Invalid gas price string');
+    }
+    const [, amountStr, denom] = match;
+    checkDenom(denom);
+    const amount = new Decimal(amountStr);
+    return new GasPrice(amount, denom);
+  }
+
+  /** Returns a string representation such as "0.025uatom". */
+  public toString(): string {
+    return this.amount.toString() + this.denom;
+  }
+}
+
+/**
+ * Calculate StdFee from a gas limit and gas price. Rounds amount up to the nearest integer unit.
+ */
+export function calculateFee(gasLimit: number | bigint, gasPrice: GasPrice | string): StdFee {
+  const processed = typeof gasPrice === 'string' ? GasPrice.fromString(gasPrice) : gasPrice;
+  const gasLimitDec = new Decimal(typeof gasLimit === 'bigint' ? gasLimit.toString() : gasLimit);
+  const amount = processed.amount.mul(gasLimitDec).ceil();
+  return {
+    amount: [{ denom: processed.denom, amount: amount.toFixed(0) }],
+    gas: (typeof gasLimit === 'bigint' ? gasLimit.toString() : String(gasLimit)),
+  };
+}
+

networks/cosmos/src/utils.ts renamed to networks/cosmos/src/utils/index.ts

@@ -1,5 +1,5 @@
 import { generateMnemonic } from '@interchainjs/crypto';
-import { AminoConverter, Encoder } from './types/signing-client';
+import { AminoConverter, Encoder } from '../types/signing-client';
 import { TelescopeGeneratedCodec } from '@interchainjs/types';
 import { assertEmpty } from '@interchainjs/utils';
 import { Pubkey } from "@interchainjs/amino";
@@ -228,4 +228,11 @@ export function toEncoders(
   ...generatedArray: (Encoder | TelescopeGeneratedCodec<any, any, any>)[]
 ): Encoder[] {
   return generatedArray.map((generated) => toEncoder(generated));
-}
+}
+
+// Re-export selected utilities used by starship tests, if needed
+export { generateMnemonic };
+
+// Re-export fee helpers
+export * from './fee';
+

networks/cosmos/src/utils.test.ts renamed to networks/cosmos/src/utils/utils.test.ts

@@ -1,4 +1,4 @@
-import { accountFromAny, Account } from "./utils";
+import { accountFromAny, Account } from ".";
 import {
   BaseAccount,
   ModuleAccount,
@@ -295,3 +295,4 @@ describe("accountFromAny", () => {
     });
   });
 });
+

networks/cosmos/src/workflows/plugins/fee-calculation.ts

@@ -6,7 +6,7 @@ import { INPUT_VALIDATION_STAGING_KEYS } from './input-validation';
 import { MESSAGE_ENCODING_STAGING_KEYS } from './message-encoding';
 import { SIGNER_INFO_STAGING_KEYS } from './signer-info';
 import { Price } from '@interchainjs/types';
-import Decimal from 'decimal.js';
+import { calculateFee } from '../../utils/fee';
 
 /**
  * Staging keys created by FeeCalculationPlugin
@@ -64,25 +64,23 @@ export class FeeCalculationPlugin extends BaseWorkflowBuilderPlugin<
       const multiplier = params.options?.multiplier ?? 1.5;
       const gasLimit = BigInt(Math.ceil(Number(gasUsed) * multiplier));
 
-      // Default gas price ( Price | 'average' | 'high' | 'low' | undefined)
-      let denom = "uatom";
-      let gasPriceValue = new Decimal('0.025');
+      // Resolve gas price to a concrete string value
+      let gasPriceString = "0.025uatom"; // Default fallback
 
-      // ex) 123.123uatom -> gasPriceValue: "123.123", denom: "uatom")
       if (typeof params.options?.gasPrice === 'string') {
-        const numberMatch = params.options.gasPrice.match(/^(\d+(?:\.\d+)?)(.*)$/);
-        if (numberMatch && numberMatch.length === 3) {
-          gasPriceValue = new Decimal(numberMatch[1]);
-          denom = numberMatch[2];
+        // Handle concrete gas price strings like "0.025uatom" or abstract values like "average"
+        if (params.options.gasPrice.match(/^(\d+(?:\.\d+)?)(.*)$/)) {
+          // It's a concrete gas price string, use it directly
+          gasPriceString = params.options.gasPrice;
+        } else {
+          // It's an abstract value like "average", "high", "low" - keep default for now
+          // TODO: In the future, this could be resolved from chain registry or network config
+          gasPriceString = "0.025uatom";
         }
       }
 
-      const amount = gasPriceValue.mul(gasLimit.toString()).ceil();
-
-      finalFee = {
-        amount: [{ denom, amount: amount.toString() }],
-        gas: gasLimit.toString(),
-      };
+      // Use the new calculateFee utility for consistent fee calculation
+      finalFee = calculateFee(gasLimit, gasPriceString);
     }
 
     // Convert to protobuf Fee