starknet 4.5.0 → 4.6.0

package/dist/types/api/rpc.d.ts

@@ -1,110 +1,68 @@
-import { StarknetChainId } from '../../constants';
-import { BlockIdentifier } from '../../provider/utils';
-import { Status } from '../lib';
-import { OPENRPC } from './openrpc';
+import { ADDRESS, FELT, OPENRPC } from './openrpc';
 export declare namespace RPC {
-    export type Response = {
+    type Response = {
         id: number;
-        result: any;
         jsonrpc: string;
+        result?: any;
         error?: {
             code: string;
             message: string;
         };
     };
-    export type AddTransactionResponse = {
-        transaction_hash: string;
-    };
-    export type GetClassResponse = {
-        program: string;
-        entry_point_by_type: any;
-    };
-    export type DeclareResponse = {
-        transaction_hash: string;
-        class_hash: string;
-    };
-    export type EstimateFeeResponse = {
-        overall_fee: number;
-        gas_consumed: number;
-        gas_price: number;
-    };
-    export type GetBlockWithTxHashesResponse = OPENRPC.GetBlockWithTxHashesResponse;
-    export type GetBlockWithTxs = OPENRPC.GetBlockWithTxs;
-    export type GetStorageAtResponse = OPENRPC.GetStorageAtResponse;
-    export type GetTransactionReceiptResponse = {
-        txn_hash: string;
-        actual_fee: string;
-        status: Status;
-        status_data: string;
-        messages_sent: Array<MessageToL1>;
-        l1_origin_message: MessageToL2;
-        events: Array<StarknetEvent>;
-    };
-    interface CommonTransactionProperties {
-        txn_hash: string;
-        max_fee: string;
-        version: string;
-        nonce: string;
-        signature: Array<string>;
-    }
-    export interface InvokeTransactionResponse extends CommonTransactionProperties {
-        contract_address?: string;
-        entry_point_selector?: string;
-        calldata?: Array<string>;
-    }
-    export interface DeclareTransactionResponse extends CommonTransactionProperties {
-        contract_class?: GetClassResponse;
-        sender_address?: string;
-    }
-    export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
-    export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
-    export type GetTransactionCountResponse = number;
-    export type GetBlockNumberResponse = number;
-    export type GetSyncingStatsResponse = {
-        starting_block_hash: string;
-        starting_block_num: string;
-        current_block_hash: string;
-        current_block_num: string;
-        highest_block_hash: string;
-        highest_block_num: string;
-    } | boolean;
-    export type EventFilter = {
-        fromBlock: BlockIdentifier;
-        toBlock: BlockIdentifier;
-        address: string;
-        keys: string[];
-        page_size: number;
-        page_number: number;
-    };
-    export type GetEventsResponse = {
-        events: StarknetEmittedEvent[];
-        page_number: number;
-        is_last_page: number;
-    };
-    export type DeployContractResponse = {
-        transaction_hash: string;
-        contract_address: string;
-    };
-    export type StarknetEvent = {
-        from_address: string;
-        keys: string[];
-        data: string[];
-    };
-    export type StarknetEmittedEvent = {
-        event: StarknetEvent;
-        block_hash: string;
-        block_number: number;
-        transaction_hash: string;
-    };
-    export type MessageToL1 = {
-        to_address: string;
-        payload: string[];
-    };
-    export type MessageToL2 = {
-        from_address: string;
-        payload: string[];
-    };
-    export type Methods = {
+    type ChainId = OPENRPC.ChainId;
+    type ContractAddress = ADDRESS;
+    type Felt = FELT;
+    type ContractClass = OPENRPC.ContractClass;
+    type StateUpdate = OPENRPC.StateUpdate;
+    type Transaction = OPENRPC.Transaction;
+    type PendingTransactions = OPENRPC.PendingTransactions;
+    type TransactionHash = OPENRPC.TransactionHash;
+    type Trace = OPENRPC.Trace;
+    type Traces = OPENRPC.Traces;
+    type BlockHash = OPENRPC.BlockHash;
+    type BlockHashAndNumber = OPENRPC.BlockHashAndNumber;
+    type GetClassResponse = OPENRPC.ContractClass;
+    type EstimateFeeResponse = OPENRPC.EstimatedFee;
+    type GetBlockWithTxHashesResponse = OPENRPC.BlockWithTxHashes;
+    type GetBlockWithTxs = OPENRPC.BlockWithTxs;
+    type GetStorageAtResponse = OPENRPC.Storage;
+    type TransactionReceipt = OPENRPC.TransactionReceipt;
+    type GetTransactionByHashResponse = OPENRPC.Transaction;
+    type GetTransactionByBlockIdAndIndex = OPENRPC.Transaction;
+    type GetTransactionCountResponse = number;
+    type GetBlockNumberResponse = OPENRPC.BlockNumber;
+    type GetSyncingStatsResponse = OPENRPC.SyncingStatus;
+    type EventFilter = OPENRPC.EventFilter;
+    type GetEventsResponse = OPENRPC.Events;
+    type InvokedTransaction = OPENRPC.InvokedTransaction;
+    type DeclaredTransaction = OPENRPC.DeclaredTransaction;
+    type DeployedTransaction = OPENRPC.DeployedTransaction;
+    type Methods = {
+        starknet_pendingTransactions: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: PendingTransactions;
+        };
+        starknet_blockHashAndNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: BlockHashAndNumber;
+        };
+        starknet_getClassHashAt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: Felt;
+        };
+        starknet_getStateUpdate: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: OPENRPC.StateUpdate;
+        };
+        starknet_getClass: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: OPENRPC.ContractClass;
+        };
         starknet_getBlockWithTxHashes: {
             QUERY: never;
             REQUEST: any[];
@@ -118,7 +76,7 @@ export declare namespace RPC {
         starknet_getNonce: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: string;
+            RESPONSE: OPENRPC.Nonce;
         };
         starknet_getStorageAt: {
             QUERY: never;
@@ -138,7 +96,7 @@ export declare namespace RPC {
         starknet_getTransactionReceipt: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionReceiptResponse;
+            RESPONSE: TransactionReceipt;
         };
         starknet_getBlockTransactionCount: {
             QUERY: never;
@@ -153,7 +111,7 @@ export declare namespace RPC {
         starknet_estimateFee: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: EstimateFeeResponse;
+            RESPONSE: OPENRPC.EstimatedFee;
         };
         starknet_blockNumber: {
             QUERY: never;
@@ -163,7 +121,7 @@ export declare namespace RPC {
         starknet_chainId: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: StarknetChainId;
+            RESPONSE: OPENRPC.ChainId;
         };
         starknet_syncing: {
             QUERY: never;
@@ -178,23 +136,32 @@ export declare namespace RPC {
         starknet_addInvokeTransaction: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: AddTransactionResponse;
+            RESPONSE: OPENRPC.InvokedTransaction;
         };
         starknet_addDeployTransaction: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: DeployContractResponse;
+            RESPONSE: OPENRPC.DeployedTransaction;
         };
         starknet_addDeclareTransaction: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: DeclareResponse;
+            RESPONSE: OPENRPC.DeclaredTransaction;
         };
         starknet_getClassAt: {
             QUERY: never;
             REQUEST: any[];
             RESPONSE: any;
         };
+        starknet_traceTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: any;
+        };
+        starknet_traceBlockTransactions: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: any;
+        };
     };
