Support estimate fee on declare v2

scripts/test-setup.sh

@@ -6,7 +6,7 @@ trap 'for killable in $(jobs -p); do kill -9 $killable; done' EXIT
 
 # setup example repo
 rm -rf starknet-hardhat-example
-EXAMPLE_REPO_BRANCH="plugin"
+EXAMPLE_REPO_BRANCH="estimate-declarev2-fee"
 if [[ "$CIRCLE_BRANCH" == "master" ]] && [[ "$EXAMPLE_REPO_BRANCH" != "plugin" ]]; then
     echo "Invalid example repo branch: $EXAMPLE_REPO_BRANCH"
     exit 1

src/account-utils.ts

@@ -215,7 +215,7 @@ export function calculateDeclareV2TxHash(
 
 export async function sendDeclareV2Tx(
     signatures: string[],
-    classHash: string,
+    compiledClassHash: string,
     maxFee: Numeric,
     senderAddress: string,
     version: Numeric,
@@ -229,7 +229,7 @@ export async function sendDeclareV2Tx(
             contract_class: contractClass.getCompiledClass(),
             signature: signatures,
             sender_address: senderAddress,
-            compiled_class_hash: number.toHex(number.toBN(classHash)),
+            compiled_class_hash: compiledClassHash,
             version: numericToHexString(version),
             nonce: numericToHexString(nonce),
             max_fee: numericToHexString(maxFee)

src/account.ts

@@ -180,10 +180,56 @@ export abstract class Account {
         );
     }
 
+    private async estimateDeclareV2Fee(
+        contractFactory: StarknetContractFactory,
+        options: EstimateFeeOptions = {}
+    ): Promise<starknet.FeeEstimation> {
+        const maxFee = (options.maxFee || 0).toString();
+        const version = DECLARE_VERSION;
+        const nonce = options.nonce == null ? await this.getNonce() : options.nonce;
+
+        const hre = await import("hardhat");
+        const chainId = hre.starknet.networkConfig.starknetChainId;
+
+        const compiledClassHash = await hre.starknetWrapper.getCompiledClassHash(
+            contractFactory.casmPath
+        );
+
+        const classHash = await hre.starknetWrapper.getSierraContractClassHash(
+            contractFactory.metadataPath
+        );
+
+        const calldata = [classHash];
+        const messageHash = calculateDeclareV2TxHash(
+            this.address,
+            calldata,
+            maxFee.toString(),
+            chainId,
+            [nonce.toString(), compiledClassHash]
+        );
+
+        const signatures = this.getSignatures(messageHash);
+        const data = {
+            type: "DECLARE",
+            sender_address: this.address,
+            compiled_class_hash: compiledClassHash,
+            contract_class: readCairo1Contract(contractFactory.metadataPath).getCompiledClass(),
+            signature: bnToDecimalStringArray(signatures || []),
+            version: numericToHexString(version),
+            nonce: numericToHexString(nonce)
+        };
+
+        return await sendEstimateFeeTx(data);
+    }
+
     async estimateDeclareFee(
         contractFactory: StarknetContractFactory,
         options: EstimateFeeOptions = {}
     ): Promise<starknet.FeeEstimation> {
+        if (contractFactory.isCairo1()) {
+            return await this.estimateDeclareV2Fee(contractFactory, options);
+        }
+
         const nonce = options.nonce == null ? await this.getNonce() : options.nonce;
         const maxFee = (options.maxFee || 0).toString();
 
@@ -464,16 +510,19 @@ export abstract class Account {
         contractFactory: StarknetContractFactory,
         options: DeclareOptions = {}
     ): Promise<string> {
-        const maxFee = options?.maxFee;
-        if (!maxFee) {
-            const msg =
-                "maxFee must be provided to send declare transactions.\n" +
-                "A value of '0' for 'maxFee' is not supported.";
+        let maxFee = options?.maxFee;
+        if (maxFee && options?.overhead) {
+            const msg = "maxFee and overhead cannot be specified together";
             throw new StarknetPluginError(msg);
         }
 
-        const version = DECLARE_VERSION;
         const nonce = options.nonce == null ? await this.getNonce() : options.nonce;
+        if (maxFee === undefined || maxFee === null) {
+            const estimatedDeclareFee = await this.estimateDeclareV2Fee(contractFactory, options);
+            maxFee = estimatedFeeToMaxFee(estimatedDeclareFee.amount, options?.overhead);
+        }
+
+        const version = DECLARE_VERSION;
         const hre = await import("hardhat");
         const chainId = hre.starknet.networkConfig.starknetChainId;
 

src/starknet-wrappers.ts

@@ -574,8 +574,6 @@ function getFullImageName(image: Image): string {
     return `${image.repository}:${image.tag}`;
 }
 
-type String2String = { [path: string]: string };
-
 export class DockerWrapper extends StarknetWrapper {
     constructor(
         private image: Image,
@@ -612,16 +610,6 @@ export class DockerWrapper extends StarknetWrapper {
     }
 
     public async interact(options: InteractWrapperOptions): Promise<ProcessResult> {
-        const binds: String2String = {};
-
-        if (options.abi) {
-            binds[options.abi] = options.abi;
-        }
-
-        if (options.accountDir) {
-            binds[options.accountDir] = options.accountDir;
-        }
-
         const preparedOptions = this.prepareInteractOptions(options);
         const executed = this.execute("starknet", preparedOptions);
         return executed;

src/starknet_cli_wrapper.py

@@ -42,7 +42,7 @@ async def get_compiled_class_hash(args):
         with open(casm_path, encoding="utf-8") as casm_file:
             compiled_class = CompiledClass.loads(casm_file.read())
         compiled_class_hash = compute_compiled_class_hash(compiled_class)
-        print(compiled_class_hash)
+        print(hex(compiled_class_hash))
         return 0
     except Exception as err:
         print(err, file=sys.stderr)