starknet 4.5.0 → 4.7.0

package/src/provider/rpc.ts

@@ -12,7 +12,7 @@ import {
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
-  InvocationsDetails,
+  InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
 import { RPC } from '../types/api';
@@ -29,90 +29,126 @@ import { parseCalldata, parseContract, wait } from '../utils/provider';
 import { RPCResponseParser } from '../utils/responseParser/rpc';
 import { randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier, BlockIdentifierClass } from './utils';
+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;
 
+  // from interface
   public chainId!: StarknetChainId;
 
   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;
     });
   }
 
+  public fetch(method: any, params: any): Promise<any> {
+    return fetch(this.nodeUrl, {
+      method: 'POST',
+      body: stringify({ method, jsonrpc: '2.0', params, id: 0 }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  protected errorHandler(error: any) {
+    if (error) {
+      const { code, message } = error;
+      throw new Error(`${code}: ${message}`);
+    }
+  }
+
   protected async fetchEndpoint<T extends keyof RPC.Methods>(
     method: T,
-    request?: RPC.Methods[T]['REQUEST']
-  ): Promise<RPC.Methods[T]['RESPONSE']> {
-    const requestData = {
-      method,
-      jsonrpc: '2.0',
-      params: request,
-      id: 0,
-    };
-
+    params?: RPC.Methods[T]['params']
+  ): Promise<RPC.Methods[T]['result']> {
     try {
-      const rawResult = await fetch(this.nodeUrl, {
-        method: 'POST',
-        body: stringify(requestData),
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
+      const rawResult = await this.fetch(method, params);
       const { error, result } = await rawResult.json();
-      if (error) {
-        const { code, message } = error;
-        throw new Error(`${code}: ${message}`);
-      } else {
-        return result as RPC.Methods[T]['RESPONSE'];
-      }
+      this.errorHandler(error);
+      return result as RPC.Methods[T]['result'];
     } catch (error: any) {
-      const data = error?.response?.data;
-      if (data?.message) {
-        throw new Error(`${data.code}: ${data.message}`);
-      }
+      this.errorHandler(error?.response?.data);
       throw error;
     }
   }
 
-  public async getChainId(): Promise<StarknetChainId> {
+  // Methods from Interface
+  public async getChainId(): Promise<any> {
     return this.fetchEndpoint('starknet_chainId');
   }
 
-  // Common Interface
+  // Methods from Interface
   public async getBlock(blockIdentifier: BlockIdentifier = 'pending'): Promise<GetBlockResponse> {
     return this.getBlockWithTxHashes(blockIdentifier).then(
       this.responseParser.parseGetBlockResponse
     );
   }
 
+  public async getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber> {
+    return this.fetchEndpoint('starknet_blockHashAndNumber');
+  }
+
   public async getBlockWithTxHashes(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxHashesResponse> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxHashes', [
-      blockIdentifierGetter.getIdentifier(),
-    ]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getBlockWithTxHashes', { block_id });
   }
 
   public async getBlockWithTxs(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxs> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()]);
+    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_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> {
+    return this.fetchEndpoint('starknet_pendingTransactions');
+  }
+
+  public async getProtocolVersion(): Promise<Error> {
+    throw new Error('Pathfinder does not implement this rpc 0.1.0 method');
+  }
+
+  public async getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getStateUpdate', { block_id });
   }
 
   public async getStorageAt(
@@ -121,61 +157,75 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toHex(toBN(key));
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getStorageAt', [
-      contractAddress,
-      parsedKey,
-      blockIdentifierGetter.getIdentifier(),
-    ]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getStorageAt', {
+      contract_address: contractAddress,
+      key: parsedKey,
+      block_id,
+    });
   }
 
-  // common interface
-  public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
+  // Methods from Interface
+  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> {
-    return this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, 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 getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getClassAt', [
-      blockIdentifierGetter.getIdentifier(),
-      contractAddress,
-    ]);
+  public async getClass(classHash: RPC.Felt): Promise<RPC.ContractClass> {
+    return this.fetchEndpoint('starknet_getClass', { class_hash: classHash });
+  }
+
+  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(
+    _contractAddress: string,
+    _blockIdentifier?: BlockIdentifier
+  ): Promise<GetCodeResponse> {
+    throw new Error('RPC 0.1.0 does not implement getCode function');
   }
 
   public async getEstimateFee(
     invocation: Invocation,
-    blockIdentifier: BlockIdentifier = 'pending',
-    invocationDetails: InvocationsDetails = {}
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
-    return this.fetchEndpoint('starknet_estimateFee', [
-      {
+    const block_id = new Block(blockIdentifier).identifier;
+    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)),
       },
-      blockIdentifier,
-    ]).then(this.responseParser.parseFeeEstimateResponse);
+      block_id,
+    }).then(this.responseParser.parseFeeEstimateResponse);
   }
 
   public async declareContract({
@@ -184,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({
@@ -201,59 +251,61 @@ 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
   public async callContract(
     call: Call,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<CallContractResponse> {
-    const result = await this.fetchEndpoint('starknet_call', [
-      {
+    const block_id = new Block(blockIdentifier).identifier;
+    const result = await this.fetchEndpoint('starknet_call', {
+      request: {
         contract_address: call.contractAddress,
         entry_point_selector: getSelectorFromName(call.entrypoint),
         calldata: parseCalldata(call.calldata),
       },
-      blockIdentifier,
-    ]);
+      block_id,
+    });
 
     return this.responseParser.parseCallContractResponse(result);
   }
 
-  public async getCode(
-    _contractAddress: string,
-    _blockIdentifier?: BlockIdentifier
-  ): Promise<GetCodeResponse> {
-    throw new Error('RPC 0.1.0 does not implement getCode function');
+  public async traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace> {
+    return this.fetchEndpoint('starknet_traceTransaction', { transaction_hash: transactionHash });
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
+  public async traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces> {
+    return this.fetchEndpoint('starknet_traceBlockTransactions', { block_hash: blockHash });
+  }
+
+  public async waitForTransaction(txHash: string, retryInterval: number = 8000) {
+    let { retries } = this;
     let onchain = false;
-    let retries = 100;
 
     while (!onchain) {
       const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
@@ -279,7 +331,7 @@ export class RpcProvider implements ProviderInterface {
         }
 
         if (retries === 0) {
-          throw error;
+          throw new Error('waitForTransaction timedout with retries');
         }
       }
 
@@ -299,10 +351,8 @@ export class RpcProvider implements ProviderInterface {
   public async getTransactionCount(
     blockIdentifier: BlockIdentifier
   ): Promise<RPC.GetTransactionCountResponse> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockTransactionCount', [
-      blockIdentifierGetter.getIdentifier(),
-    ]);
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_getBlockTransactionCount', { block_id });
   }
 
   /**
@@ -332,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 {
@@ -33,7 +33,7 @@ import { randomAddress } from '../utils/stark';
 import { buildUrl } from '../utils/url';
 import { GatewayError, HttpError } from './errors';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier, getFormattedBlockIdentifier } from './utils';
+import { Block, BlockIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 
@@ -129,7 +129,8 @@ export class SequencerProvider implements ProviderInterface {
     const queryString = Object.entries(query)
       .map(([key, value]) => {
         if (key === 'blockIdentifier') {
-          return `${getFormattedBlockIdentifier(value)}`;
+          const block = new Block(value);
+          return `${block.queryIdentifier}`;
         }
         return `${key}=${value}`;
       })
@@ -233,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,
@@ -271,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);
   }
 
@@ -315,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/provider/utils.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-classes-per-file */
 import type { BlockNumber } from '../types';
 import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
@@ -33,73 +34,59 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // null appends nothing to the request url
 
 export type BlockIdentifier = BlockNumber | BigNumberish;
-type BlockIdentifierObject =
-  | { type: 'BLOCK_NUMBER'; data: BlockNumber }
-  | { type: 'BLOCK_HASH'; data: BigNumberish };
 
-export class BlockIdentifierClass {
-  blockIdentifier: BlockIdentifier;
+export class Block {
+  hash: BlockIdentifier = null;
 
-  constructor(blockIdentifier: BlockIdentifier) {
-    this.blockIdentifier = blockIdentifier;
+  number: BlockIdentifier = null;
+
+  tag: BlockIdentifier = null;
+
+  private setIdentifier: (_identifier: BlockIdentifier) => void;
+
+  constructor(_identifier: BlockIdentifier) {
+    this.setIdentifier = function (__identifier: BlockIdentifier) {
+      if (typeof __identifier === 'string' && isHex(__identifier)) {
+        this.hash = __identifier;
+      } else if (typeof __identifier === 'number') {
+        this.number = __identifier;
+      } else {
+        this.tag = __identifier;
+      }
+    };
+
+    this.setIdentifier(_identifier);
   }
 
-  getIdentifier() {
-    if (typeof this.blockIdentifier === 'string' && isHex(this.blockIdentifier)) {
-      return { block_hash: this.blockIdentifier };
+  get queryIdentifier(): any {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
     }
 
-    if (typeof this.blockIdentifier === 'number') {
-      return { block_number: this.blockIdentifier };
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
     }
 
-    return this.blockIdentifier;
+    return `blockNumber=${this.tag}`;
   }
-}
 
-/**
- * Identifies the block to be queried.
- *
- * @param blockIdentifier - block identifier
- * @returns block identifier object
- */
-export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject {
-  if (blockIdentifier === null || blockIdentifier === 'latest') {
-    return { type: 'BLOCK_NUMBER', data: 'latest' }; // default to latest block
-  }
-  if (blockIdentifier === 'pending') {
-    return { type: 'BLOCK_NUMBER', data: 'pending' };
-  }
-  if (typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint') {
-    return { type: 'BLOCK_NUMBER', data: blockIdentifier };
-  }
-  if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
-    return { type: 'BLOCK_HASH', data: blockIdentifier };
-  }
-  if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
-    return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
-  }
-  if (typeof blockIdentifier === 'string') {
-    throw new Error(`Invalid block identifier: ${blockIdentifier}`);
-  }
-  return { type: 'BLOCK_HASH', data: blockIdentifier };
-}
+  get identifier(): any {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
 
-/**
- * Gets the block identifier for API request
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
- *
- * @param blockIdentifier
- * @returns block identifier for API request
- */
-export function getFormattedBlockIdentifier(blockIdentifier: BlockIdentifier = null): string {
-  const blockIdentifierObject = getBlockIdentifier(blockIdentifier);
-  if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
-    return '';
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+
+    return this.tag;
   }
-  if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
-    return `blockNumber=${blockIdentifierObject.data}`;
+
+  set identifier(_identifier: BlockIdentifier) {
+    this.setIdentifier(_identifier);
   }
-  return `blockHash=${toHex(toBN(blockIdentifierObject.data))}`;
+
+  valueOf = () => this.number;
+
+  toString = () => this.hash;
 }

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