-    export {};
 }

package/dist/utils/responseParser/rpc.d.ts

@@ -11,14 +11,17 @@ declare type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
 declare type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
     [key: string]: any;
 };
+declare type TransactionReceipt = RPC.TransactionReceipt & {
+    [key: string]: any;
+};
 export declare class RPCResponseParser extends ResponseParser {
     parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse;
     parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse;
-    parseGetTransactionReceiptResponse(res: RPC.GetTransactionReceiptResponse): GetTransactionReceiptResponse;
+    parseGetTransactionReceiptResponse(res: TransactionReceipt): GetTransactionReceiptResponse;
     parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse;
     parseCallContractResponse(res: Array<string>): CallContractResponse;
-    parseInvokeFunctionResponse(res: RPC.AddTransactionResponse): InvokeFunctionResponse;
-    parseDeployContractResponse(res: RPC.DeployContractResponse): DeployContractResponse;
-    parseDeclareContractResponse(res: RPC.DeclareResponse): DeclareContractResponse;
+    parseInvokeFunctionResponse(res: RPC.InvokedTransaction): InvokeFunctionResponse;
+    parseDeployContractResponse(res: RPC.DeployedTransaction): DeployContractResponse;
+    parseDeclareContractResponse(res: RPC.DeclaredTransaction): DeclareContractResponse;
 }
 export {};

