Add estimate message fee (#312)

* [skip ci]

src/devnet-utils.ts

@@ -7,6 +7,7 @@ import { Block, MintResponse, L2ToL1Message } from "./starknet-types";
 import { REQUEST_TIMEOUT } from "./constants";
 import { hash } from "starknet";
 import { numericToHexString } from "./utils";
+import { Numeric } from "./types";
 
 interface L1ToL2Message {
     address: string;
@@ -134,14 +135,14 @@ Make sure you really want to interact with Devnet and that it is running and ava
 
     public async sendMessageToL2(
         l2ContractAddress: string,
-        funcionName: string,
+        functionName: string,
         l1ContractAddress: string,
-        payload: number[],
-        nonce: number
+        payload: Numeric[],
+        nonce: Numeric
     ) {
         const body = {
             l2_contract_address: l2ContractAddress,
-            entry_point_selector: hash.getSelectorFromName(funcionName),
+            entry_point_selector: hash.getSelectorFromName(functionName),
             l1_contract_address: l1ContractAddress,
             payload: payload.map((item) => numericToHexString(item)),
             nonce: numericToHexString(nonce)

src/starknet-wrappers.ts

@@ -8,6 +8,10 @@ import { getPrefixedCommand, normalizeVenvPath } from "./utils/venv";
 import { ExternalServer } from "./external-server";
 import { StarknetPluginError } from "./starknet-plugin-error";
 import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { FeeEstimation } from "./starknet-types";
+import { hash } from "starknet";
+import { toBN, toHex } from "starknet/utils/number";
+import axios from "axios";
 
 interface CompileWrapperOptions {
     file: string;
@@ -394,6 +398,33 @@ export abstract class StarknetWrapper {
         }
         return executed;
     }
+
+    public async estimateMessageFee(
+        functionName: string,
+        fromAddress: string,
+        toAddress: string,
+        inputs: string[]
+    ): Promise<FeeEstimation> {
+        const body = {
+            from_address: fromAddress,
+            to_address: toAddress,
+            entry_point_selector: hash.getSelectorFromName(functionName),
+            payload: inputs.map((item) => toHex(toBN(item)))
+        };
+
+        const response = await axios.post(
+            `${this.hre.starknet.networkConfig.url}/feeder_gateway/estimate_message_fee`,
+            body
+        );
+
+        const { gas_price, gas_usage, overall_fee, unit } = response.data;
+        return {
+            amount: BigInt(overall_fee),
+            unit,
+            gas_price: BigInt(gas_price),
+            gas_usage: BigInt(gas_usage)
+        };
+    }
 }
 
 function getFullImageName(image: Image): string {

src/types/devnet.ts

@@ -1,3 +1,4 @@
+import { Numeric } from ".";
 import {
     FlushResponse,
     IncreaseTimeResponse,
@@ -49,8 +50,8 @@ export interface Devnet {
         l2ContractAddress: string,
         functionName: string,
         l1ContractAddress: string,
-        payload: Array<number>,
-        nonce: number
+        payload: Array<Numeric>,
+        nonce: Numeric
     ) => Promise<L1ToL2MockTxResponse>;
 
     /**

src/types/index.ts

@@ -592,6 +592,32 @@ export class StarknetContract {
         return this.adaptOutput(functionName, executed.stdout.toString());
     }
 
+    /**
+     * Computes L1-to-L2 message fee estimation
+     * @param {string} functionName Function name for entry point selector
+     * @param {StringMap} args - Arguments to Starknet contract function
+     * @returns Fee estimation
+     */
+    async estimateMessageFee(functionName: string, args: StringMap) {
+        // Check if functionName is annotated with @l1_handler
+        const func = <starknet.CairoFunction>this.abi[functionName];
+
+        if (!func?.type || func.type.toString() !== "l1_handler") {
+            throw new StarknetPluginError(
+                `Cannot estimate message fee on "${functionName}" - not an @l1_handler`
+            );
+        }
+        const adaptedInput = this.adaptInput(functionName, args);
+        // Remove value of from_address from the input array
+        const fromAddress = adaptedInput.shift();
+        return this.hre.starknetWrapper.estimateMessageFee(
+            functionName,
+            fromAddress,
+            this.address,
+            adaptedInput
+        );
+    }
+
     /**
      * Estimate the gas fee of executing `functionName` with `args`.
      * @param functionName

www/docs/intro.md

@@ -288,6 +288,16 @@ it("should estimate fee", async function () {
 
     const invokeFee = await account.estimateFee(contract, "method", { arg1: 10n });
     await account.invoke(contract, "method", { arg1: 10n }); // computes max fee implicitly
+
+    // computes message estimate fee
+    const estimatedMessageFee = await l2contract.estimateMessageFee(
+            "deposit",
+            {
+                from_address: L1_CONTRACT_ADDRESS,
+                amount: 123,
+                user: 1
+            }
+        );
 });
 ```