starknet 8.7.0 → 8.9.0

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+# [8.9.0](https://github.com/starknet-io/starknet.js/compare/v8.8.0...v8.9.0) (2025-11-13)
+
+### Features
+
+- paymaster snip-29 in Contract class ([#1470](https://github.com/starknet-io/starknet.js/issues/1470)) ([a6b839e](https://github.com/starknet-io/starknet.js/commit/a6b839eec40c2d610e98edba6b838749c7e89053))
+
+# [8.8.0](https://github.com/starknet-io/starknet.js/compare/v8.7.0...v8.8.0) (2025-11-12)
+
+### Bug Fixes
+
+- both sepolia and mainet on alchemy ([f119081](https://github.com/starknet-io/starknet.js/commit/f1190815ba032a0b4094e6c16c3b6cd4cca216e1))
+- public node hotfix ([d35e39e](https://github.com/starknet-io/starknet.js/commit/d35e39eb600a30b46146630ec0bbc916db65d976))
+
+### Features
+
+- starknet version, use starknt version to determin declare hash instead of spec version ([70a23ee](https://github.com/starknet-io/starknet.js/commit/70a23ee4f14d5f7a0d754bfcfc3312cd5585b951))
+
 # [8.7.0](https://github.com/starknet-io/starknet.js/compare/v8.6.0...v8.7.0) (2025-11-07)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -3244,6 +3244,8 @@ type ExecuteOptions = Pick<CommonContractOptions, 'parseRequest'> & {
      * Deployer contract salt
      */
     salt?: string;
+    paymasterDetails?: PaymasterDetails;
+    maxFeeInGasToken?: BigNumberish;
     /**
      * Wait for transaction to be included in a block
      * @default false
@@ -3917,7 +3919,7 @@ declare const DEFAULT_GLOBAL_CONFIG: {
     blake: ((uint8Array: Uint8Array) => Uint8Array) | undefined;
 };
 declare const RPC_DEFAULT_NODES: {
-    readonly SN_MAIN: readonly ["https://starknet-mainnet.g.alchemy.com/starknet/version/rpc"];
+    readonly SN_MAIN: readonly ["https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/"];
     readonly SN_SEPOLIA: readonly ["https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/"];
 };
 declare const PAYMASTER_RPC_NODES: {
@@ -4022,6 +4024,11 @@ declare class RpcChannel$1 {
     blockIdentifier?: BlockIdentifier): Promise<RPCSPEC08.StorageProof>;
     getCompiledCasm(classHash: BigNumberish): Promise<RPCSPEC08.CASM_COMPILED_CONTRACT_CLASS>;
     getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    /**
+     * Helper method to get the starknet version from the block, default latest block
+     * @returns Starknet version
+     */
+    getStarknetVersion(blockIdentifier?: BlockIdentifier): Promise<string>;
     /**
      * Get the most recent accepted block hash and number
      */
@@ -4165,6 +4172,11 @@ declare class RpcChannel {
     blockIdentifier?: BlockIdentifier): Promise<RPC.StorageProof>;
     getCompiledCasm(classHash: BigNumberish): Promise<RPC.CASM_COMPILED_CONTRACT_CLASS>;
     getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    /**
+     * Helper method to get the starknet version from the block, default latest block
+     * @returns Starknet version
+     */
+    getStarknetVersion(blockIdentifier?: BlockIdentifier): Promise<string>;
     /**
      * Get the most recent accepted block hash and number
      */
@@ -4708,6 +4720,7 @@ declare class RpcProvider$1 implements ProviderInterface {
     readSpecVersion(): "0.8.1" | "0.9.0" | undefined;
     getSpecVersion(): Promise<string>;
     setUpSpecVersion(): Promise<"0.8.1" | "0.9.0">;
+    getStarknetVersion(blockIdentifier?: BlockIdentifier): Promise<string>;
     getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
     getBlock(): Promise<PendingBlock>;
     getBlock(blockIdentifier: 'pre_confirmed'): Promise<PendingBlock>;
@@ -5344,7 +5357,7 @@ declare abstract class ContractInterface {
      */
     abstract estimate(method: string, args?: ArgsOrCalldata, options?: {
         blockIdentifier?: BlockIdentifier;
-    }): Promise<EstimateFeeResponseOverhead>;
+    }): Promise<EstimateFeeResponseOverhead | PaymasterFeeEstimate>;
     /**
      * Populate transaction data for a contract method call
      *
@@ -5472,7 +5485,7 @@ declare class Contract implements ContractInterface {
         waitForTransaction: false;
     }): Promise<InvokeFunctionResponse>;
     invoke(method: string, args?: ArgsOrCalldata, options?: ExecuteOptions): Promise<InvokeFunctionResponse>;
-    estimate(method: string, args?: ArgsOrCalldata, estimateDetails?: UniversalDetails): Promise<EstimateFeeResponseOverhead>;
+    estimate(method: string, args?: ArgsOrCalldata, estimateDetails?: ExecuteOptions): Promise<EstimateFeeResponseOverhead | PaymasterFeeEstimate>;
     populate(method: string, args?: RawArgs): Call;
     parseEvents(receipt: GetTransactionReceiptResponse): ParsedEvents;
     isCairo1(): boolean;
@@ -5983,7 +5996,7 @@ declare function computeCompiledClassHash(casm: CompiledSierraCasm,
 /**
  * Used to determine which hashing algorithm to use
  */
-specVersion?: _SupportedRpcVersion): string;
+starknetVersion?: string): string;
 
 /**
  * Hashes Exports
@@ -9285,7 +9298,7 @@ declare function isSierra(contract: CairoContract | string): contract is SierraC
  * // }
  * ```
  */
-declare function extractContractHashes(payload: DeclareContractPayload, specVersion?: _SupportedRpcVersion): CompleteDeclareContractPayload;
+declare function extractContractHashes(payload: DeclareContractPayload, starknetVersion?: string): CompleteDeclareContractPayload;
 /**
  * Helper to redeclare response Cairo0 contract
  */

package/dist/index.global.js

@@ -1179,7 +1179,7 @@ var starknet = (() => {
     blake: void 0
   };
   var RPC_DEFAULT_NODES = {
-    SN_MAIN: [`https://starknet-mainnet.g.alchemy.com/starknet/version/rpc`],
+    SN_MAIN: [`https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/`],
     SN_SEPOLIA: [`https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/`]
   };
   var PAYMASTER_RPC_NODES = {
@@ -9938,8 +9938,8 @@ ${indent}}` : "}";
     }
     return computeLegacyContractClassHash(compiledContract);
   }
-  function computeCompiledClassHash(casm, specVersion) {
-    if (specVersion && compareVersions(specVersion, "0.10.0") >= 0) {
+  function computeCompiledClassHash(casm, starknetVersion) {
+    if (starknetVersion && compareVersions(starknetVersion, "0.14.1") >= 0) {
       return computeCompiledClassHashBlake(casm);
     }
     return computeCompiledClassHashPoseidon(casm);
@@ -14324,11 +14324,11 @@ ${indent}}` : "}";
     const compiledContract = isString(contract) ? parse2(contract) : contract;
     return "sierra_program" in compiledContract;
   }
-  function extractContractHashes(payload, specVersion) {
+  function extractContractHashes(payload, starknetVersion) {
     const response = { ...payload };
     if (isSierra(payload.contract)) {
       if (!payload.compiledClassHash && payload.casm) {
-        response.compiledClassHash = computeCompiledClassHash(payload.casm, specVersion);
+        response.compiledClassHash = computeCompiledClassHash(payload.casm, starknetVersion);
       }
       if (!response.compiledClassHash)
         throw new Error(
@@ -15133,6 +15133,14 @@ ${indent}}` : "}";
         block_id
       });
     }
+    /**
+     * Helper method to get the starknet version from the block, default latest block
+     * @returns Starknet version
+     */
+    async getStarknetVersion(blockIdentifier = this.blockIdentifier) {
+      const block = await this.getBlockWithTxHashes(blockIdentifier);
+      return block.starknet_version;
+    }
     /**
      * Get the most recent accepted block hash and number
      */
@@ -15722,6 +15730,14 @@ ${indent}}` : "}";
         block_id
       });
     }
+    /**
+     * Helper method to get the starknet version from the block, default latest block
+     * @returns Starknet version
+     */
+    async getStarknetVersion(blockIdentifier = this.blockIdentifier) {
+      const block = await this.getBlockWithTxHashes(blockIdentifier);
+      return block.starknet_version;
+    }
     /**
      * Get the most recent accepted block hash and number
      */
@@ -17661,6 +17677,9 @@ ${indent}}` : "}";
     setUpSpecVersion() {
       return this.channel.setUpSpecVersion();
     }
+    async getStarknetVersion(blockIdentifier) {
+      return this.channel.getStarknetVersion(blockIdentifier);
+    }
     async getNonceForAddress(contractAddress, blockIdentifier) {
       return this.channel.getNonceForAddress(contractAddress, blockIdentifier);
     }
@@ -17900,7 +17919,7 @@ ${indent}}` : "}";
       if (!contractClassIdentifier.classHash && "contract" in contractClassIdentifier) {
         const hashes = extractContractHashes(
           contractClassIdentifier,
-          await this.channel.setUpSpecVersion()
+          await this.channel.getStarknetVersion()
         );
         classHash = hashes.classHash;
       } else if (contractClassIdentifier.classHash) {
@@ -20491,7 +20510,7 @@ ${indent}}` : "}";
       const invocations = [
         {
           type: ETransactionType2.DECLARE,
-          payload: extractContractHashes(payload, await this.channel.setUpSpecVersion())
+          payload: extractContractHashes(payload, await this.channel.getStarknetVersion())
         }
       ];
       const estimateBulk = await this.estimateFeeBulk(invocations, details);
@@ -20657,7 +20676,7 @@ ${indent}}` : "}";
     async declareIfNot(payload, transactionsDetail = {}) {
       const declareContractPayload = extractContractHashes(
         payload,
-        await this.channel.setUpSpecVersion()
+        await this.channel.getStarknetVersion()
       );
       try {
         await this.getClassByHash(declareContractPayload.classHash);
@@ -20673,7 +20692,7 @@ ${indent}}` : "}";
       assert(isSierra(payload.contract), SYSTEM_MESSAGES.declareNonSierra);
       const declareContractPayload = extractContractHashes(
         payload,
-        await this.channel.setUpSpecVersion()
+        await this.channel.getStarknetVersion()
       );
       const detailsWithTip = await this.resolveDetailsWithTip(details);
       const { resourceBounds: providedResourceBounds } = details;
@@ -20983,7 +21002,7 @@ ${indent}}` : "}";
     async buildDeclarePayload(payload, details) {
       const { classHash, contract, compiledClassHash } = extractContractHashes(
         payload,
-        await this.channel.setUpSpecVersion()
+        await this.channel.getStarknetVersion()
       );
       const compressedCompiledContract = parseContract(contract);
       assert(
@@ -21333,7 +21352,7 @@ ${indent}}` : "}";
     async declare(payload) {
       const declareContractPayload = extractContractHashes(
         payload,
-        await this.channel.setUpSpecVersion()
+        await this.channel.getStarknetVersion()
       );
       const pContract = payload.contract;
       const cairo1Contract = {
@@ -21675,7 +21694,7 @@ ${indent}}` : "}";
       });
     }
     async invoke(method, args = [], options = {}) {
-      const { parseRequest = true, signature, waitForTransaction, ...RestInvokeOptions } = options;
+      const { parseRequest = true, signature, waitForTransaction, ...restInvokeOptions } = options;
       assert(this.address !== null, "contract is not connected to an address");
       const calldata = getCompiledCalldata(args, () => {
         if (parseRequest) {
@@ -21691,8 +21710,20 @@ ${indent}}` : "}";
         entrypoint: method
       };
       if (isAccount(this.providerOrAccount)) {
+        if (restInvokeOptions.paymasterDetails) {
+          const myCall = {
+            contractAddress: this.address,
+            entrypoint: method,
+            calldata: args
+          };
+          return this.providerOrAccount.executePaymasterTransaction(
+            [myCall],
+            restInvokeOptions.paymasterDetails,
+            restInvokeOptions.maxFeeInGasToken
+          );
+        }
         const result = await this.providerOrAccount.execute(invocation, {
-          ...RestInvokeOptions
+          ...restInvokeOptions
         });
         if (waitForTransaction) {
           const result2 = await this.providerOrAccount.waitForTransaction(result.transaction_hash);
@@ -21703,7 +21734,7 @@ ${indent}}` : "}";
         }
         return result;
       }
-      if (!RestInvokeOptions.nonce)
+      if (!restInvokeOptions.nonce)
         throw new Error(`Manual nonce is required when invoking a function without an account`);
       logger.warn(`Invoking ${method} without an account.`);
       return this.providerOrAccount.invokeFunction(
@@ -21712,8 +21743,8 @@ ${indent}}` : "}";
           signature
         },
         {
-          ...RestInvokeOptions,
-          nonce: RestInvokeOptions.nonce
+          ...restInvokeOptions,
+          nonce: restInvokeOptions.nonce
         }
       );
     }
@@ -21724,6 +21755,17 @@ ${indent}}` : "}";
       }
       const invocation = this.populate(method, args);
       if (isAccount(this.providerOrAccount)) {
+        if (estimateDetails.paymasterDetails) {
+          const myCall = {
+            contractAddress: this.address,
+            entrypoint: method,
+            calldata: args
+          };
+          return this.providerOrAccount.estimatePaymasterTransactionFee(
+            [myCall],
+            estimateDetails.paymasterDetails
+          );
+        }
         return this.providerOrAccount.estimateInvokeFee(invocation, estimateDetails);
       }
       throw Error("Contract must be connected to the account contract to estimate");