package/dist/utils/responseParser/rpc.js

@@ -48,7 +48,7 @@ var RPCResponseParser = /** @class */ (function (_super) {
     };
     RPCResponseParser.prototype.parseGetTransactionReceiptResponse = function (res) {
         return {
-            transaction_hash: res.txn_hash,
+            transaction_hash: res.transaction_hash,
             actual_fee: res.actual_fee,
             status: res.status,
             status_data: res.status_data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/provider/rpc.d.ts

@@ -12,24 +12,34 @@ export declare class RpcProvider implements ProviderInterface {
     chainId: StarknetChainId;
     private responseParser;
     constructor(optionsOrProvider: RpcProviderOptions);
+    fetch(method: any, params: any): Promise<any>;
+    protected errorHandler(error: any): void;
     protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, request?: RPC.Methods[T]['REQUEST']): Promise<RPC.Methods[T]['RESPONSE']>;
-    getChainId(): Promise<StarknetChainId>;
+    getChainId(): Promise<any>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getClassHashAt(blockIdentifier: BlockIdentifier, contractAddress: RPC.ContractAddress): Promise<RPC.Felt>;
     getNonce(contractAddress: string): Promise<any>;
+    getPendingTransactions(): Promise<RPC.PendingTransactions>;
+    getProtocolVersion(): Promise<Error>;
+    getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate>;
     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>;
+    getClass(classHash: RPC.Felt): Promise<RPC.ContractClass>;
     getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     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<GetCodeResponse>;
+    traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
+    traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.

package/provider/rpc.js

@@ -58,54 +58,45 @@ var RpcProvider = /** @class */ (function () {
             _this.chainId = chainId;
         });
     }
+    RpcProvider.prototype.fetch = function (method, params) {
+        return (0, fetchPonyfill_1.default)(this.nodeUrl, {
+            method: 'POST',
+            body: (0, json_1.stringify)({ method: method, jsonrpc: '2.0', params: params, id: 0 }),
+            headers: { 'Content-Type': 'application/json' },
+        });
+    };
+    RpcProvider.prototype.errorHandler = function (error) {
+        if (error) {
+            var code = error.code, message = error.message;
+            throw new Error("".concat(code, ": ").concat(message));
+        }
+    };
     RpcProvider.prototype.fetchEndpoint = function (method, request) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var requestData, rawResult, _b, error, result, code, message, error_1, data;
+            var rawResult, _b, error, result, error_1;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        requestData = {
-                            method: method,
-                            jsonrpc: '2.0',
-                            params: request,
-                            id: 0,
-                        };
-                        _c.label = 1;
+                        _c.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.fetch(method, request)];
                     case 1:
-                        _c.trys.push([1, 4, , 5]);
-                        return [4 /*yield*/, (0, fetchPonyfill_1.default)(this.nodeUrl, {
-                                method: 'POST',
-                                body: (0, json_1.stringify)(requestData),
-                                headers: {
-                                    'Content-Type': 'application/json',
-                                },
-                            })];
-                    case 2:
                         rawResult = _c.sent();
                         return [4 /*yield*/, rawResult.json()];
-                    case 3:
+                    case 2:
                         _b = _c.sent(), error = _b.error, result = _b.result;
-                        if (error) {
-                            code = error.code, message = error.message;
-                            throw new Error("".concat(code, ": ").concat(message));
-                        }
-                        else {
-                            return [2 /*return*/, result];
-                        }
-                        return [3 /*break*/, 5];
-                    case 4:
+                        this.errorHandler(error);
+                        return [2 /*return*/, result];
+                    case 3:
                         error_1 = _c.sent();
-                        data = (_a = error_1 === null || error_1 === void 0 ? void 0 : error_1.response) === null || _a === void 0 ? void 0 : _a.data;
-                        if (data === null || data === void 0 ? void 0 : data.message) {
-                            throw new Error("".concat(data.code, ": ").concat(data.message));
-                        }
+                        this.errorHandler((_a = error_1 === null || error_1 === void 0 ? void 0 : error_1.response) === null || _a === void 0 ? void 0 : _a.data);
                         throw error_1;
-                    case 5: return [2 /*return*/];
+                    case 4: return [2 /*return*/];
                 }
             });
         });
     };
