starknet 4.5.0 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [4.6.0](https://github.com/0xs34n/starknet.js/compare/v4.5.0...v4.6.0) (2022-09-15)
+
+### Bug Fixes
+
+- add test getTransactionCount [skip ci] ([342755a](https://github.com/0xs34n/starknet.js/commit/342755aa99dda016d7aa394a0023b3f2e5d5e963))
+- estimateFee and call block id ([ef1645f](https://github.com/0xs34n/starknet.js/commit/ef1645f740e7c29edea6b091bec9949ec713953f))
+- rpc test update, comepleted rpc to openrpc mapping, rpc provider methods ([8b41e0f](https://github.com/0xs34n/starknet.js/commit/8b41e0fcf36b34b20dfaba356cfc0131f02d7d69))
+
+### Features
+
+- new Block utility object, rpc fetch clenup, open rpc fetch api ([0d381c8](https://github.com/0xs34n/starknet.js/commit/0d381c89fe655b2628f02e67095ef03cb1721398))
+- read, write and trace api ([d488ab2](https://github.com/0xs34n/starknet.js/commit/d488ab2513b88fdeb4e27b6ec2b7226ffd359445))
+- retry rpc wait for transaction 200 times instead of 100 ([3bc9118](https://github.com/0xs34n/starknet.js/commit/3bc9118cae86fba21e1c85667079079662ba0b7b))
+- updated rpc tests with new methods ([e369d95](https://github.com/0xs34n/starknet.js/commit/e369d95d72f3b39b3e8b8baa99867b94c1d5d1c1))
+
 # [4.5.0](https://github.com/0xs34n/starknet.js/compare/v4.4.2...v4.5.0) (2022-09-09)
 
 ### Bug Fixes

package/README.md

@@ -39,8 +39,10 @@
 Install starknet with `npm`
 
 ```bash
+# latest official release (main branch)
 $ npm install starknet
-# or for starknet.js v4:
+
+# or for latest pre-release version (develop branch):
 $ npm install starknet@next
 ```
 

package/__tests__/defaultProvider.test.ts

@@ -139,10 +139,11 @@ describe('defaultProvider', () => {
 
   describeIfNotDevnet('Provider', () => {
     const provider = getTestProvider();
+    let latestBlock;
     describe(`Provider methods if not devnet`, () => {
       describe('getBlock', () => {
-        test('pending', async () => {
-          const latestBlock = await provider.getBlock();
+        test('getBlock by tag pending', async () => {
+          latestBlock = await provider.getBlock();
           expect(latestBlock).toHaveProperty('block_hash');
           expect(latestBlock).toHaveProperty('parent_hash');
           expect(latestBlock).toHaveProperty('block_number');
@@ -153,11 +154,8 @@ describe('defaultProvider', () => {
           expect(Array.isArray(latestBlock.transactions)).toBe(true);
         });
 
-        test('Block Hash 0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43', async () => {
-          const block = await provider.getBlock(
-            '0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43'
-          );
-
+        test('getBlock by Hash', async () => {
+          const block = await provider.getBlock(latestBlock.block_hash);
           expect(block).toHaveProperty('block_hash');
           expect(block).toHaveProperty('parent_hash');
           expect(block).toHaveProperty('block_number');
@@ -168,8 +166,8 @@ describe('defaultProvider', () => {
           expect(Array.isArray(block.transactions)).toBe(true);
         });
 
-        test('Block Number 102634', async () => {
-          const block = await provider.getBlock(102634);
+        test('getBlock by Number', async () => {
+          const block = await provider.getBlock(latestBlock.block_number);
           expect(block).toHaveProperty('block_hash');
           expect(block).toHaveProperty('parent_hash');
           expect(block).toHaveProperty('block_number');

package/__tests__/rpcProvider.test.ts

@@ -1,5 +1,6 @@
-import { Account, RpcProvider, ec } from '../src';
+import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
 import {
+  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfRpc,
   getTestAccount,
@@ -20,21 +21,115 @@ describeIfRpc('RPCProvider', () => {
     accountPublicKey = ec.getStarkKey(accountKeyPair);
   });
 
+  test('getChainId', async () => {
+    const chainId = await rpcProvider.getChainId();
+    expect(chainId).toBe('0x534e5f474f45524c49');
+  });
+
+  test('getPendingTransactions', async () => {
+    const transactions = await rpcProvider.getPendingTransactions();
+    expect(Array.isArray(transactions)).toBe(true);
+  });
+
+  test('getTransactionCount', async () => {
+    const count = await rpcProvider.getTransactionCount('latest');
+    expect(typeof count).toBe('number');
+  });
+
+  test('getBlockHashAndNumber', async () => {
+    const blockHashAndNumber = await rpcProvider.getBlockHashAndNumber();
+    expect(blockHashAndNumber).toHaveProperty('block_hash');
+    expect(blockHashAndNumber).toHaveProperty('block_number');
+  });
+
+  test('getStateUpdate', async () => {
+    const stateUpdate = await rpcProvider.getStateUpdate('latest');
+    expect(stateUpdate).toHaveProperty('block_hash');
+    expect(stateUpdate).toHaveProperty('new_root');
+    expect(stateUpdate).toHaveProperty('old_root');
+    expect(stateUpdate).toHaveProperty('state_diff');
+  });
+
+  xtest('getProtocolVersion', async () => {
+    await rpcProvider.getProtocolVersion();
+  });
+
   describe('RPC methods', () => {
-    test('getChainId', async () => {
-      const chainId = await rpcProvider.getChainId();
-      expect(chainId).toBe('0x534e5f474f45524c49');
+    let latestBlock: GetBlockResponse;
+
+    beforeAll(async () => {
+      latestBlock = await rpcProvider.getBlock('latest');
+    });
+
+    test('getBlockWithTxHashes', async () => {
+      const blockResponse = await rpcProvider.getBlockWithTxHashes(latestBlock.block_number);
+      expect(blockResponse).toHaveProperty('transactions');
+    });
+
+    test('getBlockWithTxs', async () => {
+      const blockResponse = await rpcProvider.getBlockWithTxs(latestBlock.block_number);
+      expect(blockResponse).toHaveProperty('transactions');
+    });
+
+    test('getTransactionByBlockIdAndIndex', async () => {
+      const transaction = await rpcProvider.getTransactionByBlockIdAndIndex(
+        latestBlock.block_number,
+        0
+      );
+      expect(transaction).toHaveProperty('transaction_hash');
+    });
+
+    xtest('traceBlockTransactions', async () => {
+      await rpcProvider.traceBlockTransactions(latestBlock.block_hash);
+    });
+
+    describe('deploy contract related tests', () => {
+      let contract_address;
+      let transaction_hash;
+
+      beforeAll(async () => {
+        ({ contract_address, transaction_hash } = await rpcProvider.deployContract({
+          contract: compiledOpenZeppelinAccount,
+          constructorCalldata: [accountPublicKey],
+          addressSalt: accountPublicKey,
+        }));
+        await rpcProvider.waitForTransaction(transaction_hash);
+      });
+
+      test('deployContract result', () => {
+        expect(contract_address).toBeTruthy();
+        expect(transaction_hash).toBeTruthy();
+      });
+
+      test('getTransactionByHash', async () => {
+        const transaction = await rpcProvider.getTransactionByHash(transaction_hash);
+        expect(transaction).toHaveProperty('transaction_hash');
+      });
+
+      test('getClassHashAt', async () => {
+        const classHash = await rpcProvider.getClassHashAt('latest', contract_address);
+        expect(typeof classHash).toBe('string');
+      });
+
+      xtest('traceTransaction', async () => {
+        await rpcProvider.traceTransaction(transaction_hash);
+      });
     });
 
-    test('deployContract', async () => {
-      const { contract_address, transaction_hash } = await rpcProvider.deployContract({
-        contract: compiledOpenZeppelinAccount,
-        constructorCalldata: [accountPublicKey],
-        addressSalt: accountPublicKey,
+    describe('declare contract related tests', () => {
+      let class_hash;
+
+      beforeAll(async () => {
+        ({ class_hash } = await rpcProvider.declareContract({
+          contract: compiledErc20,
+        }));
+      });
+
+      test('getClass', async () => {
+        const contractClass = await rpcProvider.getClass(class_hash);
+        expect(contractClass).toHaveProperty('program');
+        expect(contractClass).toHaveProperty('entry_points_by_type');
       });
-      await rpcProvider.waitForTransaction(transaction_hash);
-      expect(contract_address).toBeTruthy();
-      expect(transaction_hash).toBeTruthy();
     });
 
     test.todo('getEstimateFee');

package/__tests__/utils/utils.test.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 
 import { constants, hash, json, number, stark } from '../../src';
+import { Block } from '../../src/provider/utils';
 import { pedersen } from '../../src/utils/hash';
 
 const { IS_BROWSER } = constants;
@@ -112,3 +113,19 @@ describe('calculateContractAddressFromHash()', () => {
     );
   });
 });
+
+describe('new Block()', () => {
+  test('Block identifier and queryIdentifier', () => {
+    const blockA = new Block(0);
+    expect(blockA.identifier).toMatchObject({ block_number: 0 });
+    expect(blockA.queryIdentifier).toBe('blockNumber=0');
+
+    const blockB = new Block('latest');
+    expect(blockB.identifier).toBe('latest');
+    expect(blockB.queryIdentifier).toBe('blockNumber=latest');
+
+    const blockC = new Block('0x01');
+    expect(blockC.identifier).toMatchObject({ block_hash: '0x01' });
+    expect(blockC.queryIdentifier).toBe('blockHash=0x01');
+  });
+});

package/dist/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/dist/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/dist/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);
         })