starknet 3.8.0 → 3.10.1

package/signer/ledger.js

@@ -141,6 +141,7 @@ var hw_app_eth_1 = __importDefault(require('@ledgerhq/hw-app-eth'));
 var hw_transport_webhid_1 = __importDefault(require('@ledgerhq/hw-transport-webhid'));
 var encode_1 = require('../utils/encode');
 var hash_1 = require('../utils/hash');
+var transaction_1 = require('../utils/transaction');
 var typedData_1 = require('../utils/typedData');
 function hexZeroPad(hash, length) {
   var value = hash;
@@ -200,13 +201,19 @@ var LedgerBlindSigner = /** @class */ (function () {
   };
   LedgerBlindSigner.prototype.signTransaction = function (transactions, transactionsDetail) {
     return __awaiter(this, void 0, void 0, function () {
-      var msgHash;
+      var calldata, msgHash;
       return __generator(this, function (_a) {
-        msgHash = (0, hash_1.hashMulticall)(
-          transactionsDetail.walletAddress,
+        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(
           transactions,
-          transactionsDetail.nonce.toString(),
-          transactionsDetail.maxFee.toString()
+          transactionsDetail.nonce
+        );
+        msgHash = (0, hash_1.calculcateTransactionHash)(
+          transactionsDetail.walletAddress,
+          transactionsDetail.version,
+          (0, hash_1.getSelectorFromName)('__execute__'),
+          calldata,
+          transactionsDetail.maxFee,
+          transactionsDetail.chainId
         );
         return [2 /*return*/, this.sign(msgHash)];
       });

package/src/account/default.ts

@@ -1,6 +1,7 @@
 import assert from 'minimalistic-assert';
 
-import { Provider } from '../provider';
+import { ZERO } from '../constants';
+import { Provider, ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
 import { Signer, SignerInterface } from '../signer';
 import {
@@ -9,6 +10,7 @@ import {
   Call,
   EstimateFeeResponse,
   InvocationsDetails,
+  InvocationsSignerDetails,
   InvokeFunctionTransaction,
   KeyPair,
   Signature,
@@ -17,22 +19,27 @@ 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';
 
 export class Account extends Provider implements AccountInterface {
   public address: string;
 
-  private signer: SignerInterface;
+  public signer: SignerInterface;
 
-  constructor(provider: Provider, address: string, keyPairOrSigner: KeyPair | SignerInterface) {
+  constructor(
+    provider: ProviderInterface,
+    address: string,
+    keyPairOrSigner: KeyPair | SignerInterface
+  ) {
     super(provider);
     this.signer =
       'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new Signer(keyPairOrSigner as KeyPair);
@@ -56,14 +63,19 @@ export class Account extends Provider implements AccountInterface {
   ): Promise<EstimateFeeResponse> {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = providedNonce ?? (await this.getNonce());
-    const signerDetails = {
+    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()];
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
     return this.fetchEndpoint(
       'estimate_fee',
       { blockIdentifier },
@@ -71,6 +83,7 @@ export class Account extends Provider implements AccountInterface {
         contract_address: this.address,
         entry_point_selector: getSelectorFromName('__execute__'),
         calldata,
+        version: toHex(version),
         signature: bigNumberishArrayToDecimalStringArray(signature),
       }
     );
@@ -91,17 +104,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, { nonce })).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,
@@ -151,7 +172,7 @@ export class Account extends Provider implements AccountInterface {
         .map(computeHashOnElements);
 
       return computeHashOnElements([
-        transactionPrefix,
+        encodeShortString('StarkNet Transaction'),
         account,
         computeHashOnElements(hashArray),
         nonce,
@@ -233,7 +254,8 @@ export class Account extends Provider implements AccountInterface {
   }
 
   /**
-   * Verify a signature of a JSON object
+   * Verify a signature of a given hash
+   * @warning This method is not recommended, use verifyMessage instead
    *
    * @param hash - JSON object to be verified
    * @param signature - signature of the JSON object
@@ -257,8 +279,7 @@ export class Account extends Provider implements AccountInterface {
   }
 
   /**
-   * Verify a signature of a given hash
-   * @warning This method is not recommended, use verifyMessage instead
+   * Verify a signature of a JSON object
    *
    * @param hash - hash to be verified
    * @param signature - signature of the hash

package/src/account/interface.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { SignerInterface } from '../signer';
 import {
   Abi,
   AddTransactionResponse,
@@ -15,6 +16,8 @@ import { TypedData } from '../utils/typedData/types';
 export abstract class AccountInterface extends ProviderInterface {
   public abstract address: string;
 
+  public abstract signer: SignerInterface;
+
   /**
    * Deploys a given compiled contract (json) to starknet
    *

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/contractFactory.ts

@@ -1,7 +1,7 @@
 import assert from 'minimalistic-assert';
 
-import { Account } from '../account';
-import { Provider, defaultProvider } from '../provider';
+import { AccountInterface } from '../account';
+import { ProviderInterface, defaultProvider } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
 import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
@@ -11,11 +11,11 @@ export class ContractFactory {
 
   compiledContract: CompiledContract;
 
-  providerOrAccount: Provider | Account;
+  providerOrAccount: ProviderInterface | AccountInterface;
 
   constructor(
     compiledContract: CompiledContract,
-    providerOrAccount: Provider | Account = defaultProvider,
+    providerOrAccount: ProviderInterface | AccountInterface = defaultProvider,
     abi: Abi = compiledContract.abi // abi can be different from the deployed contract ie for proxy contracts
   ) {
     this.abi = abi;
@@ -59,7 +59,7 @@ export class ContractFactory {
    *
    * @param providerOrAccount - new Provider or Account to attach to
    */
-  connect(providerOrAccount: Provider | Account): ContractFactory {
+  connect(providerOrAccount: ProviderInterface | AccountInterface): ContractFactory {
     this.providerOrAccount = providerOrAccount;
     return this;
   }

package/src/contract/default.ts

@@ -46,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);
   };
 }
 
@@ -338,7 +349,7 @@ export class Contract implements ContractInterface {
       if (member.type === 'felt') {
         return acc + 1;
       }
-      return acc + this.structMemberNum(member.type);
+      return acc + this.calculateStructMembers(member.type);
     }, 0);
   }
 

package/src/index.ts

@@ -15,6 +15,7 @@ export * as encode from './utils/encode';
 export * as hash from './utils/hash';
 export * as json from './utils/json';
 export * as number from './utils/number';
+export * as transaction from './utils/transaction';
 export * as stark from './utils/stark';
 export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';

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,24 @@ export class Provider implements ProviderInterface {
 
   public gatewayUrl: string;
 
-  constructor(optionsOrProvider: ProviderOptions | Provider = { network: 'goerli-alpha' }) {
-    if (optionsOrProvider instanceof Provider) {
+  public chainId: StarknetChainId;
+
+  constructor(
+    optionsOrProvider: ProviderOptions | ProviderInterface = { network: 'goerli-alpha' }
+  ) {
+    if (optionsOrProvider instanceof ProviderInterface) {
       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 +83,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'];
 

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/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

@@ -105,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
+  );
 }

package/src/utils/stark.ts

@@ -1,10 +1,11 @@
+import BN from 'bn.js';
 import { gzip } from 'pako';
 
 import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 import { genKeyPair, getStarkKey } from './ellipticCurve';
 import { addHexPrefix, btoaUniversal } from './encode';
 import { stringify } from './json';
-import { toBN } from './number';
+import { BigNumberish, toBN } from './number';
 
 /**
  * Function to compress compiled cairo program
@@ -48,3 +49,9 @@ export function compileCalldata(args: RawArgs): Calldata {
     return toBN(value).toString();
   });
 }
+
+export function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead: number = 0.15): BN {
+  // BN can only handle Integers, so we need to do all calulations with integers
+  const overHeadPercent = Math.round((1 + overhead) * 100);
+  return toBN(estimatedFee).mul(toBN(overHeadPercent)).div(toBN(100));
+}

package/src/utils/transaction.ts

@@ -47,3 +47,10 @@ export const fromCallsToExecuteCalldata = (calls: Call[]): string[] => {
     ...calldata,
   ];
 };
+
+export const fromCallsToExecuteCalldataWithNonce = (
+  calls: Call[],
+  nonce: BigNumberish
+): string[] => {
+  return [...fromCallsToExecuteCalldata(calls), toBN(nonce).toString()];
+};

package/types/api.d.ts

@@ -101,6 +101,7 @@ export declare type InvokeFunctionTransaction = {
   calldata?: RawCalldata;
   nonce?: BigNumberish;
   max_fee?: BigNumberish;
+  version?: BigNumberish;
 };
 export declare type InvokeFunctionTrace = {
   caller_address: string;

package/types/lib.d.ts

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

package/types/signer.d.ts

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

package/utils/hash.d.ts

@@ -1,9 +1,9 @@
 import BN from 'bn.js';
 
-import { Call } from '../types';
+import { StarknetChainId, TransactionHashPrefix } from '../constants';
 import { BigNumberish } from './number';
-export declare const transactionPrefix: string;
 export declare const transactionVersion = 0;
+export declare const feeTransactionVersion: BN;
 /**
  * Function to get the starknet keccak hash from a string
  *
@@ -22,9 +22,27 @@ export declare function starknetKeccak(value: string): BN;
 export declare function getSelectorFromName(funcName: string): string;
 export declare function pedersen(input: [BigNumberish, BigNumberish]): string;
 export declare function computeHashOnElements(data: BigNumberish[]): string;
-export declare function hashMulticall(
-  account: string,
-  transactions: Call[],
-  nonce: string,
-  maxFee: string
+export declare function calculateTransactionHashCommon(
+  txHashPrefix: TransactionHashPrefix,
+  version: BigNumberish,
+  contractAddress: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId,
+  additionalData?: BigNumberish[]
+): string;
+export declare function calculateDeployTransactionHash(
+  contractAddress: BigNumberish,
+  constructorCalldata: BigNumberish[],
+  version: BigNumberish,
+  chainId: StarknetChainId
+): string;
+export declare function calculcateTransactionHash(
+  contractAddress: BigNumberish,
+  version: BigNumberish,
+  entryPointSelector: BigNumberish,
+  calldata: BigNumberish[],
+  maxFee: BigNumberish,
+  chainId: StarknetChainId
 ): string;