starknet 4.3.0 → 4.4.1

package/signer/default.d.ts

@@ -3,7 +3,7 @@ import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
 export declare class Signer implements SignerInterface {
     protected keyPair: KeyPair;
-    constructor(keyPair: KeyPair);
+    constructor(keyPair?: KeyPair);
     getPubKey(): Promise<string>;
     signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
     signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;

package/signer/default.js

@@ -43,6 +43,7 @@ var transaction_1 = require("../utils/transaction");
 var typedData_1 = require("../utils/typedData");
 var Signer = /** @class */ (function () {
     function Signer(keyPair) {
+        if (keyPair === void 0) { keyPair = (0, ellipticCurve_1.genKeyPair)(); }
         this.keyPair = keyPair;
     }
     Signer.prototype.getPubKey = function () {

package/src/index.ts

@@ -17,6 +17,7 @@ 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 merkle from './utils/merkle';
 export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';

package/src/provider/default.ts

@@ -1,6 +1,5 @@
 import { StarknetChainId } from '../constants';
 import {
-  BlockTag,
   Call,
   CallContractResponse,
   ContractClass,
@@ -69,9 +68,9 @@ export class Provider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockTagOrHash: BlockTag | BigNumberish = 'pending'
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
-    return this.provider.getStorageAt(contractAddress, key, blockTagOrHash);
+    return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
   }
 
   public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {

package/src/provider/interface.ts

@@ -1,6 +1,5 @@
 import { StarknetChainId } from '../constants';
 import type {
-  BlockTag,
   Call,
   CallContractResponse,
   ContractClass,
@@ -43,6 +42,9 @@ export abstract class ProviderInterface {
    */
   public abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
 
+  /**
+   * @deprecated The method should not be used
+   */
   public abstract getCode(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
@@ -65,13 +67,13 @@ export abstract class ProviderInterface {
    *
    * @param contractAddress
    * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockHashOrTag - block hash or tag (pending, latest)
+   * @param blockIdentifier - block identifier
    * @returns the value of the storage variable
    */
   public abstract getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockHashOrTag?: BlockTag | BigNumberish
+    blockIdentifier: BlockIdentifier
   ): Promise<BigNumberish>;
 
   /**

package/src/provider/rpc.ts

@@ -1,6 +1,5 @@
 import { StarknetChainId } from '../constants';
 import {
-  BlockTag,
   Call,
   CallContractResponse,
   DeclareContractPayload,
@@ -9,6 +8,7 @@ import {
   DeployContractResponse,
   EstimateFeeResponse,
   GetBlockResponse,
+  GetCodeResponse,
   GetTransactionReceiptResponse,
   GetTransactionResponse,
   Invocation,
@@ -21,8 +21,7 @@ import { getSelectorFromName } from '../utils/hash';
 import { stringify } from '../utils/json';
 import {
   BigNumberish,
-  bigNumberishArrayToDecimalStringArray,
-  isHex,
+  bigNumberishArrayToHexadecimalStringArray,
   toBN,
   toHex,
 } from '../utils/number';
@@ -30,7 +29,7 @@ import { parseCalldata, parseContract, wait } from '../utils/provider';
 import { RPCResponseParser } from '../utils/responseParser/rpc';
 import { randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier } from './utils';
+import { BlockIdentifier, BlockIdentifierClass } from './utils';
 
 export type RpcProviderOptions = { nodeUrl: string };
 
@@ -89,34 +88,63 @@ export class RpcProvider implements ProviderInterface {
     return this.fetchEndpoint('starknet_chainId');
   }
 
+  // Common Interface
   public async getBlock(blockIdentifier: BlockIdentifier = 'pending'): Promise<GetBlockResponse> {
-    const method =
-      typeof blockIdentifier === 'string' && isHex(blockIdentifier)
-        ? 'starknet_getBlockByHash'
-        : 'starknet_getBlockByNumber';
-
-    return this.fetchEndpoint(method, [blockIdentifier]).then(
+    return this.getBlockWithTxHashes(blockIdentifier).then(
       this.responseParser.parseGetBlockResponse
     );
   }
 
+  public async getBlockWithTxHashes(
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<RPC.GetBlockWithTxHashesResponse> {
+    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockWithTxHashes', [
+      blockIdentifierGetter.getIdentifier(),
+    ]);
+  }
+
+  public async getBlockWithTxs(
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<RPC.GetBlockWithTxs> {
+    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()]);
+  }
+
+  public async getNonce(contractAddress: string): Promise<any> {
+    return this.fetchEndpoint('starknet_getNonce', [contractAddress]);
+  }
+
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockHashOrTag: BlockTag | BigNumberish = 'pending'
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toHex(toBN(key));
+    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
     return this.fetchEndpoint('starknet_getStorageAt', [
       contractAddress,
       parsedKey,
-      blockHashOrTag,
+      blockIdentifierGetter.getIdentifier(),
     ]);
   }
 
+  // common interface
   public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
-    return this.fetchEndpoint('starknet_getTransactionByHash', [txHash]).then(
-      this.responseParser.parseGetTransactionResponse
-    );
+    return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
+  }
+
+  public async getTransactionByHash(
+    txHash: BigNumberish
+  ): Promise<RPC.GetTransactionByHashResponse> {
+    return this.fetchEndpoint('starknet_getTransactionByHash', [txHash]);
+  }
+
+  public async getTransactionByBlockIdAndIndex(
+    blockIdentifier: BlockIdentifier,
+    index: number
+  ): Promise<RPC.GetTransactionByBlockIdAndIndex> {
+    return this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index]);
   }
 
   public async getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse> {
@@ -125,11 +153,12 @@ export class RpcProvider implements ProviderInterface {
     );
   }
 
-  public async getClassAt(
-    contractAddress: string,
-    _blockIdentifier: BlockIdentifier = 'pending'
-  ): Promise<any> {
-    return this.fetchEndpoint('starknet_getClassAt', [contractAddress]);
+  public async getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any> {
+    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
+    return this.fetchEndpoint('starknet_getClassAt', [
+      blockIdentifierGetter.getIdentifier(),
+      contractAddress,
+    ]);
   }
 
   public async getEstimateFee(
@@ -142,7 +171,7 @@ export class RpcProvider implements ProviderInterface {
         contract_address: invocation.contractAddress,
         entry_point_selector: getSelectorFromName(invocation.entrypoint),
         calldata: parseCalldata(invocation.calldata),
-        signature: bigNumberishArrayToDecimalStringArray(invocation.signature || []),
+        signature: bigNumberishArrayToHexadecimalStringArray(invocation.signature || []),
         version: toHex(toBN(invocationDetails?.version || 0)),
       },
       blockIdentifier,
@@ -173,7 +202,7 @@ export class RpcProvider implements ProviderInterface {
 
     return this.fetchEndpoint('starknet_addDeployTransaction', [
       addressSalt ?? randomAddress(),
-      bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      bigNumberishArrayToHexadecimalStringArray(constructorCalldata ?? []),
       {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
@@ -191,7 +220,7 @@ export class RpcProvider implements ProviderInterface {
         entry_point_selector: getSelectorFromName(functionInvocation.entrypoint),
         calldata: parseCalldata(functionInvocation.calldata),
       },
-      bigNumberishArrayToDecimalStringArray(functionInvocation.signature || []),
+      bigNumberishArrayToHexadecimalStringArray(functionInvocation.signature || []),
       toHex(toBN(details.maxFee || 0)),
       toHex(toBN(details.version || 0)),
     ]).then(this.responseParser.parseInvokeFunctionResponse);
@@ -214,12 +243,10 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public async getCode(
-    contractAddress: string,
+    _contractAddress: string,
     _blockIdentifier?: BlockIdentifier
-  ): Promise<RPC.GetCodeResponse> {
-    const result = await this.fetchEndpoint('starknet_getCode', [contractAddress]);
-
-    return this.responseParser.parseGetCodeResponse(result);
+  ): Promise<GetCodeResponse> {
+    throw new Error('RPC 0.1.0 does not implement getCode function');
   }
 
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
@@ -270,10 +297,10 @@ export class RpcProvider implements ProviderInterface {
   public async getTransactionCount(
     blockIdentifier: BlockIdentifier
   ): Promise<RPC.GetTransactionCountResponse> {
-    if (typeof blockIdentifier === 'number') {
-      return this.fetchEndpoint('starknet_getBlockTransactionCountByNumber', [blockIdentifier]);
-    }
-    return this.fetchEndpoint('starknet_getBlockTransactionCountByHash', [blockIdentifier]);
+    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockTransactionCount', [
+      blockIdentifierGetter.getIdentifier(),
+    ]);
   }
 
   /**

package/src/provider/sequencer.ts

@@ -2,7 +2,6 @@ import urljoin from 'url-join';
 
 import { ONE, StarknetChainId, ZERO } from '../constants';
 import {
-  BlockTag,
   Call,
   CallContractResponse,
   ContractClass,
@@ -233,11 +232,11 @@ export class SequencerProvider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockHashOrTag: BlockTag | BigNumberish = 'pending'
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toBN(key).toString(10);
     return this.fetchEndpoint('get_storage_at', {
-      blockIdentifier: blockHashOrTag,
+      blockIdentifier,
       contractAddress,
       key: parsedKey,
     });
@@ -332,9 +331,7 @@ export class SequencerProvider implements ProviderInterface {
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<Sequencer.GetCodeResponse> {
-    return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier }).then(
-      this.responseParser.parseGetCodeResponse
-    );
+    return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier });
   }
 
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {

package/src/provider/utils.ts

@@ -1,5 +1,5 @@
 import type { BlockNumber } from '../types';
-import { BigNumberish, toBN, toHex } from '../utils/number';
+import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
 /**
  *
@@ -31,11 +31,32 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // hex string and BN are detected as block hashes
 // decimal string and number are detected as block numbers
 // 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;
+
+  constructor(blockIdentifier: BlockIdentifier) {
+    this.blockIdentifier = blockIdentifier;
+  }
+
+  getIdentifier() {
+    if (typeof this.blockIdentifier === 'string' && isHex(this.blockIdentifier)) {
+      return { block_hash: this.blockIdentifier };
+    }
+
+    if (typeof this.blockIdentifier === 'number') {
+      return { block_number: this.blockIdentifier };
+    }
+
+    return this.blockIdentifier;
+  }
+}
+
 /**
  * Identifies the block to be queried.
  *

package/src/signer/default.ts

@@ -1,5 +1,5 @@
 import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
-import { getStarkKey, sign } from '../utils/ellipticCurve';
+import { genKeyPair, getStarkKey, sign } from '../utils/ellipticCurve';
 import { calculcateTransactionHash, getSelectorFromName } from '../utils/hash';
 import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
@@ -8,7 +8,7 @@ import { SignerInterface } from './interface';
 export class Signer implements SignerInterface {
   protected keyPair: KeyPair;
 
-  constructor(keyPair: KeyPair) {
+  constructor(keyPair: KeyPair = genKeyPair()) {
     this.keyPair = keyPair;
   }
 

package/src/types/api/openrpc.ts

@@ -0,0 +1,168 @@
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+
+/**
+ * "type": "string",
+ * "title": "Field element",
+ * "$comment": "A field element, represented as a string of hex digits",
+ * "description": "A field element. Represented as up to 63 hex digits and leading 4 bits zeroed.",
+ * "pattern": "^0x0[a-fA-F0-9]{1,63}$"
+ */
+type FELT = string;
+type BLOCK_NUMBER = number;
+type BLOCK_HASH = FELT;
+type TXN_HASH = FELT;
+type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+type MSG_TO_L1 = {
+  to_address: FELT;
+  payload: Array<FELT>;
+};
+type EVENT = {
+  from_address: FELT;
+  keys: Array<FELT>;
+  data: Array<FELT>;
+};
+type COMMON_RECEIPT_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  actual_fee: FELT;
+  status: TXN_STATUS;
+  block_hash: BLOCK_HASH;
+  block_number: BLOCK_NUMBER;
+  type?: TXN_TYPE;
+};
+type INVOKE_TXN_RECEIPT_PROPERTIES = {
+  messages_sent: MSG_TO_L1;
+  events: EVENT;
+};
+type PENDING_COMMON_RECEIPT_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  actual_fee: FELT;
+  type?: TXN_TYPE;
+};
+type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+type TXN_RECEIPT =
+  | INVOKE_TXN_RECEIPT
+  | L1_HANDLER_TXN_RECEIPT
+  | DECLARE_TXN_RECEIPT
+  | DEPLOY_TXN_RECEIPT
+  | PENDING_TXN_RECEIPT;
+
+export namespace RPC_1 {
+  export type GetTransactionReceiptResponse = TXN_RECEIPT;
+
+  export type Methods = {
+    starknet_getTransactionReceipt: {
+      QUERY: never;
+      REQUEST: any[];
+      RESPONSE: GetTransactionReceiptResponse;
+    };
+  };
+}
+
+// starknet_getBlockWithTxHashes
+type BLOCK_HEADER = {
+  block_hash: BLOCK_HASH;
+  parent_hash: BLOCK_HASH;
+  block_number: BLOCK_NUMBER;
+  new_root: FELT;
+  timestamp: number;
+  sequencer_address: FELT;
+};
+type BLOCK_BODY_WITH_TX_HASHES = {
+  transactions: Array<TXN_HASH>;
+};
+type BLOCK_WITH_TX_HASHES = {
+  status: TXN_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TX_HASHES;
+type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+// starknet_getBlockWithTx
+type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+/**
+ * "title": "An integer number in hex format (0x...)",
+ * "pattern": "^0x[a-fA-F0-9]+$"
+ */
+type NUM_AS_HEX = string;
+type SIGNATURE = Array<FELT>;
+type COMMON_TXN_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  max_fee: FELT;
+  version: NUM_AS_HEX;
+  signature: SIGNATURE;
+  nonce: FELT;
+  type: TXN_TYPE;
+};
+type ADDRESS = FELT;
+type FUNCTION_CALL = {
+  contract_address: ADDRESS;
+  entry_point_selector: FELT;
+  calldata: Array<FELT>;
+};
+type INVOKE_TXN = COMMON_TXN_PROPERTIES & FUNCTION_CALL;
+type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+  class_hash: FELT;
+  sender_address: ADDRESS;
+};
+type DEPLOY_TXN = {
+  transaction_hash: TXN_HASH;
+  class_hash: FELT;
+  version: NUM_AS_HEX;
+  type: TXN_TYPE;
+  contract_address: FELT;
+  contract_address_salt: FELT;
+  constructor_calldata: Array<FELT>;
+};
+type TXN = INVOKE_TXN | DECLARE_TXN | DEPLOY_TXN;
+type BLOCK_BODY_WITH_TXS = {
+  transactions: Array<TXN>;
+};
+type BLOCK_WITH_TXS = {
+  status: BLOCK_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TXS;
+
+type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+type CONTRACT_CLASS = {
+  program: string; // A base64 representation of the compressed program code
+  entry_points_by_type: {
+    CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
+    EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
+    L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
+  };
+};
+
+type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+type CONTRACT_ENTRY_POINT = {
+  offset: NUM_AS_HEX;
+  selector: FELT;
+};
+
+export namespace OPENRPC {
+  export type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+  export type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+  export type GetStorageAtResponse = FELT;
+  export type GetTransactionByHashResponse = TXN;
+  export type GetTransactionByBlockIdAndIndex = TXN;
+  export type GetClassResponse = CONTRACT_CLASS;
+}

package/src/types/api/rpc.ts

@@ -1,5 +1,7 @@
 import { StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../../provider/utils';
 import { Status } from '../lib';
+import { OPENRPC } from './openrpc';
 
 export namespace RPC {
   export type Response = {
@@ -32,25 +34,9 @@ export namespace RPC {
     gas_price: number;
   };
 
-  export type GetBlockResponse = {
-    block_hash: string;
-    parent_hash: string;
-    block_number: number;
-    status: Status;
-    sequencer: string;
-    new_root: string;
-    old_root: string;
-    accepted_time: number;
-    gas_price: string;
-    transactions: string[];
-  };
-
-  export type GetCodeResponse = {
-    bytecode: string[];
-    abi: string;
-  };
-
-  export type GetStorageAtResponse = string;
+  export type GetBlockWithTxHashesResponse = OPENRPC.GetBlockWithTxHashesResponse;
+  export type GetBlockWithTxs = OPENRPC.GetBlockWithTxs;
+  export type GetStorageAtResponse = OPENRPC.GetStorageAtResponse;
 
   export type GetTransactionReceiptResponse = {
     txn_hash: string;
@@ -81,7 +67,8 @@ export namespace RPC {
     sender_address?: string;
   }
 
-  export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+  export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
+  export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
 
   export type GetTransactionCountResponse = number;
 
@@ -99,8 +86,8 @@ export namespace RPC {
     | boolean;
 
   export type EventFilter = {
-    fromBlock: string;
-    toBlock: string;
+    fromBlock: BlockIdentifier;
+    toBlock: BlockIdentifier;
     address: string;
     keys: string[];
     page_size: number;
@@ -143,56 +130,46 @@ export namespace RPC {
   };
 
   export type Methods = {
-    starknet_getBlockByHash: {
+    starknet_getBlockWithTxHashes: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetBlockResponse;
+      RESPONSE: GetBlockWithTxHashesResponse;
     };
-    starknet_getBlockByNumber: {
+    starknet_getBlockWithTxs: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetBlockResponse;
+      RESPONSE: GetBlockWithTxs;
     };
-    starknet_getStorageAt: {
+    starknet_getNonce: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetStorageAtResponse;
+      RESPONSE: string;
     };
-    starknet_getTransactionByHash: {
+    starknet_getStorageAt: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetStorageAtResponse;
     };
-    starknet_getTransactionByBlockHashAndIndex: {
+    starknet_getTransactionByHash: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetTransactionByHashResponse;
     };
-    starknet_getTransactionByBlockNumberAndIndex: {
+    starknet_getTransactionByBlockIdAndIndex: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: GetTransactionResponse;
+      RESPONSE: GetTransactionByBlockIdAndIndex;
     };
     starknet_getTransactionReceipt: {
       QUERY: never;
       REQUEST: any[];
       RESPONSE: GetTransactionReceiptResponse;
     };
-    starknet_getBlockTransactionCountByHash: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetTransactionCountResponse;
-    };
-    starknet_getBlockTransactionCountByNumber: {
+    starknet_getBlockTransactionCount: {
       QUERY: never;
       REQUEST: any[];
       RESPONSE: GetTransactionCountResponse;
     };
-    starknet_getCode: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetCodeResponse;
-    };
     starknet_call: {
       QUERY: never;
       REQUEST: any[];

package/src/types/provider.ts

@@ -1,19 +1,19 @@
+/**
+ * Common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import BN from 'bn.js';
 
 import { Abi, CompressedProgram, EntryPointsByType, RawCalldata, Signature, Status } from './lib';
 
 export interface GetBlockResponse {
-  accepted_time: number;
+  timestamp: number;
   block_hash: string;
   block_number: number;
-  gas_price: string;
   new_root: string;
-  old_root?: string;
   parent_hash: string;
-  sequencer: string;
   status: Status;
   transactions: Array<string>;
-  starknet_version?: string;
 }
 
 export interface GetCodeResponse {