starknet 3.7.0 → 3.10.0

package/src/account/default.ts

@@ -1,6 +1,8 @@
 import assert from 'minimalistic-assert';
 
+import { ZERO } from '../constants';
 import { Provider } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
@@ -8,6 +10,7 @@ import {
   Call,
   EstimateFeeResponse,
   InvocationsDetails,
+  InvocationsSignerDetails,
   InvokeFunctionTransaction,
   KeyPair,
   Signature,
@@ -16,13 +19,14 @@ import {
 import { sign } from '../utils/ellipticCurve';
 import {
   computeHashOnElements,
+  feeTransactionVersion,
   getSelectorFromName,
-  transactionPrefix,
   transactionVersion,
 } from '../utils/hash';
 import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
-import { compileCalldata } from '../utils/stark';
-import { fromCallsToExecuteCalldata } from '../utils/transaction';
+import { encodeShortString } from '../utils/shortString';
+import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
 
@@ -46,23 +50,39 @@ export class Account extends Provider implements AccountInterface {
     return toHex(toBN(result[0]));
   }
 
-  public async estimateFee(calls: Call | Call[]): Promise<EstimateFeeResponse> {
+  public async estimateFee(
+    calls: Call | Call[],
+    {
+      nonce: providedNonce,
+      blockIdentifier = 'pending',
+    }: { nonce?: BigNumberish; blockIdentifier?: BlockIdentifier } = {}
+  ): Promise<EstimateFeeResponse> {
     const transactions = Array.isArray(calls) ? calls : [calls];
-    const nonce = await this.getNonce();
-    const signerDetails = {
+    const nonce = providedNonce ?? (await this.getNonce());
+    const version = toBN(feeTransactionVersion);
+
+    const signerDetails: InvocationsSignerDetails = {
       walletAddress: this.address,
       nonce: toBN(nonce),
-      maxFee: toBN('0'),
+      maxFee: ZERO,
+      version,
+      chainId: this.chainId,
     };
+
     const signature = await this.signer.signTransaction(transactions, signerDetails);
 
-    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
-    return this.fetchEndpoint('estimate_fee', undefined, {
-      contract_address: this.address,
-      entry_point_selector: getSelectorFromName('__execute__'),
-      calldata,
-      signature: bigNumberishArrayToDecimalStringArray(signature),
-    });
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
+    return this.fetchEndpoint(
+      'estimate_fee',
+      { blockIdentifier },
+      {
+        contract_address: this.address,
+        entry_point_selector: getSelectorFromName('__execute__'),
+        calldata,
+        version: toHex(version),
+        signature: bigNumberishArrayToDecimalStringArray(signature),
+      }
+    );
   }
 
   /**
@@ -80,16 +100,25 @@ export class Account extends Provider implements AccountInterface {
   ): Promise<AddTransactionResponse> {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
-    const maxFee = transactionsDetail.maxFee ?? (await this.estimateFee(transactions)).amount;
-    const signerDetails = {
+    let maxFee: BigNumberish = '0';
+    if (transactionsDetail.maxFee || transactionsDetail.maxFee === 0) {
+      maxFee = transactionsDetail.maxFee;
+    } else {
+      const estimatedFee = (await this.estimateFee(transactions, { nonce })).amount;
+      maxFee = estimatedFeeToMaxFee(estimatedFee).toString();
+    }
+
+    const signerDetails: InvocationsSignerDetails = {
       walletAddress: this.address,
       nonce,
       maxFee,
+      version: toBN(transactionVersion),
+      chainId: this.chainId,
     };
 
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
 
-    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
     return this.fetchEndpoint('add_transaction', undefined, {
       type: 'INVOKE_FUNCTION',
       contract_address: this.address,
@@ -139,7 +168,7 @@ export class Account extends Provider implements AccountInterface {
         .map(computeHashOnElements);
 
       return computeHashOnElements([
-        transactionPrefix,
+        encodeShortString('StarkNet Transaction'),
         account,
         computeHashOnElements(hashArray),
         nonce,

package/src/constants.ts

@@ -8,6 +8,16 @@ export const TWO = toBN(2);
 export const MASK_250 = TWO.pow(toBN(250)).sub(ONE); // 2 ** 250 - 1
 export const MASK_251 = TWO.pow(toBN(251));
 
+export enum StarknetChainId {
+  MAINNET = '0x534e5f4d41494e', // encodeShortString('SN_MAIN'),
+  TESTNET = '0x534e5f474f45524c49', // encodeShortString('SN_GOERLI'),
+}
+export enum TransactionHashPrefix {
+  DEPLOY = '0x6465706c6f79', // encodeShortString('deploy'),
+  INVOKE = '0x696e766f6b65', // encodeShortString('invoke'),
+  L1_HANDLER = '0x6c315f68616e646c6572', // encodeShortString('l1_handler'),
+}
+
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.

package/src/contract/default.ts

@@ -3,6 +3,7 @@ import assert from 'minimalistic-assert';
 
 import { AccountInterface } from '../account';
 import { ProviderInterface, defaultProvider } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
   AbiEntry,
@@ -45,7 +46,18 @@ function buildCall(contract: Contract, functionAbi: FunctionAbi): AsyncContractF
  */
 function buildInvoke(contract: Contract, functionAbi: FunctionAbi): AsyncContractFunction {
   return async function (...args: Array<any>): Promise<any> {
-    return contract.invoke(functionAbi.name, args);
+    const { inputs } = functionAbi;
+    const inputsLength = inputs.reduce((acc, input) => {
+      if (!/_len$/.test(input.name)) {
+        return acc + 1;
+      }
+      return acc;
+    }, 0);
+    const options = {};
+    if (inputsLength + 1 === args.length && typeof args[args.length - 1] === 'object') {
+      Object.assign(options, args.pop());
+    }
+    return contract.invoke(functionAbi.name, args, options);
   };
 }
 
@@ -528,7 +540,11 @@ export class Contract implements ContractInterface {
     }, [] as Result);
   }
 
-  public invoke(method: string, args: Array<any> = []): Promise<AddTransactionResponse> {
+  public invoke(
+    method: string,
+    args: Array<any> = [],
+    options: Overrides = {}
+  ): Promise<AddTransactionResponse> {
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
     // validate method and args
@@ -542,11 +558,6 @@ export class Contract implements ContractInterface {
       return acc;
     }, 0);
 
-    const overrides: Overrides = {};
-    if (args.length === inputsLength + 1 && Array.isArray(args[args.length - 1])) {
-      Object.assign(overrides, args.pop());
-    }
-
     if (args.length !== inputsLength) {
       throw Error(
         `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
@@ -562,31 +573,33 @@ export class Contract implements ContractInterface {
     };
     if ('execute' in this.providerOrAccount) {
       return this.providerOrAccount.execute(invocation, undefined, {
-        maxFee: overrides.maxFee,
-        nonce: overrides.nonce,
+        maxFee: options.maxFee,
+        nonce: options.nonce,
       });
     }
 
     return this.providerOrAccount.invokeFunction({
       ...invocation,
-      signature: overrides.signature || [],
+      signature: options.signature || [],
     });
   }
 
-  public async call(method: string, args: Array<any> = []): Promise<Result> {
+  public async call(
+    method: string,
+    args: Array<any> = [],
+    {
+      blockIdentifier = 'pending',
+    }: {
+      blockIdentifier?: BlockIdentifier;
+    } = {}
+  ): Promise<Result> {
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
 
     // validate method and args
     this.validateMethodAndArgs('CALL', method, args);
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    const inputsLength = inputs.length;
-    const options = {
-      blockIdentifier: null,
-    };
-    if (args.length === inputsLength + 1 && typeof args[args.length - 1] === 'object') {
-      Object.assign(options, args.pop());
-    }
+
     // compile calldata
     const calldata = this.compileCalldata(args, inputs);
     return this.providerOrAccount
@@ -596,7 +609,7 @@ export class Contract implements ContractInterface {
           calldata,
           entrypoint: method,
         },
-        options
+        { blockIdentifier }
       )
       .then((x) => this.parseResponse(method, x.result));
   }

package/src/contract/interface.ts

@@ -1,11 +1,13 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
   AddTransactionResponse,
   AsyncContractFunction,
   ContractFunction,
   Invocation,
+  Overrides,
   Result,
 } from '../types';
 
@@ -57,7 +59,13 @@ export abstract class ContractInterface {
    * @param args Array of the arguments for the call
    * @returns Result of the call as an array with key value pars
    */
-  public abstract call(method: string, args?: Array<any>): Promise<Result>;
+  public abstract call(
+    method: string,
+    args?: Array<any>,
+    options?: {
+      blockIdentifier?: BlockIdentifier;
+    }
+  ): Promise<Result>;
 
   /**
    * Invokes a method on a contract
@@ -66,7 +74,11 @@ export abstract class ContractInterface {
    * @param args Array of the arguments for the invoke
    * @returns Add Transaction Response
    */
-  public abstract invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
+  public abstract invoke(
+    method: string,
+    args?: Array<any>,
+    options?: Overrides
+  ): Promise<AddTransactionResponse>;
 
   /**
    * Calls a method on a contract
@@ -74,7 +86,13 @@ export abstract class ContractInterface {
    * @param method name of the method
    * @param args Array of the arguments for the call
    */
-  public abstract estimate(method: string, args?: Array<any>): Promise<any>;
+  public abstract estimate(
+    method: string,
+    args?: Array<any>,
+    options?: {
+      blockIdentifier?: BlockIdentifier;
+    }
+  ): Promise<any>;
 
   /**
    * Calls a method on a contract

package/src/provider/default.ts

@@ -1,6 +1,7 @@
 import axios, { AxiosRequestHeaders } from 'axios';
 import urljoin from 'url-join';
 
+import { StarknetChainId } from '../constants';
 import {
   Abi,
   AddTransactionResponse,
@@ -49,17 +50,22 @@ export class Provider implements ProviderInterface {
 
   public gatewayUrl: string;
 
+  public chainId: StarknetChainId;
+
   constructor(optionsOrProvider: ProviderOptions | Provider = { network: 'goerli-alpha' }) {
     if (optionsOrProvider instanceof Provider) {
       this.baseUrl = optionsOrProvider.baseUrl;
       this.feederGatewayUrl = optionsOrProvider.feederGatewayUrl;
       this.gatewayUrl = optionsOrProvider.gatewayUrl;
+      this.chainId =
+        optionsOrProvider.chainId ?? Provider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
     } else {
       const baseUrl =
         'baseUrl' in optionsOrProvider
           ? optionsOrProvider.baseUrl
           : Provider.getNetworkFromName(optionsOrProvider.network);
       this.baseUrl = baseUrl;
+      this.chainId = Provider.getChainIdFromBaseUrl(baseUrl);
       this.feederGatewayUrl = urljoin(baseUrl, 'feeder_gateway');
       this.gatewayUrl = urljoin(baseUrl, 'gateway');
     }
@@ -75,6 +81,19 @@ export class Provider implements ProviderInterface {
     }
   }
 
+  protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId {
+    try {
+      const url = new URL(baseUrl);
+      if (url.host.includes('mainnet.starknet.io')) {
+        return StarknetChainId.MAINNET;
+      }
+    } catch {
+      // eslint-disable-next-line no-console
+      console.error(`Could not parse baseUrl: ${baseUrl}`);
+    }
+    return StarknetChainId.TESTNET;
+  }
+
   private getFetchUrl(endpoint: keyof Endpoints) {
     const gatewayUrlEndpoints = ['add_transaction'];
 
@@ -168,14 +187,18 @@ export class Provider implements ProviderInterface {
    */
   public async callContract(
     { contractAddress, entrypoint, calldata = [] }: Call,
-    options: { blockIdentifier: BlockIdentifier } = { blockIdentifier: null }
+    { blockIdentifier = 'pending' }: { blockIdentifier?: BlockIdentifier } = {}
   ): Promise<CallContractResponse> {
-    return this.fetchEndpoint('call_contract', options, {
-      signature: [],
-      contract_address: contractAddress,
-      entry_point_selector: getSelectorFromName(entrypoint),
-      calldata,
-    });
+    return this.fetchEndpoint(
+      'call_contract',
+      { blockIdentifier },
+      {
+        signature: [],
+        contract_address: contractAddress,
+        entry_point_selector: getSelectorFromName(entrypoint),
+        calldata,
+      }
+    );
   }
 
   /**
@@ -203,7 +226,7 @@ export class Provider implements ProviderInterface {
    */
   public async getCode(
     contractAddress: string,
-    blockIdentifier: BlockIdentifier = null
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<GetCodeResponse> {
     return this.fetchEndpoint('get_code', { blockIdentifier, contractAddress });
   }
@@ -223,7 +246,7 @@ export class Provider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: number,
-    blockIdentifier: BlockIdentifier = null
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<object> {
     return this.fetchEndpoint('get_storage_at', { blockIdentifier, contractAddress, key });
   }
@@ -340,7 +363,6 @@ export class Provider implements ProviderInterface {
 
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
     let onchain = false;
-    await wait(retryInterval);
 
     while (!onchain) {
       // eslint-disable-next-line no-await-in-loop
@@ -348,9 +370,12 @@ export class Provider implements ProviderInterface {
       // eslint-disable-next-line no-await-in-loop
       const res = await this.getTransactionStatus(txHash);
 
-      if (res.tx_status === 'ACCEPTED_ON_L1' || res.tx_status === 'ACCEPTED_ON_L2') {
+      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
+      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
+
+      if (successStates.includes(res.tx_status)) {
         onchain = true;
-      } else if (res.tx_status === 'REJECTED' || res.tx_status === 'NOT_RECEIVED') {
+      } else if (errorStates.includes(res.tx_status)) {
         const message = res.tx_failure_reason
           ? `${res.tx_status}: ${res.tx_failure_reason.code}\n${res.tx_failure_reason.error_message}`
           : res.tx_status;

package/src/provider/interface.ts

@@ -1,3 +1,4 @@
+import { StarknetChainId } from '../constants';
 import type {
   AddTransactionResponse,
   Call,
@@ -21,6 +22,8 @@ export abstract class ProviderInterface {
 
   public abstract gatewayUrl: string;
 
+  public abstract chainId: StarknetChainId;
+
   /**
    * Gets the smart contract address on the goerli testnet.
    *

package/src/provider/utils.ts

@@ -43,6 +43,12 @@ type BlockIdentifierObject =
  * @returns block identifier object
  */
 export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject {
+  if (blockIdentifier === null) {
+    return { type: 'BLOCK_NUMBER', data: null };
+  }
+  if (blockIdentifier === 'pending') {
+    return { type: 'BLOCK_NUMBER', data: 'pending' };
+  }
   if (typeof blockIdentifier === 'number') {
     return { type: 'BLOCK_NUMBER', data: blockIdentifier };
   }
@@ -52,12 +58,6 @@ export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdent
   if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
     return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
   }
-  if (blockIdentifier === null) {
-    return { type: 'BLOCK_NUMBER', data: null };
-  }
-  if (blockIdentifier === 'pending') {
-    return { type: 'BLOCK_NUMBER', data: 'pending' };
-  }
   if (typeof blockIdentifier === 'string') {
     throw new Error(`Invalid block identifier: ${blockIdentifier}`);
   }
@@ -69,8 +69,7 @@ export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdent
  *
  * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
  *
- * @param blockNumber
- * @param blockHash
+ * @param blockIdentifier
  * @returns block identifier for API request
  */
 export function getFormattedBlockIdentifier(blockIdentifier: BlockIdentifier = null): string {

package/src/signer/default.ts

@@ -1,6 +1,7 @@
 import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { getStarkKey, sign } from '../utils/ellipticCurve';
-import { hashMulticall } from '../utils/hash';
+import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -25,11 +26,15 @@ export class Signer implements SignerInterface {
     }
     // now use abi to display decoded data somewhere, but as this signer is headless, we can't do that
 
-    const msgHash = hashMulticall(
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, transactionsDetail.nonce);
+
+    const msgHash = calculcateTransactionHash(
       transactionsDetail.walletAddress,
-      transactions,
-      transactionsDetail.nonce.toString(),
-      transactionsDetail.maxFee.toString()
+      transactionsDetail.version,
+      getSelectorFromName('__execute__'),
+      calldata,
+      transactionsDetail.maxFee,
+      transactionsDetail.chainId
     );
 
     return sign(this.keyPair, msgHash);

package/src/signer/ledger.ts

@@ -4,7 +4,8 @@ import TransportWebHID from '@ledgerhq/hw-transport-webhid';
 
 import { Invocation, InvocationsSignerDetails, Signature } from '../types';
 import { addHexPrefix } from '../utils/encode';
-import { hashMulticall } from '../utils/hash';
+import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -46,11 +47,15 @@ export class LedgerBlindSigner implements SignerInterface {
     transactions: Invocation[],
     transactionsDetail: InvocationsSignerDetails
   ): Promise<Signature> {
-    const msgHash = hashMulticall(
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, transactionsDetail.nonce);
+
+    const msgHash = calculcateTransactionHash(
       transactionsDetail.walletAddress,
-      transactions,
-      transactionsDetail.nonce.toString(),
-      transactionsDetail.maxFee.toString()
+      transactionsDetail.version,
+      getSelectorFromName('__execute__'),
+      calldata,
+      transactionsDetail.maxFee,
+      transactionsDetail.chainId
     );
 
     return this.sign(msgHash);

package/src/types/api.ts

@@ -75,7 +75,9 @@ export type Endpoints = {
     RESPONSE: CallContractResponse;
   };
   estimate_fee: {
-    QUERY: never;
+    QUERY: {
+      blockIdentifier: BlockIdentifier;
+    };
     REQUEST: CallContractTransaction;
     RESPONSE: EstimateFeeResponse;
   };
@@ -103,6 +105,7 @@ export type InvokeFunctionTransaction = {
   calldata?: RawCalldata;
   nonce?: BigNumberish;
   max_fee?: BigNumberish;
+  version?: BigNumberish;
 };
 
 export type InvokeFunctionTrace = {

package/src/types/lib.ts

@@ -24,6 +24,7 @@ export type Call = Omit<Invocation, 'signature'>;
 export type InvocationsDetails = {
   nonce?: BigNumberish;
   maxFee?: BigNumberish;
+  version?: BigNumberish;
 };
 
 export type Status =

package/src/types/signer.ts

@@ -1,5 +1,7 @@
+import { StarknetChainId } from '../constants';
 import { InvocationsDetails } from './lib';
 
 export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
   walletAddress: string;
+  chainId: StarknetChainId;
 }

package/src/utils/hash.ts

@@ -2,15 +2,21 @@ import BN from 'bn.js';
 import { keccak256 } from 'ethereum-cryptography/keccak';
 import assert from 'minimalistic-assert';
 
-import { CONSTANT_POINTS, FIELD_PRIME, MASK_250, ONE, ZERO } from '../constants';
-import { Call } from '../types';
+import {
+  CONSTANT_POINTS,
+  FIELD_PRIME,
+  MASK_250,
+  ONE,
+  StarknetChainId,
+  TransactionHashPrefix,
+  ZERO,
+} from '../constants';
 import { ec } from './ellipticCurve';
 import { addHexPrefix, buf2hex, utf8ToArray } from './encode';
-import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from './number';
-import { encodeShortString } from './shortString';
+import { BigNumberish, toBN, toHex } from './number';
 
-export const transactionPrefix = encodeShortString('StarkNet Transaction');
 export const transactionVersion = 0;
+export const feeTransactionVersion = toBN(2).pow(toBN(128)).add(toBN(transactionVersion));
 
 function keccakHex(value: string): string {
   return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
@@ -64,27 +70,65 @@ export function computeHashOnElements(data: BigNumberish[]) {
   return [...data, data.length].reduce((x, y) => pedersen([x, y]), 0).toString();
 }
 
-export function hashMulticall(
-  account: string,
-  transactions: Call[],
-  nonce: string,
-  maxFee: string
-) {
-  const hashArray = transactions
-    .map(({ contractAddress, entrypoint, calldata }) => [
-      contractAddress,
-      getSelectorFromName(entrypoint),
-      computeHashOnElements(calldata || []),
-    ])
-    .map(bigNumberishArrayToDecimalStringArray)
-    .map(computeHashOnElements);
+// following implementation is based on this python implementation:
+// https://github.com/starkware-libs/cairo-lang/blob/b614d1867c64f3fb2cf4a4879348cfcf87c3a5a7/src/starkware/starknet/core/os/transaction_hash/transaction_hash.py
 
-  return computeHashOnElements([
-    transactionPrefix,
-    account,
-    computeHashOnElements(hashArray),
-    nonce,
+export function calculateTransactionHashCommon(
+  txHashPrefix: TransactionHashPrefix,
+  version: BigNumberish,
+  contractAddress: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId,
+  additionalData: BigNumberish[] = []
+): string {
+  const calldataHash = computeHashOnElements(calldata);
+  const dataToHash = [
+    txHashPrefix,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldataHash,
     maxFee,
-    transactionVersion,
-  ]);
+    chainId,
+    ...additionalData,
+  ];
+  return computeHashOnElements(dataToHash);
+}
+
+export function calculateDeployTransactionHash(
+  contractAddress: BigNumberish,
+  constructorCalldata: BigNumberish[],
+  version: BigNumberish,
+  chainId: StarknetChainId
+): string {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.DEPLOY,
+    version,
+    contractAddress,
+    getSelectorFromName('constructor'),
+    constructorCalldata,
+    ZERO,
+    chainId
+  );
+}
+
+export function calculcateTransactionHash(
+  contractAddress: BigNumberish,
+  version: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId
+): string {
+  return calculateTransactionHashCommon(
+    TransactionHashPrefix.INVOKE,
+    version,
+    contractAddress,
+    entryPointSelector,
+    calldata,
+    maxFee,
+    chainId
+  );
 }