+    // Methods from Interface
     RpcProvider.prototype.getChainId = function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -113,7 +104,7 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    // Common Interface
+    // Methods from Interface
     RpcProvider.prototype.getBlock = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
@@ -122,25 +113,39 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    RpcProvider.prototype.getBlockHashAndNumber = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_blockHashAndNumber')];
+            });
+        });
+    };
     RpcProvider.prototype.getBlockWithTxHashes = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var blockIdentifierGetter;
+            var block;
             return __generator(this, function (_a) {
-                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
-                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxHashes', [
-                        blockIdentifierGetter.getIdentifier(),
-                    ])];
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxHashes', [block.identifier])];
             });
         });
     };
     RpcProvider.prototype.getBlockWithTxs = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var blockIdentifierGetter;
+            var block;
+            return __generator(this, function (_a) {
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxs', [block.identifier])];
+            });
+        });
+    };
+    RpcProvider.prototype.getClassHashAt = function (blockIdentifier, contractAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var block;
             return __generator(this, function (_a) {
-                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
-                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()])];
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassHashAt', [block.identifier, contractAddress])];
             });
         });
     };
@@ -151,22 +156,45 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    RpcProvider.prototype.getPendingTransactions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_pendingTransactions')];
+            });
+        });
+    };
+    RpcProvider.prototype.getProtocolVersion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Pathfinder does not implement this rpc 0.1.0 method');
+            });
+        });
+    };
+    RpcProvider.prototype.getStateUpdate = function (blockIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            var block;
+            return __generator(this, function (_a) {
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getStateUpdate', [block.identifier])];
+            });
+        });
+    };
     RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var parsedKey, blockIdentifierGetter;
+            var parsedKey, block;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toHex)((0, number_1.toBN)(key));
-                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                block = new utils_1.Block(blockIdentifier);
                 return [2 /*return*/, this.fetchEndpoint('starknet_getStorageAt', [
                         contractAddress,
                         parsedKey,
-                        blockIdentifierGetter.getIdentifier(),
+                        block.identifier,
                     ])];
             });
         });
     };
-    // common interface
+    // Methods from Interface
     RpcProvider.prototype.getTransaction = function (txHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -183,8 +211,13 @@ var RpcProvider = /** @class */ (function () {
     };
     RpcProvider.prototype.getTransactionByBlockIdAndIndex = function (blockIdentifier, index) {
         return __awaiter(this, void 0, void 0, function () {
+            var block;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index])];
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByBlockIdAndIndex', [
+                        block.identifier,
+                        index,
+                    ])];
             });
         });
     };
@@ -195,15 +228,26 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    RpcProvider.prototype.getClass = function (classHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClass', [classHash])];
+            });
+        });
+    };
     RpcProvider.prototype.getClassAt = function (contractAddress, blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var blockIdentifierGetter;
+            var block;
             return __generator(this, function (_a) {
-                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
-                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [
-                        blockIdentifierGetter.getIdentifier(),
-                        contractAddress,
-                    ])];
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [block.identifier, contractAddress])];
+            });
+        });
+    };
+    RpcProvider.prototype.getCode = function (_contractAddress, _blockIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('RPC 0.1.0 does not implement getCode function');
             });
         });
     };
