starknet 4.18.0 → 4.19.0

package/dist/index.mjs

@@ -2821,6 +2821,9 @@ var RpcProvider = class {
       block_id
     }).then(this.responseParser.parseFeeEstimateResponse);
   }
+  async getEstimateFeeBulk(_invocations, _blockIdentifier = this.blockIdentifier) {
+    throw new Error("RPC does not implement getInvokeEstimateFeeBulk function");
+  }
   async declareContract({ contractDefinition, signature, senderAddress }, details) {
     return this.fetchEndpoint("starknet_addDeclareTransaction", {
       declare_transaction: {
@@ -3002,6 +3005,27 @@ var SequencerAPIResponseParser = class extends ResponseParser {
       overall_fee: toBN(res.amount)
     };
   }
+  parseFeeEstimateBulkResponse(res) {
+    return [].concat(res).map((item) => {
+      if ("overall_fee" in item) {
+        let gasInfo = {};
+        try {
+          gasInfo = {
+            gas_consumed: toBN(item.gas_usage),
+            gas_price: toBN(item.gas_price)
+          };
+        } catch {
+        }
+        return {
+          overall_fee: toBN(item.overall_fee),
+          ...gasInfo
+        };
+      }
+      return {
+        overall_fee: toBN(item.amount)
+      };
+    });
+  }
   parseCallContractResponse(res) {
     return {
       result: res.result
@@ -3134,6 +3158,7 @@ var SequencerProvider = class {
       "call_contract",
       "estimate_fee",
       "estimate_message_fee",
+      "estimate_fee_bulk",
       "simulate_transaction"
     ];
     return postMethodEndpoints.includes(endpoint) ? "POST" : "GET";
@@ -3336,6 +3361,42 @@ var SequencerProvider = class {
       }
     ).then(this.responseParser.parseFeeEstimateResponse);
   }
+  async getEstimateFeeBulk(invocations, blockIdentifier = this.blockIdentifier) {
+    const params = invocations.map((invocation) => {
+      let res;
+      if (invocation.type === "INVOKE_FUNCTION") {
+        res = {
+          type: invocation.type,
+          contract_address: invocation.contractAddress,
+          calldata: invocation.calldata ?? []
+        };
+      } else if (invocation.type === "DECLARE") {
+        res = {
+          type: invocation.type,
+          sender_address: invocation.senderAddress,
+          contract_class: invocation.contractDefinition
+        };
+      } else {
+        res = {
+          type: invocation.type,
+          class_hash: toHex(toBN(invocation.classHash)),
+          constructor_calldata: bigNumberishArrayToDecimalStringArray(
+            invocation.constructorCalldata || []
+          ),
+          contract_address_salt: toHex(toBN(invocation.addressSalt || 0))
+        };
+      }
+      return {
+        ...res,
+        signature: bigNumberishArrayToDecimalStringArray(invocation.signature || []),
+        version: toHex(toBN((invocation == null ? void 0 : invocation.version) || 1)),
+        nonce: toHex(toBN(invocation.nonce))
+      };
+    });
+    return this.fetchEndpoint("estimate_fee_bulk", { blockIdentifier }, params).then(
+      this.responseParser.parseFeeEstimateBulkResponse
+    );
+  }
   async getCode(contractAddress, blockIdentifier = this.blockIdentifier) {
     return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
   }
@@ -3438,6 +3499,9 @@ var Provider = class {
       blockIdentifier
     );
   }
+  async getEstimateFeeBulk(invocations, blockIdentifier) {
+    return this.provider.getEstimateFeeBulk(invocations, blockIdentifier);
+  }
   async getNonceForAddress(contractAddress, blockIdentifier) {
     return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
   }
@@ -4492,10 +4556,9 @@ var Account = class extends Provider {
       version,
       chainId
     };
-    const signature = await this.signer.signTransaction(transactions, signerDetails);
-    const calldata = fromCallsToExecuteCalldata(transactions);
+    const invocation = await this.buildInvocation(transactions, signerDetails);
     const response = await super.getInvokeEstimateFee(
-      { contractAddress: this.address, calldata, signature },
+      { ...invocation },
       { version, nonce },
       blockIdentifier
     );
@@ -4509,17 +4572,12 @@ var Account = class extends Provider {
     const nonce = toBN(providedNonce ?? await this.getNonce());
     const version = toBN(feeTransactionVersion);
     const chainId = await this.getChainId();
-    const contractDefinition = parseContract(contract);
-    const signature = await this.signer.signDeclareTransaction({
-      classHash,
-      senderAddress: this.address,
-      chainId,
-      maxFee: ZERO,
-      version,
-      nonce
-    });
+    const payload = await this.buildDeclarePayload(
+      { classHash, contract },
+      { nonce, chainId, version, walletAddress: this.address, maxFee: ZERO }
+    );
     const response = await super.getDeclareEstimateFee(
-      { senderAddress: this.address, signature, contractDefinition },
+      { ...payload },
       { version, nonce },
       blockIdentifier
     );
@@ -4538,19 +4596,12 @@ var Account = class extends Provider {
     const nonce = "0x0";
     const version = toBN(feeTransactionVersion);
     const chainId = await this.getChainId();
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
-    const signature = await this.signer.signDeployAccountTransaction({
-      classHash,
-      contractAddress,
-      chainId,
-      maxFee: ZERO,
-      version,
-      nonce,
-      addressSalt,
-      constructorCalldata
-    });
+    const payload = await this.buildAccountDeployPayload(
+      { classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress },
+      { nonce, chainId, version, walletAddress: this.address, maxFee: ZERO }
+    );
     const response = await super.getDeployAccountEstimateFee(
-      { classHash, addressSalt, constructorCalldata, signature },
+      { ...payload },
       { version, nonce },
       blockIdentifier
     );
@@ -4561,27 +4612,85 @@ var Account = class extends Provider {
     };
   }
   async estimateDeployFee(payload, transactionsDetail) {
-    const calls = [].concat(payload).map((it) => {
-      const {
-        classHash,
-        salt = "0",
-        unique = true,
-        constructorCalldata = []
-      } = it;
-      const compiledConstructorCallData = compileCalldata(constructorCalldata);
+    const calls = this.buildUDCContractPayload(payload);
+    return this.estimateInvokeFee(calls, transactionsDetail);
+  }
+  async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier } = {}) {
+    const nonce = toBN(providedNonce ?? await this.getNonce());
+    const version = toBN(feeTransactionVersion);
+    const chainId = await this.getChainId();
+    const params = await Promise.all(
+      [].concat(transactions).map(async (transaction, index) => {
+        const signerDetails = {
+          walletAddress: this.address,
+          nonce: toBN(Number(nonce) + index),
+          maxFee: ZERO,
+          version,
+          chainId
+        };
+        const txPayload = transaction.payload;
+        let res;
+        if (typeof transaction === "object" && transaction.type === "INVOKE_FUNCTION") {
+          const invocation = await this.buildInvocation(
+            Array.isArray(txPayload) ? txPayload : [txPayload],
+            signerDetails
+          );
+          res = {
+            type: "INVOKE_FUNCTION",
+            ...invocation,
+            version,
+            nonce: toBN(Number(nonce) + index),
+            blockIdentifier
+          };
+        } else if (typeof transaction === "object" && transaction.type === "DECLARE") {
+          const declareContractPayload = await this.buildDeclarePayload(txPayload, signerDetails);
+          res = {
+            type: "DECLARE",
+            ...declareContractPayload,
+            version,
+            nonce: toBN(Number(nonce) + index),
+            blockIdentifier
+          };
+        } else if (typeof transaction === "object" && transaction.type === "DEPLOY_ACCOUNT") {
+          const payload = await this.buildAccountDeployPayload(txPayload, signerDetails);
+          res = {
+            type: "DEPLOY_ACCOUNT",
+            ...payload,
+            version,
+            nonce,
+            blockIdentifier
+          };
+        } else if (typeof transaction === "object" && transaction.type === "DEPLOY") {
+          const calls = this.buildUDCContractPayload(txPayload);
+          const invocation = await this.buildInvocation(calls, signerDetails);
+          res = {
+            type: "INVOKE_FUNCTION",
+            ...invocation,
+            version,
+            nonce: toBN(Number(nonce) + index),
+            blockIdentifier
+          };
+        }
+        return res;
+      })
+    );
+    const response = await super.getEstimateFeeBulk(params, blockIdentifier);
+    return [].concat(response).map((elem) => {
+      const suggestedMaxFee = estimatedFeeToMaxFee(elem.overall_fee);
       return {
-        contractAddress: UDC.ADDRESS,
-        entrypoint: UDC.ENTRYPOINT,
-        calldata: [
-          classHash,
-          salt,
-          toCairoBool(unique),
-          compiledConstructorCallData.length,
-          ...compiledConstructorCallData
-        ]
+        ...elem,
+        suggestedMaxFee
       };
     });
-    return this.estimateInvokeFee(calls, transactionsDetail);
+  }
+  async buildInvocation(call, signerDetails) {
+    const calldata = fromCallsToExecuteCalldata(call);
+    const signature = await this.signer.signTransaction(call, signerDetails);
+    return {
+      contractAddress: this.address,
+      calldata,
+      signature
+    };
   }
   async execute(calls, abis = void 0, transactionsDetail = {}) {
     const transactions = Array.isArray(calls) ? calls : [calls];
@@ -4770,6 +4879,69 @@ var Account = class extends Provider {
     }
     return feeEstimate.suggestedMaxFee.toString();
   }
+  async buildDeclarePayload({ classHash, contract }, { nonce, chainId, version, walletAddress, maxFee }) {
+    const contractDefinition = parseContract(contract);
+    const signature = await this.signer.signDeclareTransaction({
+      classHash,
+      senderAddress: walletAddress,
+      chainId,
+      maxFee,
+      version,
+      nonce
+    });
+    return {
+      senderAddress: walletAddress,
+      signature,
+      contractDefinition
+    };
+  }
+  async buildAccountDeployPayload({
+    classHash,
+    addressSalt = 0,
+    constructorCalldata = [],
+    contractAddress: providedContractAddress
+  }, { nonce, chainId, version, maxFee }) {
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+    const signature = await this.signer.signDeployAccountTransaction({
+      classHash,
+      contractAddress,
+      chainId,
+      maxFee,
+      version,
+      nonce,
+      addressSalt,
+      constructorCalldata
+    });
+    return {
+      classHash,
+      addressSalt,
+      constructorCalldata,
+      signature
+    };
+  }
+  buildUDCContractPayload(payload) {
+    const calls = [].concat(payload).map((it) => {
+      const {
+        classHash,
+        salt = "0",
+        unique = true,
+        constructorCalldata = []
+      } = it;
+      const compiledConstructorCallData = compileCalldata(constructorCalldata);
+      return {
+        contractAddress: UDC.ADDRESS,
+        entrypoint: UDC.ENTRYPOINT,
+        calldata: [
+          classHash,
+          salt,
+          toCairoBool(unique),
+          compiledConstructorCallData.length,
+          ...compiledConstructorCallData
+        ]
+      };
+    });
+    return calls;
+  }
 };
 
 // src/account/interface.ts