starknet 4.1.0 → 4.3.1

package/provider/default.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProviderOptions } from './rpc';
@@ -16,7 +16,7 @@ export declare class Provider implements ProviderInterface {
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockTagOrHash?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;

package/provider/default.js

@@ -86,11 +86,11 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getStorageAt = function (contractAddress, key, blockTagOrHash) {
-        if (blockTagOrHash === void 0) { blockTagOrHash = 'pending'; }
+    Provider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.provider.getStorageAt(contractAddress, key, blockTagOrHash)];
+                return [2 /*return*/, this.provider.getStorageAt(contractAddress, key, blockIdentifier)];
             });
         });
     };

package/provider/interface.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import type { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import type { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
@@ -19,6 +19,9 @@ export declare abstract class ProviderInterface {
      * @returns the block object
      */
     abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * @deprecated The method should not be used
+     */
     abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     /**
      * Gets the contract class of the deployed contract.
@@ -33,10 +36,10 @@ export declare 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
      */
-    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets the transaction information from a tx id.
      *

package/provider/rpc.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { RPC } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -15,16 +15,21 @@ export declare class RpcProvider implements ProviderInterface {
     protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, request?: RPC.Methods[T]['REQUEST']): Promise<RPC.Methods[T]['RESPONSE']>;
     getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getNonce(contractAddress: string): Promise<any>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+    getTransactionByHash(txHash: BigNumberish): Promise<RPC.GetTransactionByHashResponse>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    getClassAt(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<any>;
+    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
     declareContract({ contract, version, }: DeclareContractPayload): Promise<DeclareContractResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    getCode(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<RPC.GetCodeResponse>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.

package/provider/rpc.js

@@ -47,6 +47,7 @@ var number_1 = require("../utils/number");
 var provider_1 = require("../utils/provider");
 var rpc_1 = require("../utils/responseParser/rpc");
 var stark_1 = require("../utils/stark");
+var utils_1 = require("./utils");
 var RpcProvider = /** @class */ (function () {
     function RpcProvider(optionsOrProvider) {
         var _this = this;
@@ -112,36 +113,78 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    // Common Interface
     RpcProvider.prototype.getBlock = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var method;
             return __generator(this, function (_a) {
-                method = typeof blockIdentifier === 'string' && (0, number_1.isHex)(blockIdentifier)
-                    ? 'starknet_getBlockByHash'
-                    : 'starknet_getBlockByNumber';
-                return [2 /*return*/, this.fetchEndpoint(method, [blockIdentifier]).then(this.responseParser.parseGetBlockResponse)];
+                return [2 /*return*/, this.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse)];
             });
         });
     };
-    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    RpcProvider.prototype.getBlockWithTxHashes = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxHashes', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
+            });
+        });
+    };
+    RpcProvider.prototype.getBlockWithTxs = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()])];
+            });
+        });
+    };
+    RpcProvider.prototype.getNonce = function (contractAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getNonce', [contractAddress])];
+            });
+        });
+    };
+    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var parsedKey;
+            var parsedKey, blockIdentifierGetter;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toHex)((0, number_1.toBN)(key));
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
                 return [2 /*return*/, this.fetchEndpoint('starknet_getStorageAt', [
                         contractAddress,
                         parsedKey,
-                        blockHashOrTag,
+                        blockIdentifierGetter.getIdentifier(),
                     ])];
             });
         });
     };
+    // common interface
     RpcProvider.prototype.getTransaction = function (txHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash]).then(this.responseParser.parseGetTransactionResponse)];
+                return [2 /*return*/, this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByHash = function (txHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash])];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByBlockIdAndIndex = function (blockIdentifier, index) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index])];
             });
         });
     };
@@ -152,11 +195,15 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getClassAt = function (contractAddress, _blockIdentifier) {
-        if (_blockIdentifier === void 0) { _blockIdentifier = 'pending'; }
+    RpcProvider.prototype.getClassAt = function (contractAddress, blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [contractAddress])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [
+                        blockIdentifierGetter.getIdentifier(),
+                        contractAddress,
+                    ])];
             });
         });
     };
@@ -248,16 +295,10 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getCode = function (contractAddress, _blockIdentifier) {
+    RpcProvider.prototype.getCode = function (_contractAddress, _blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.fetchEndpoint('starknet_getCode', [contractAddress])];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, this.responseParser.parseGetCodeResponse(result)];
-                }
+                throw new Error('RPC 0.1.0 does not implement getCode function');
             });
         });
     };
@@ -325,11 +366,12 @@ var RpcProvider = /** @class */ (function () {
      */
     RpcProvider.prototype.getTransactionCount = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             return __generator(this, function (_a) {
-                if (typeof blockIdentifier === 'number') {
-                    return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByNumber', [blockIdentifier])];
-                }
-                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByHash', [blockIdentifier])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCount', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
             });
         });
     };

