fix: discriminate extrinsic_base_weight based on dispatch class

calc/pkg/calc.d.ts

@@ -6,20 +6,20 @@ export class CalcFee {
   free(): void;
 /**
 * @param {any} polynomial
-* @param {BigInt} extrinsic_base_weight
 * @param {string} multiplier
 * @param {string} per_byte_fee
 * @param {string} spec_name
 * @param {number} spec_version
 * @returns {CalcFee | undefined}
 */
-  static from_params(polynomial: any, extrinsic_base_weight: BigInt, multiplier: string, per_byte_fee: string, spec_name: string, spec_version: number): CalcFee | undefined;
+  static from_params(polynomial: any, multiplier: string, per_byte_fee: string, spec_name: string, spec_version: number): CalcFee | undefined;
 /**
 * @param {BigInt} weight
 * @param {number} len
+* @param {BigInt} extrinsic_base_weight
 * @returns {string}
 */
-  calc_fee(weight: BigInt, len: number): string;
+  calc_fee(weight: BigInt, len: number, extrinsic_base_weight: BigInt): string;
 }
 /**
 */

calc/pkg/calc.js

@@ -147,25 +147,21 @@ class CalcFee {
     }
     /**
     * @param {any} polynomial
-    * @param {BigInt} extrinsic_base_weight
     * @param {string} multiplier
     * @param {string} per_byte_fee
     * @param {string} spec_name
     * @param {number} spec_version
     * @returns {CalcFee | undefined}
     */
