starknet 4.6.0 → 4.7.0

package/src/account/interface.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import {
   Abi,
@@ -92,5 +93,5 @@ export abstract class AccountInterface extends ProviderInterface {
    */
   public abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
 
-  public abstract getNonce(): Promise<string>;
+  public abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
 }

package/src/contract/contractFactory.ts

@@ -3,7 +3,6 @@ import assert from 'minimalistic-assert';
 import { AccountInterface } from '../account';
 import { ProviderInterface, defaultProvider } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
-import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
 
 export class ContractFactory {
@@ -32,7 +31,7 @@ export class ContractFactory {
    */
   public async deploy(
     constructorCalldata?: RawCalldata,
-    addressSalt?: BigNumberish
+    addressSalt?: string | undefined
   ): Promise<Contract> {
     const { contract_address, transaction_hash } = await this.providerOrAccount.deployContract({
       contract: this.compiledContract,

package/src/contract/default.ts

@@ -9,10 +9,10 @@ import {
   AbiEntry,
   Args,
   AsyncContractFunction,
+  Call,
   Calldata,
   ContractFunction,
   FunctionAbi,
-  Invocation,
   InvokeFunctionResponse,
   Overrides,
   ParsedStruct,
@@ -125,7 +125,7 @@ export class Contract implements ContractInterface {
     address: string,
     providerOrAccount: ProviderInterface | AccountInterface = defaultProvider
   ) {
-    this.address = address;
+    this.address = address.toLowerCase();
     this.providerOrAccount = providerOrAccount;
     this.abi = abi;
     this.structs = abi
@@ -578,13 +578,22 @@ export class Contract implements ContractInterface {
       });
     }
 
+    if (!options.nonce) {
+      throw new Error(`Nonce is required when invoking a function without an account`);
+    }
+
     // eslint-disable-next-line no-console
     console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
 
-    return this.providerOrAccount.invokeFunction({
-      ...invocation,
-      signature: options.signature || [],
-    });
+    return this.providerOrAccount.invokeFunction(
+      {
+        ...invocation,
+        signature: options.signature || [],
+      },
+      {
+        nonce: options.nonce,
+      }
+    );
   }
 
   public async call(
@@ -630,13 +639,12 @@ export class Contract implements ContractInterface {
     throw Error('Contract must be connected to the account contract to estimate');
   }
 
-  public populate(method: string, args: Array<any> = []): Invocation {
+  public populate(method: string, args: Array<any> = []): Call {
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
     return {
       contractAddress: this.address,
       entrypoint: method,
       calldata: this.compileCalldata(args, inputs),
-      signature: [],
     };
   }
 }

package/src/provider/default.ts

@@ -13,7 +13,7 @@ import {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -63,10 +63,17 @@ export class Provider implements ProviderInterface {
 
   public async getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier = 'pending',
-    invocationDetails: InvocationsDetails = {}
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
-    return this.provider.getEstimateFee(invocation, blockIdentifier, invocationDetails);
+    return this.provider.getEstimateFee(invocation, invocationDetails, blockIdentifier);
+  }
+
+  public async getNonce(
+    contractAddress: string,
+    blockIdentifier?: BlockIdentifier
+  ): Promise<BigNumberish> {
+    return this.provider.getNonce(contractAddress, blockIdentifier);
   }
 
   public async getStorageAt(
@@ -94,7 +101,7 @@ export class Provider implements ProviderInterface {
 
   public async invokeFunction(
     functionInvocation: Invocation,
-    details: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse> {
     return this.provider.invokeFunction(functionInvocation, details);
   }

package/src/provider/interface.ts

@@ -13,7 +13,7 @@ import type {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
@@ -69,6 +69,17 @@ export abstract class ProviderInterface {
     blockIdentifier?: BlockIdentifier
   ): Promise<ContractClass>;
 
+  /**
+   * Gets the nonce of a contract with respect to a specific block
+   *
+   * @param contractAddress - contract address
+   * @returns the hex nonce
+   */
+  public abstract getNonce(
+    contractAddress: string,
+    blockIdentifier?: BlockIdentifier
+  ): Promise<BigNumberish>;
+
   /**
    * Gets the contract's storage variable at a specific key.
    *
@@ -141,7 +152,7 @@ export abstract class ProviderInterface {
    */
   public abstract invokeFunction(
     invocation: Invocation,
-    details?: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse>;
 
   /**
@@ -160,8 +171,8 @@ export abstract class ProviderInterface {
    */
   public abstract getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier,
-    details?: InvocationsDetails
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier
   ): Promise<EstimateFeeResponse>;
 
   /**

package/src/provider/rpc.ts

@@ -12,7 +12,7 @@ import {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import { RPC } from '../types/api';
@@ -31,7 +31,10 @@ import { randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
 import { Block, BlockIdentifier } from './utils';
 
-export type RpcProviderOptions = { nodeUrl: string };
+export type RpcProviderOptions = {
+  nodeUrl: string;
+  retries?: number;
+};
 
 export class RpcProvider implements ProviderInterface {
   public nodeUrl: string;
@@ -41,9 +44,12 @@ export class RpcProvider implements ProviderInterface {
 
   private responseParser = new RPCResponseParser();
 
+  private retries: number;
+
   constructor(optionsOrProvider: RpcProviderOptions) {
-    const { nodeUrl } = optionsOrProvider;
+    const { nodeUrl, retries } = optionsOrProvider;
     this.nodeUrl = nodeUrl;
+    this.retries = retries || 200;
 
     this.getChainId().then((chainId) => {
       this.chainId = chainId;
@@ -67,13 +73,13 @@ export class RpcProvider implements ProviderInterface {
 
   protected async fetchEndpoint<T extends keyof RPC.Methods>(
     method: T,
-    request?: RPC.Methods[T]['REQUEST']
-  ): Promise<RPC.Methods[T]['RESPONSE']> {
+    params?: RPC.Methods[T]['params']
+  ): Promise<RPC.Methods[T]['result']> {
     try {
-      const rawResult = await this.fetch(method, request);
+      const rawResult = await this.fetch(method, params);
       const { error, result } = await rawResult.json();
       this.errorHandler(error);
-      return result as RPC.Methods[T]['RESPONSE'];
+      return result as RPC.Methods[T]['result'];
     } catch (error: any) {
       this.errorHandler(error?.response?.data);
       throw error;
@@ -99,27 +105,37 @@ export class RpcProvider implements ProviderInterface {
   public async getBlockWithTxHashes(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxHashesResponse> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxHashes', [block.identifier]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getBlockWithTxHashes', { block_id });
   }
 
   public async getBlockWithTxs(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxs> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxs', [block.identifier]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getBlockWithTxs', { block_id });
   }
 
   public async getClassHashAt(
     blockIdentifier: BlockIdentifier,
     contractAddress: RPC.ContractAddress
   ): Promise<RPC.Felt> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getClassHashAt', [block.identifier, contractAddress]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getClassHashAt', {
+      block_id,
+      contract_address: contractAddress,
+    });
   }
 
-  public async getNonce(contractAddress: string): Promise<any> {
-    return this.fetchEndpoint('starknet_getNonce', [contractAddress]);
+  public async getNonce(
+    contractAddress: string,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<RPC.Nonce> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getNonce', {
+      contract_address: contractAddress,
+      block_id,
+    });
   }
 
   public async getPendingTransactions(): Promise<RPC.PendingTransactions> {
@@ -131,8 +147,8 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public async getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getStateUpdate', [block.identifier]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getStateUpdate', { block_id });
   }
 
   public async getStorageAt(
@@ -141,49 +157,50 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toHex(toBN(key));
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getStorageAt', [
-      contractAddress,
-      parsedKey,
-      block.identifier,
-    ]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getStorageAt', {
+      contract_address: contractAddress,
+      key: parsedKey,
+      block_id,
+    });
   }
 
   // Methods from Interface
-  public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
+  public async getTransaction(txHash: string): Promise<GetTransactionResponse> {
     return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
   }
 
-  public async getTransactionByHash(
-    txHash: BigNumberish
-  ): Promise<RPC.GetTransactionByHashResponse> {
-    return this.fetchEndpoint('starknet_getTransactionByHash', [txHash]);
+  public async getTransactionByHash(txHash: string): Promise<RPC.GetTransactionByHashResponse> {
+    return this.fetchEndpoint('starknet_getTransactionByHash', { transaction_hash: txHash });
   }
 
   public async getTransactionByBlockIdAndIndex(
     blockIdentifier: BlockIdentifier,
     index: number
   ): Promise<RPC.GetTransactionByBlockIdAndIndex> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getTransactionByBlockIdAndIndex', [
-      block.identifier,
-      index,
-    ]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getTransactionByBlockIdAndIndex', { block_id, index });
   }
 
-  public async getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse> {
-    return this.fetchEndpoint('starknet_getTransactionReceipt', [txHash]).then(
+  public async getTransactionReceipt(txHash: string): Promise<GetTransactionReceiptResponse> {
+    return this.fetchEndpoint('starknet_getTransactionReceipt', { transaction_hash: txHash }).then(
       this.responseParser.parseGetTransactionReceiptResponse
     );
   }
 
   public async getClass(classHash: RPC.Felt): Promise<RPC.ContractClass> {
-    return this.fetchEndpoint('starknet_getClass', [classHash]);
+    return this.fetchEndpoint('starknet_getClass', { class_hash: classHash });
   }
 
-  public async getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getClassAt', [block.identifier, contractAddress]);
+  public async getClassAt(
+    contractAddress: string,
+    blockIdentifier: BlockIdentifier
+  ): Promise<RPC.ContractClass> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getClassAt', {
+      block_id,
+      contract_address: contractAddress,
+    });
   }
 
   public async getCode(
@@ -195,20 +212,20 @@ export class RpcProvider implements ProviderInterface {
 
   public async getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier = 'pending',
-    invocationDetails: InvocationsDetails = {}
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
     const block_id = new Block(blockIdentifier).identifier;
-    return this.fetchEndpoint('starknet_estimateFee', [
-      {
+    return this.fetchEndpoint('starknet_estimateFee', {
+      request: {
         contract_address: invocation.contractAddress,
-        entry_point_selector: getSelectorFromName(invocation.entrypoint),
         calldata: parseCalldata(invocation.calldata),
         signature: bigNumberishArrayToHexadecimalStringArray(invocation.signature || []),
         version: toHex(toBN(invocationDetails?.version || 0)),
+        max_fee: toHex(toBN(invocationDetails?.maxFee || 0)),
       },
       block_id,
-    ]).then(this.responseParser.parseFeeEstimateResponse);
+    }).then(this.responseParser.parseFeeEstimateResponse);
   }
 
   public async declareContract({
@@ -217,14 +234,14 @@ export class RpcProvider implements ProviderInterface {
   }: DeclareContractPayload): Promise<DeclareContractResponse> {
     const contractDefinition = parseContract(contract);
 
-    return this.fetchEndpoint('starknet_addDeclareTransaction', [
-      {
+    return this.fetchEndpoint('starknet_addDeclareTransaction', {
+      contract_class: {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
         abi: contractDefinition.abi, // rpc 2.0
       },
-      toHex(toBN(version || 0)),
-    ]).then(this.responseParser.parseDeclareContractResponse);
+      version: toHex(toBN(version || 0)),
+    });
   }
 
   public async deployContract({
@@ -234,31 +251,30 @@ export class RpcProvider implements ProviderInterface {
   }: DeployContractPayload): Promise<DeployContractResponse> {
     const contractDefinition = parseContract(contract);
 
-    return this.fetchEndpoint('starknet_addDeployTransaction', [
-      addressSalt ?? randomAddress(),
-      bigNumberishArrayToHexadecimalStringArray(constructorCalldata ?? []),
-      {
+    return this.fetchEndpoint('starknet_addDeployTransaction', {
+      contract_address_salt: addressSalt ?? randomAddress(),
+      constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata ?? []),
+      contract_definition: {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
         abi: contractDefinition.abi, // rpc 2.0
       },
-    ]).then(this.responseParser.parseDeployContractResponse);
+    });
   }
 
   public async invokeFunction(
     functionInvocation: Invocation,
-    details: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse> {
-    return this.fetchEndpoint('starknet_addInvokeTransaction', [
-      {
+    return this.fetchEndpoint('starknet_addInvokeTransaction', {
+      function_invocation: {
         contract_address: functionInvocation.contractAddress,
-        entry_point_selector: getSelectorFromName(functionInvocation.entrypoint),
         calldata: parseCalldata(functionInvocation.calldata),
       },
-      bigNumberishArrayToHexadecimalStringArray(functionInvocation.signature || []),
-      toHex(toBN(details.maxFee || 0)),
-      toHex(toBN(details.version || 0)),
-    ]).then(this.responseParser.parseInvokeFunctionResponse);
+      signature: bigNumberishArrayToHexadecimalStringArray(functionInvocation.signature || []),
+      max_fee: toHex(toBN(details.maxFee || 0)),
+      version: toHex(toBN(details.version || 0)),
+    });
   }
 
   // Methods from Interface
@@ -267,29 +283,29 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<CallContractResponse> {
     const block_id = new Block(blockIdentifier).identifier;
-    const result = await this.fetchEndpoint('starknet_call', [
-      {
+    const result = await this.fetchEndpoint('starknet_call', {
+      request: {
         contract_address: call.contractAddress,
         entry_point_selector: getSelectorFromName(call.entrypoint),
         calldata: parseCalldata(call.calldata),
       },
       block_id,
-    ]);
+    });
 
     return this.responseParser.parseCallContractResponse(result);
   }
 
   public async traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace> {
-    return this.fetchEndpoint('starknet_traceTransaction', [transactionHash]);
+    return this.fetchEndpoint('starknet_traceTransaction', { transaction_hash: transactionHash });
   }
 
   public async traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces> {
-    return this.fetchEndpoint('starknet_traceBlockTransactions', [blockHash]);
+    return this.fetchEndpoint('starknet_traceBlockTransactions', { block_hash: blockHash });
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
+  public async waitForTransaction(txHash: string, retryInterval: number = 8000) {
+    let { retries } = this;
     let onchain = false;
-    let retries = 200;
 
     while (!onchain) {
       const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
@@ -315,7 +331,7 @@ export class RpcProvider implements ProviderInterface {
         }
 
         if (retries === 0) {
-          throw error;
+          throw new Error('waitForTransaction timedout with retries');
         }
       }
 
@@ -335,8 +351,8 @@ export class RpcProvider implements ProviderInterface {
   public async getTransactionCount(
     blockIdentifier: BlockIdentifier
   ): Promise<RPC.GetTransactionCountResponse> {
-    const block = new Block(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockTransactionCount', [block.identifier]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getBlockTransactionCount', { block_id });
   }
 
   /**
@@ -366,6 +382,6 @@ export class RpcProvider implements ProviderInterface {
    * @returns events and the pagination of the events
    */
   public async getEvents(eventFilter: RPC.EventFilter): Promise<RPC.GetEventsResponse> {
-    return this.fetchEndpoint('starknet_getEvents', [eventFilter]);
+    return this.fetchEndpoint('starknet_getEvents', { filter: eventFilter });
   }
 }

package/src/provider/sequencer.ts

@@ -14,7 +14,7 @@ import {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import {
@@ -234,6 +234,13 @@ export class SequencerProvider implements ProviderInterface {
     );
   }
 
+  public async getNonce(
+    contractAddress: string,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<BigNumberish> {
+    return this.fetchEndpoint('get_nonce', { contractAddress, blockIdentifier });
+  }
+
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
@@ -272,16 +279,16 @@ export class SequencerProvider implements ProviderInterface {
 
   public async invokeFunction(
     functionInvocation: Invocation,
-    details: InvocationsDetails
+    details: InvocationsDetailsWithNonce
   ): Promise<InvokeFunctionResponse> {
     return this.fetchEndpoint('add_transaction', undefined, {
       type: 'INVOKE_FUNCTION',
       contract_address: functionInvocation.contractAddress,
-      entry_point_selector: getSelectorFromName(functionInvocation.entrypoint),
       calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
       signature: bigNumberishArrayToDecimalStringArray(functionInvocation.signature ?? []),
+      nonce: toHex(toBN(details.nonce)),
       max_fee: toHex(toBN(details.maxFee || 0)),
-      version: toHex(toBN(details.version || 0)),
+      version: toHex(toBN(details.version || 1)),
     }).then(this.responseParser.parseInvokeFunctionResponse);
   }
 
@@ -316,18 +323,19 @@ export class SequencerProvider implements ProviderInterface {
 
   public async getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier = 'pending',
-    invocationDetails: InvocationsDetails = {}
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
     return this.fetchEndpoint(
       'estimate_fee',
       { blockIdentifier },
       {
+        type: 'INVOKE_FUNCTION',
         contract_address: invocation.contractAddress,
-        entry_point_selector: getSelectorFromName(invocation.entrypoint),
         calldata: invocation.calldata ?? [],
         signature: bigNumberishArrayToDecimalStringArray(invocation.signature || []),
-        version: toHex(toBN(invocationDetails?.version || 0)),
+        version: toHex(toBN(invocationDetails?.version || 1)),
+        nonce: toHex(toBN(invocationDetails.nonce)),
       }
     ).then(this.responseParser.parseFeeEstimateResponse);
   }

package/src/signer/default.ts

@@ -1,7 +1,7 @@
-import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
+import { Abi, Call, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { genKeyPair, getStarkKey, sign } from '../utils/ellipticCurve';
-import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
-import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
+import { calculateTransactionHash } from '../utils/hash';
+import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -17,7 +17,7 @@ export class Signer implements SignerInterface {
   }
 
   public async signTransaction(
-    transactions: Invocation[],
+    transactions: Call[],
     transactionsDetail: InvocationsSignerDetails,
     abis?: Abi[]
   ): Promise<Signature> {
@@ -26,15 +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 calldata = fromCallsToExecuteCalldataWithNonce(transactions, transactionsDetail.nonce);
+    const calldata = fromCallsToExecuteCalldata(transactions);
 
-    const msgHash = calculcateTransactionHash(
+    const msgHash = calculateTransactionHash(
       transactionsDetail.walletAddress,
       transactionsDetail.version,
-      getSelectorFromName('__execute__'),
       calldata,
       transactionsDetail.maxFee,
-      transactionsDetail.chainId
+      transactionsDetail.chainId,
+      transactionsDetail.nonce
     );
 
     return sign(this.keyPair, msgHash);

package/src/signer/interface.ts

@@ -1,4 +1,4 @@
-import { Abi, Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { Abi, Call, InvocationsSignerDetails, Signature } from '../types';
 import { TypedData } from '../utils/typedData';
 
 export abstract class SignerInterface {
@@ -33,7 +33,7 @@ export abstract class SignerInterface {
    * @returns signature
    */
   public abstract signTransaction(
-    transactions: Invocation[],
+    transactions: Call[],
     transactionsDetail: InvocationsSignerDetails,
     abis?: Abi[]
   ): Promise<Signature>;