feat: make fee margins configurable

__tests__/rpcProvider.test.ts

@@ -5,6 +5,7 @@ import {
   Block,
   CallData,
   Contract,
+  FeeEstimate,
   RPC,
   RPC06,
   RpcProvider,
@@ -79,6 +80,33 @@ describeIfRpc('RPCProvider', () => {
     expect(typeof spec).toBe('string');
   });
 
+  test('configurable margin', async () => {
+    const p = new RpcProvider({
+      nodeUrl: provider.channel.nodeUrl,
+      feeMarginPercentage: {
+        l1BoundMaxAmount: 0,
+        l1BoundMaxPricePerUnit: 0,
+        maxFee: 0,
+      },
+    });
+    const estimateSpy = jest.spyOn(p.channel as any, 'getEstimateFee');
+    const mockFeeEstimate: FeeEstimate = {
+      gas_consumed: '0x2',
+      gas_price: '0x1',
+      data_gas_consumed: '0x2',
+      data_gas_price: '0x1',
+      overall_fee: '0x4',
+      unit: 'WEI',
+    };
+    estimateSpy.mockResolvedValue([mockFeeEstimate]);
+    const result = (await p.getEstimateFeeBulk([{} as any], {}))[0];
+    expect(estimateSpy).toHaveBeenCalledTimes(1);
+    expect(result.suggestedMaxFee).toBe(4n);
+    expect(result.resourceBounds.l1_gas.max_amount).toBe('0x4');
+    expect(result.resourceBounds.l1_gas.max_price_per_unit).toBe('0x1');
+    estimateSpy.mockRestore();
+  });
+
   describe('Test Estimate message fee', () => {
     const L1_ADDRESS = '0x8359E4B0152ed5A731162D3c7B0D8D56edB165A0';
     let l1l2ContractAddress: string;

__tests__/utils/stark.test.ts

@@ -87,11 +87,11 @@ describe('stark', () => {
     };
     expect(stark.estimateFeeToBounds(estimateFeeResponse)).toStrictEqual({
       l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
-      l1_gas: { max_amount: '0x6e', max_price_per_unit: '0xf' },
+      l1_gas: { max_amount: '0x96', max_price_per_unit: '0xf' },
     });
     expect(stark.estimateFeeToBounds(estimateFeeResponse07)).toStrictEqual({
       l2_gas: { max_amount: '0x0', max_price_per_unit: '0x0' },
-      l1_gas: { max_amount: '0xdc', max_price_per_unit: '0xf' },
+      l1_gas: { max_amount: '0x12c', max_price_per_unit: '0xf' },
     });
   });
 

__tests__/utils/utils.test.ts

@@ -70,11 +70,11 @@ describe('computeHashOnElements()', () => {
 });
 describe('estimatedFeeToMaxFee()', () => {
   test('should return maxFee for 0', () => {
-    const res = stark.estimatedFeeToMaxFee(0, 0.15);
+    const res = stark.estimatedFeeToMaxFee(0, 15);
     expect(res).toBe(0n);
   });
   test('should return maxFee for 10_000', () => {
-    const res = stark.estimatedFeeToMaxFee(10_000, 0.15);
+    const res = stark.estimatedFeeToMaxFee(10_000, 15);
     expect(res).toBe(11500n);
   });
 });

src/constants.ts

@@ -48,6 +48,12 @@ export enum TransactionHashPrefix {
   L1_HANDLER = '0x6c315f68616e646c6572', // encodeShortString('l1_handler'),
 }
 
+export const enum feeMarginPercentage {
+  L1_BOUND_MAX_AMOUNT = 50,
+  L1_BOUND_MAX_PRICE_PER_UNIT = 50,
+  MAX_FEE = 50,
+}
+
 export const UDC = {
   ADDRESS: '0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf',
   ENTRYPOINT: 'deployContract',

src/provider/rpc.ts

@@ -31,15 +31,17 @@ import { isSierra } from '../utils/contract';
 import { RPCResponseParser } from '../utils/responseParser/rpc';
 
 export class RpcProvider implements ProviderInterface {
-  private responseParser = new RPCResponseParser();
+  private responseParser: RPCResponseParser;
 
   public channel: RPC07.RpcChannel | RPC06.RpcChannel;
 
   constructor(optionsOrProvider?: RpcProviderOptions | ProviderInterface | RpcProvider) {
     if (optionsOrProvider && 'channel' in optionsOrProvider) {
       this.channel = optionsOrProvider.channel;
+      this.responseParser = (optionsOrProvider as any).responseParser;
     } else {
       this.channel = new RpcChannel({ ...optionsOrProvider, waitMode: false });
+      this.responseParser = new RPCResponseParser(optionsOrProvider?.feeMarginPercentage);
     }
   }
 
@@ -176,7 +178,7 @@ export class RpcProvider implements ProviderInterface {
     // can't be named simulateTransaction because of argument conflict with account
     return this.channel
       .simulateTransaction(invocations, options)
-      .then(this.responseParser.parseSimulateTransactionResponse);
+      .then((r) => this.responseParser.parseSimulateTransactionResponse(r));
   }
 
   public async waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions) {
@@ -278,7 +280,7 @@ export class RpcProvider implements ProviderInterface {
         ],
         { blockIdentifier, skipValidate }
       )
-      .then(this.responseParser.parseFeeEstimateResponse);
+      .then((r) => this.responseParser.parseFeeEstimateResponse(r));
   }
 
   public async getDeclareEstimateFee(
@@ -298,7 +300,7 @@ export class RpcProvider implements ProviderInterface {
         ],
         { blockIdentifier, skipValidate }
       )
-      .then(this.responseParser.parseFeeEstimateResponse);
+      .then((r) => this.responseParser.parseFeeEstimateResponse(r));
   }
 
   public async getDeployAccountEstimateFee(
@@ -318,7 +320,7 @@ export class RpcProvider implements ProviderInterface {
         ],
         { blockIdentifier, skipValidate }
       )
-      .then(this.responseParser.parseFeeEstimateResponse);
+      .then((r) => this.responseParser.parseFeeEstimateResponse(r));
   }
 
   public async getEstimateFeeBulk(
@@ -327,7 +329,7 @@ export class RpcProvider implements ProviderInterface {
   ) {
     return this.channel
       .getEstimateFee(invocations, options)
-      .then(this.responseParser.parseFeeEstimateBulkResponse);
+      .then((r) => this.responseParser.parseFeeEstimateBulkResponse(r));
   }
 
   public async invokeFunction(

src/types/provider/configuration.ts

@@ -12,4 +12,9 @@ export type RpcProviderOptions = {
   specVersion?: string;
   default?: boolean;
   waitMode?: boolean;
+  feeMarginPercentage?: {
+    l1BoundMaxAmount: number;
+    l1BoundMaxPricePerUnit: number;
+    maxFee: number;
+  };
 };

src/utils/responseParser/rpc.ts

@@ -14,6 +14,7 @@ import {
   FeeEstimate,
   SimulateTransactionResponse,
   SimulatedTransaction,
+  RpcProviderOptions,
 } from '../../types/provider';
 import { toBigInt } from '../num';
 import { estimateFeeToBounds, estimatedFeeToMaxFee } from '../stark';
@@ -31,6 +32,24 @@ export class RPCResponseParser
       | 'parseCallContractResponse'
     >
 {
+  private margin: RpcProviderOptions['feeMarginPercentage'];
+
+  constructor(margin?: RpcProviderOptions['feeMarginPercentage']) {
+    this.margin = margin;
+  }
+
+  private estimatedFeeToMaxFee(estimatedFee: Parameters<typeof estimatedFeeToMaxFee>[0]) {
+    return estimatedFeeToMaxFee(estimatedFee, this.margin?.maxFee);
+  }
+
+  private estimateFeeToBounds(estimate: Parameters<typeof estimateFeeToBounds>[0]) {
+    return estimateFeeToBounds(
+      estimate,
+      this.margin?.l1BoundMaxAmount,
+      this.margin?.l1BoundMaxPricePerUnit
+    );
+  }
+
   public parseGetBlockResponse(res: BlockWithTxHashes): GetBlockResponse {
     return { status: 'PENDING', ...res } as GetBlockResponse;
   }
@@ -58,8 +77,8 @@ export class RPCResponseParser
       gas_consumed: toBigInt(val.gas_consumed),
       gas_price: toBigInt(val.gas_price),
       unit: val.unit,
-      suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-      resourceBounds: estimateFeeToBounds(val),
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
     };
   }
 
@@ -69,8 +88,8 @@ export class RPCResponseParser
       gas_consumed: toBigInt(val.gas_consumed),
       gas_price: toBigInt(val.gas_price),
       unit: val.unit,
-      suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-      resourceBounds: estimateFeeToBounds(val),
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
     }));
   }
 