-    static from_params(polynomial, extrinsic_base_weight, multiplier, per_byte_fee, spec_name, spec_version) {
+    static from_params(polynomial, multiplier, per_byte_fee, spec_name, spec_version) {
         try {
-            uint64CvtShim[0] = extrinsic_base_weight;
-            const low0 = u32CvtShim[0];
-            const high0 = u32CvtShim[1];
-            var ptr1 = passStringToWasm0(multiplier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var ptr0 = passStringToWasm0(multiplier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            var ptr1 = passStringToWasm0(per_byte_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             var len1 = WASM_VECTOR_LEN;
-            var ptr2 = passStringToWasm0(per_byte_fee, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var ptr2 = passStringToWasm0(spec_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             var len2 = WASM_VECTOR_LEN;
-            var ptr3 = passStringToWasm0(spec_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len3 = WASM_VECTOR_LEN;
-            var ret = wasm.calcfee_from_params(addBorrowedObject(polynomial), low0, high0, ptr1, len1, ptr2, len2, ptr3, len3, spec_version);
+            var ret = wasm.calcfee_from_params(addBorrowedObject(polynomial), ptr0, len0, ptr1, len1, ptr2, len2, spec_version);
             return ret === 0 ? undefined : CalcFee.__wrap(ret);
         } finally {
             heap[stack_pointer++] = undefined;
@@ -174,16 +170,20 @@ class CalcFee {
     /**
     * @param {BigInt} weight
     * @param {number} len
+    * @param {BigInt} extrinsic_base_weight
     * @returns {string}
     */
-    calc_fee(weight, len) {
+    calc_fee(weight, len, extrinsic_base_weight) {
         try {
             const retptr = wasm.__wbindgen_export_2.value - 16;
             wasm.__wbindgen_export_2.value = retptr;
             uint64CvtShim[0] = weight;
             const low0 = u32CvtShim[0];
             const high0 = u32CvtShim[1];
-            wasm.calcfee_calc_fee(retptr, this.ptr, low0, high0, len);
+            uint64CvtShim[0] = extrinsic_base_weight;
+            const low1 = u32CvtShim[0];
+            const high1 = u32CvtShim[1];
+            wasm.calcfee_calc_fee(retptr, this.ptr, low0, high0, len, low1, high1);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             return getStringFromWasm0(r0, r1);

calc/pkg/calc_bg.d.ts

@@ -2,8 +2,8 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export function __wbg_calcfee_free(a: number): void;
-export function calcfee_from_params(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number): number;
-export function calcfee_calc_fee(a: number, b: number, c: number, d: number, e: number): void;
+export function calcfee_from_params(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): number;
+export function calcfee_calc_fee(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
 export function __wbg_calcpayout_free(a: number): void;
 export function calcpayout_from_params(a: number, b: number, c: number): number;
 export function calcpayout_calc_payout(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number): void;

calc/src/calc_fee.rs

@@ -83,24 +83,22 @@ pub struct CalcFee {
     polynomial: Vec<Coefficient>,
     multiplier: Multiplier,
     per_byte_fee: Balance,
-    base_fee: Balance,
     adjust_len_fee: bool,
 }
 
 #[wasm_bindgen]
 impl CalcFee {
     pub fn from_params(
         polynomial: &JsValue,
-        extrinsic_base_weight: Weight,
         multiplier: &str,
         per_byte_fee: &str,
         spec_name: &str,
         spec_version: u32,
     ) -> Option<CalcFee> {
         debug::setup();
         info!(
-            "CalcFee::from_params({:#?}, {}, {}, {}, {}, {})",
-            polynomial, extrinsic_base_weight, multiplier, per_byte_fee, spec_name, spec_version
+            "CalcFee::from_params({:#?}, {}, {}, {}, {})",
+            polynomial, multiplier, per_byte_fee, spec_name, spec_version
         );
 
         let polynomial: Vec<Coefficient> = {
@@ -126,7 +124,6 @@ impl CalcFee {
         };
         let multiplier = Multiplier::new(multiplier, spec_name, spec_version)?;
         let per_byte_fee = Balance::from_str(per_byte_fee).unwrap();
-        let base_fee = weight_to_fee(&extrinsic_base_weight, &polynomial);
         let adjust_len_fee = if let Multiplier::V2(_) = &multiplier {
             false
         } else {
@@ -136,7 +133,6 @@ impl CalcFee {
             polynomial,
             multiplier,
             per_byte_fee,
-            base_fee,
             adjust_len_fee,
         };
         info!(
@@ -146,9 +142,15 @@ impl CalcFee {
         Some(calc)
     }
 
-    pub fn calc_fee(&self, weight: Weight, len: u32) -> String {
+    pub fn calc_fee(
+        &self, 
+        weight: Weight, 
+        len: u32, 
+        extrinsic_base_weight: Weight,
+    ) -> String {
         let unadjusted_len_fee = self.per_byte_fee.saturating_mul(len.into());
         let unadjusted_weight_fee = weight_to_fee(&weight, &self.polynomial);
+        let base_fee = weight_to_fee(&extrinsic_base_weight, &self.polynomial);
 
         let (len_fee, adjustable_fee) = if self.adjust_len_fee {
             (0, unadjusted_len_fee.saturating_add(unadjusted_weight_fee))
@@ -157,20 +159,20 @@ impl CalcFee {
         };
         let adjusted_fee = self.multiplier.calc(adjustable_fee);
 
-        let result = self
-            .base_fee
+        let result = base_fee
             .saturating_add(len_fee)
             .saturating_add(adjusted_fee);
 
         info!(
             "calc_fee: ({}, {}) -> len_fee: {} weight_fee: {} adjustable_fee: {} \
-			adjusted_fee: {} result: {}",
+			adjusted_fee: {} base_fee: {} result: {}",
             weight,
             len,
             unadjusted_len_fee,
             unadjusted_weight_fee,
             adjustable_fee,
             adjusted_fee,
+            base_fee,
             result
         );
 

package.json

@@ -39,7 +39,7 @@
     "@polkadot/api": "^3.6.4",
     "@polkadot/apps-config": "^0.77.1",
     "@polkadot/util-crypto": "^5.4.4",
-    "@substrate/calc": "^0.1.3",
+    "@substrate/calc": "file:./calc/pkg",
     "confmgr": "^1.0.6",
     "express": "^4.17.1",
     "express-winston": "^4.0.5",

src/services/blocks/BlocksService.spec.ts

@@ -124,7 +124,9 @@ describe('BlocksService', () => {
 				mockBlock789629
 			);
 
-			expect(calcFee?.calc_fee(BigInt(399480000), 534)).toBe('544000000');
+			expect(
+				calcFee?.calc_fee(BigInt(399480000), 534, BigInt(125000000))
+			).toBe('544000000');
 		});
 
 		it('calculates partialFee for utility.batch in polkadot block 789629', async () => {
@@ -135,9 +137,9 @@ describe('BlocksService', () => {
 				mockBlock789629
 			);
 
-			expect(calcFee?.calc_fee(BigInt(941325000000), 1247)).toBe(
-				'1257000075'
-			);
+			expect(
+				calcFee?.calc_fee(BigInt(941325000000), 1247, BigInt(125000000))
+			).toBe('1257000075');
 		});
 	});