@@ -211,7 +255,9 @@ var RpcProvider = /** @class */ (function () {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         if (invocationDetails === void 0) { invocationDetails = {}; }
         return __awaiter(this, void 0, void 0, function () {
+            var block_id;
             return __generator(this, function (_a) {
+                block_id = new utils_1.Block(blockIdentifier).identifier;
                 return [2 /*return*/, this.fetchEndpoint('starknet_estimateFee', [
                         {
                             contract_address: invocation.contractAddress,
@@ -220,7 +266,7 @@ var RpcProvider = /** @class */ (function () {
                             signature: (0, number_1.bigNumberishArrayToHexadecimalStringArray)(invocation.signature || []),
                             version: (0, number_1.toHex)((0, number_1.toBN)((invocationDetails === null || invocationDetails === void 0 ? void 0 : invocationDetails.version) || 0)),
                         },
-                        blockIdentifier,
+                        block_id,
                     ]).then(this.responseParser.parseFeeEstimateResponse)];
             });
         });
@@ -276,20 +322,23 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    // Methods from Interface
     RpcProvider.prototype.callContract = function (call, blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var result;
+            var block_id, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.fetchEndpoint('starknet_call', [
-                            {
-                                contract_address: call.contractAddress,
-                                entry_point_selector: (0, hash_1.getSelectorFromName)(call.entrypoint),
-                                calldata: (0, provider_1.parseCalldata)(call.calldata),
-                            },
-                            blockIdentifier,
-                        ])];
+                    case 0:
+                        block_id = new utils_1.Block(blockIdentifier).identifier;
+                        return [4 /*yield*/, this.fetchEndpoint('starknet_call', [
+                                {
+                                    contract_address: call.contractAddress,
+                                    entry_point_selector: (0, hash_1.getSelectorFromName)(call.entrypoint),
+                                    calldata: (0, provider_1.parseCalldata)(call.calldata),
+                                },
+                                block_id,
+                            ])];
                     case 1:
                         result = _a.sent();
                         return [2 /*return*/, this.responseParser.parseCallContractResponse(result)];
@@ -297,10 +346,17 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getCode = function (_contractAddress, _blockIdentifier) {
+    RpcProvider.prototype.traceTransaction = function (transactionHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                throw new Error('RPC 0.1.0 does not implement getCode function');
+                return [2 /*return*/, this.fetchEndpoint('starknet_traceTransaction', [transactionHash])];
+            });
+        });
+    };
+    RpcProvider.prototype.traceBlockTransactions = function (blockHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_traceBlockTransactions', [blockHash])];
             });
         });
     };
@@ -312,7 +368,7 @@ var RpcProvider = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         onchain = false;
-                        retries = 100;
+                        retries = 200;
                         _a.label = 1;
                     case 1:
                         if (!!onchain) return [3 /*break*/, 7];
@@ -368,12 +424,10 @@ var RpcProvider = /** @class */ (function () {
      */
     RpcProvider.prototype.getTransactionCount = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var blockIdentifierGetter;
+            var block;
             return __generator(this, function (_a) {
-                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
-                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCount', [
-                        blockIdentifierGetter.getIdentifier(),
-                    ])];
+                block = new utils_1.Block(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCount', [block.identifier])];
             });
         });
     };

package/provider/sequencer.js

@@ -134,7 +134,8 @@ var SequencerProvider = /** @class */ (function () {
             .map(function (_a) {
             var _b = __read(_a, 2), key = _b[0], value = _b[1];
             if (key === 'blockIdentifier') {
-                return "".concat((0, utils_1.getFormattedBlockIdentifier)(value));
+                var block = new utils_1.Block(value);
+                return "".concat(block.queryIdentifier);
             }
             return "".concat(key, "=").concat(value);
         })