@@ -85,8 +104,8 @@ export class RPCResponseParser
     return res.map((it: SimulatedTransaction) => {
       return {
         ...it,
-        suggestedMaxFee: estimatedFeeToMaxFee(BigInt(it.fee_estimation.overall_fee)),
-        resourceBounds: estimateFeeToBounds(it.fee_estimation),
+        suggestedMaxFee: this.estimatedFeeToMaxFee(it.fee_estimation.overall_fee),
+        resourceBounds: this.estimateFeeToBounds(it.fee_estimation),
       };
     });
   }

src/utils/stark.ts

@@ -1,7 +1,7 @@
 import { getStarkKey, utils } from '@scure/starknet';
 import { gzip, ungzip } from 'pako';
 
-import { ZERO } from '../constants';
+import { ZERO, feeMarginPercentage } from '../constants';
 import {
   ArraySignatureType,
   BigNumberish,
@@ -95,14 +95,17 @@ export function signatureToHexArray(sig?: Signature): ArraySignatureType {
 /**
  * Convert estimated fee to max fee with overhead
  */
-export function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead: number = 0.5): bigint {
-  return addPercent(estimatedFee, overhead * 100);
+export function estimatedFeeToMaxFee(
+  estimatedFee: BigNumberish,
+  overhead: number = feeMarginPercentage.MAX_FEE
+): bigint {
+  return addPercent(estimatedFee, overhead);
 }
 
 export function estimateFeeToBounds(
   estimate: FeeEstimate | 0n,
-  amountOverhead: number = 10,
-  priceOverhead = 50
+  amountOverhead: number = feeMarginPercentage.L1_BOUND_MAX_AMOUNT,
+  priceOverhead: number = feeMarginPercentage.L1_BOUND_MAX_PRICE_PER_UNIT
 ): ResourceBounds {
   if (typeof estimate === 'bigint') {
     return {