package/provider/sequencer.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { GetContractAddressesResponse, GetTransactionStatusResponse, GetTransactionTraceResponse, Sequencer } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -29,7 +29,7 @@ export declare class SequencerProvider implements ProviderInterface {
     protected fetchEndpoint<T extends keyof Sequencer.Endpoints>(endpoint: T, ...[query, request]: Sequencer.Endpoints[T]['QUERY'] extends never ? Sequencer.Endpoints[T]['REQUEST'] extends never ? [] : [undefined, Sequencer.Endpoints[T]['REQUEST']] : Sequencer.Endpoints[T]['REQUEST'] extends never ? [Sequencer.Endpoints[T]['QUERY']] : [Sequencer.Endpoints[T]['QUERY'], Sequencer.Endpoints[T]['REQUEST']]): Promise<Sequencer.Endpoints[T]['RESPONSE']>;
     callContract({ contractAddress, entrypoint: entryPointSelector, calldata }: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;

package/provider/sequencer.js

@@ -65,6 +65,7 @@ var number_1 = require("../utils/number");
 var provider_1 = require("../utils/provider");
 var sequencer_1 = require("../utils/responseParser/sequencer");
 var stark_1 = require("../utils/stark");
+var url_1 = require("../utils/url");
 var errors_1 = require("./errors");
 var utils_1 = require("./utils");
 function isEmptyQueryObject(obj) {
@@ -79,7 +80,7 @@ function isEmptyQueryObject(obj) {
 var SequencerProvider = /** @class */ (function () {
     function SequencerProvider(optionsOrProvider) {
         if (optionsOrProvider === void 0) { optionsOrProvider = { network: 'goerli-alpha' }; }
-        var _a, _b, _c;
+        var _a;
         this.responseParser = new sequencer_1.SequencerAPIResponseParser();
         if ('network' in optionsOrProvider) {
             this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
@@ -89,11 +90,10 @@ var SequencerProvider = /** @class */ (function () {
         }
         else {
             this.baseUrl = optionsOrProvider.baseUrl;
-            this.feederGatewayUrl =
-                (_a = optionsOrProvider.feederGatewayUrl) !== null && _a !== void 0 ? _a : (0, url_join_1.default)(this.baseUrl, 'feeder_gateway');
-            this.gatewayUrl = (_b = optionsOrProvider.gatewayUrl) !== null && _b !== void 0 ? _b : (0, url_join_1.default)(this.baseUrl, 'gateway');
+            this.feederGatewayUrl = (0, url_1.buildUrl)(this.baseUrl, 'feeder_gateway', optionsOrProvider.feederGatewayUrl);
+            this.gatewayUrl = (0, url_1.buildUrl)(this.baseUrl, 'gateway', optionsOrProvider.gatewayUrl);
             this.chainId =
-                (_c = optionsOrProvider.chainId) !== null && _c !== void 0 ? _c : SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
+                (_a = optionsOrProvider.chainId) !== null && _a !== void 0 ? _a : SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
         }
     }
     SequencerProvider.getNetworkFromName = function (name) {
@@ -249,14 +249,14 @@ var SequencerProvider = /** @class */ (function () {
             });
         });
     };
-    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             var parsedKey;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toBN)(key).toString(10);
                 return [2 /*return*/, this.fetchEndpoint('get_storage_at', {
-                        blockIdentifier: blockHashOrTag,
+                        blockIdentifier: blockIdentifier,
                         contractAddress: contractAddress,
                         key: parsedKey,
                     })];
@@ -359,7 +359,7 @@ var SequencerProvider = /** @class */ (function () {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier }).then(this.responseParser.parseGetCodeResponse)];
+                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier })];
             });
         });
     };

package/provider/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="bn.js" />
 import type { BlockNumber } from '../types';
 import { BigNumberish } from '../utils/number';
 /**
@@ -23,6 +24,17 @@ declare type BlockIdentifierObject = {
     type: 'BLOCK_HASH';
     data: BigNumberish;
 };
+export declare class BlockIdentifierClass {
+    blockIdentifier: BlockIdentifier;
+    constructor(blockIdentifier: BlockIdentifier);
+    getIdentifier(): string | import("bn.js") | {
+        block_hash: string;
+        block_number?: undefined;
+    } | {
+        block_number: number;
+        block_hash?: undefined;
+    } | null;
+}
 /**
  * Identifies the block to be queried.
  *

package/provider/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.txIdentifier = exports.formatHash = void 0;
+exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.BlockIdentifierClass = exports.txIdentifier = exports.formatHash = void 0;
 var number_1 = require("../utils/number");
 /**
  *
@@ -29,6 +29,22 @@ function txIdentifier(txHash, txId) {
     return "transactionHash=".concat(hashString);
 }
 exports.txIdentifier = txIdentifier;
+var BlockIdentifierClass = /** @class */ (function () {
+    function BlockIdentifierClass(blockIdentifier) {
+        this.blockIdentifier = blockIdentifier;
+    }
+    BlockIdentifierClass.prototype.getIdentifier = function () {
+        if (typeof this.blockIdentifier === 'string' && (0, number_1.isHex)(this.blockIdentifier)) {
+            return { block_hash: this.blockIdentifier };
+        }
+        if (typeof this.blockIdentifier === 'number') {
+            return { block_number: this.blockIdentifier };
+        }
+        return this.blockIdentifier;
+    };
+    return BlockIdentifierClass;
+}());
+exports.BlockIdentifierClass = BlockIdentifierClass;
 /**
  * Identifies the block to be queried.
  *

package/src/index.ts

@@ -22,3 +22,4 @@ export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';
 export * as typedData from './utils/typedData';
 export * from './utils/address';
+export * from './utils/url';

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,
@@ -19,18 +19,12 @@ import { RPC } from '../types/api';
 import fetch from '../utils/fetchPonyfill';
 import { getSelectorFromName } from '../utils/hash';
 import { stringify } from '../utils/json';
-import {
-  BigNumberish,
-  bigNumberishArrayToDecimalStringArray,
-  isHex,
-  toBN,
-  toHex,
-} from '../utils/number';
+import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
 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 +83,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 +148,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(
@@ -214,12 +238,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 +292,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(),
+    ]);
   }
 
   /**