starknet 3.18.2 → 4.0.1

package/CHANGELOG.md

@@ -1,3 +1,73 @@
+## [4.0.1](https://github.com/0xs34n/starknet.js/compare/v4.0.0...v4.0.1) (2022-08-03)
+
+### Bug Fixes
+
+- use custom fetch ponyfill ([16e9a53](https://github.com/0xs34n/starknet.js/commit/16e9a530d62942da75ed1bc30d0048a35f9f0152))
+- use isomorphic-unfetch ([aa7af66](https://github.com/0xs34n/starknet.js/commit/aa7af6622d918ad0d17fe28bf1e73635895537c5))
+
+# [4.0.0](https://github.com/0xs34n/starknet.js/compare/v3.19.0...v4.0.0) (2022-07-27)
+
+### Documentation
+
+- v4 ([9e300a9](https://github.com/0xs34n/starknet.js/commit/9e300a98e587fc702ee3ef98441c457fe87e6c1e))
+
+### BREAKING CHANGES
+
+- new provider and signer interfaces
+
+# [3.19.0](https://github.com/0xs34n/starknet.js/compare/v3.18.2...v3.19.0) (2022-07-25)
+
+### Bug Fixes
+
+- account tests ([cc3f362](https://github.com/0xs34n/starknet.js/commit/cc3f362fffc157cb97e0fa2b8ff3a3db7dcf5985))
+- add invoke warning ([34db683](https://github.com/0xs34n/starknet.js/commit/34db683267b639adbd37eb097573eb7210cb4a58))
+- call contract latest block ([1476461](https://github.com/0xs34n/starknet.js/commit/1476461aeff6885b5185f45c5f8633f8c60cbfca))
+- ci ([808e1f7](https://github.com/0xs34n/starknet.js/commit/808e1f7a837e014d3c3781973b434df646c207b4))
+- ci ([6337feb](https://github.com/0xs34n/starknet.js/commit/6337febc9f6f6359f70d66be039779371f3186ff))
+- contract tests ([ffb6a12](https://github.com/0xs34n/starknet.js/commit/ffb6a12dec4c27f9b570fcc2016fb3c17f5dcfb4))
+- default provider tests ([2fac438](https://github.com/0xs34n/starknet.js/commit/2fac43876375a3d83818e152f4be5c3f219e8aff))
+- invoke response type ([bdeb96b](https://github.com/0xs34n/starknet.js/commit/bdeb96b896c96f7f7778fd38e697bf368f2a8510))
+- no secrets in matrix ([5ff7a26](https://github.com/0xs34n/starknet.js/commit/5ff7a2610c1c3f67ecb0a2b8d32e7c8c61017354))
+- nonce issue on test runs ([bed6fbf](https://github.com/0xs34n/starknet.js/commit/bed6fbf74b6446e18ea63444ddefaa782a7ffdf4))
+- pending getBlock test ([a9ea023](https://github.com/0xs34n/starknet.js/commit/a9ea023249c33369ed04b3f548bf98947240ff9e))
+- provider ([32f9072](https://github.com/0xs34n/starknet.js/commit/32f90724894eccd1b0154842180da38bcf6411fe))
+- provider tests ([79eb5ba](https://github.com/0xs34n/starknet.js/commit/79eb5bac4c03b64b6f3a2f3b59a1fea7bb930ce8))
+- provider tests ([255fd3c](https://github.com/0xs34n/starknet.js/commit/255fd3cb68f0edc7794f77623389f94ac341880a))
+- remove account test from contract tests ([d444e7f](https://github.com/0xs34n/starknet.js/commit/d444e7fb5f55a7a384dcc43a9ea0f1d09438364a))
+- remove comment ([591caf6](https://github.com/0xs34n/starknet.js/commit/591caf6e7983ecf009a95ab3f9e1b86335fe1a23))
+- remove hardcoded url ([c8f3377](https://github.com/0xs34n/starknet.js/commit/c8f3377d52f605dd03ab20879a5c7fd53aafe819))
+- remove test only ([5add341](https://github.com/0xs34n/starknet.js/commit/5add341257f8d6b355a367e977b125f9642f7630))
+- rename gateway to sequencer ([b7291e6](https://github.com/0xs34n/starknet.js/commit/b7291e654732bd5f57b2d477b20a5467dfc9854b))
+- rename rpc provider ([fee4fb3](https://github.com/0xs34n/starknet.js/commit/fee4fb3e36e9d824f0956174a9278f6131b3ba3e))
+- revert default block to pending ([28beff7](https://github.com/0xs34n/starknet.js/commit/28beff76107f762478e70974389eb75202a65d42))
+- rpc provider account tests ([b2fc530](https://github.com/0xs34n/starknet.js/commit/b2fc53004a1e52149b3fa4e7357c3ade1d01cd4a))
+- rpc provider tests ([12db930](https://github.com/0xs34n/starknet.js/commit/12db930b1babf3e3de035426c8c449bfb448951c))
+- rpc provider waitForTransaction ([9e708ba](https://github.com/0xs34n/starknet.js/commit/9e708ba72ea350ae4866e5cff9519a89201b5b01))
+- run only devnet on pr ([613084b](https://github.com/0xs34n/starknet.js/commit/613084b32f93540e5f11938196d7b2c003f12bbf))
+- seperate types and fix fees ([577a836](https://github.com/0xs34n/starknet.js/commit/577a836b48a4567d63f0138163d016422256d221))
+- set rpc url in pr workflow ([89ec3c1](https://github.com/0xs34n/starknet.js/commit/89ec3c1edfd6947404d009420305d7bb210c6cd3))
+- test account ([ac8210a](https://github.com/0xs34n/starknet.js/commit/ac8210a6bbb159a17ab548a12f7a20823e55814a))
+- tests should wait for build ([af8c5c7](https://github.com/0xs34n/starknet.js/commit/af8c5c779370e170de4785902e1e9ac282f2bfec))
+- update jsdocs ([2c08e5d](https://github.com/0xs34n/starknet.js/commit/2c08e5d8fe80469ba41222767193823b3d516536))
+- use rpc conditionally ([7023068](https://github.com/0xs34n/starknet.js/commit/70230682343b682df50da21cb9e7a7f54490091c))
+- waitForTransaction ([4f0c00b](https://github.com/0xs34n/starknet.js/commit/4f0c00b568a174db51ecef918d8a8878254daba5))
+- www/docs/API/contract.md ([3ca4a51](https://github.com/0xs34n/starknet.js/commit/3ca4a513950f4aa27ac447835fcefcebbece083b))
+- www/docs/API/provider.md ([d73e826](https://github.com/0xs34n/starknet.js/commit/d73e8264527a5af21e1d8e7a7c1f3aa8b8c92fb8))
+
+### Features
+
+- adapt abstract provider interface to RPC provider ([b217b3b](https://github.com/0xs34n/starknet.js/commit/b217b3bd1e40c60427636ccad03583e901f6ba58))
+- add account rpc tests ([fc3b484](https://github.com/0xs34n/starknet.js/commit/fc3b4846486e63f2ff5eaba78844235091f2d49e))
+- add gateway provider class ([dad1eea](https://github.com/0xs34n/starknet.js/commit/dad1eea9caafc71c940262ee13dd75817996abfd))
+- add provider utils ([4df4ae7](https://github.com/0xs34n/starknet.js/commit/4df4ae7e8b8111669e2bc20e30c2c89af9c50a4f))
+- add rpc provider ([315bb74](https://github.com/0xs34n/starknet.js/commit/315bb747f26ba19556841a326484a7dbfa1a2857))
+- change estimate fee response on rpc provider ([942f4f2](https://github.com/0xs34n/starknet.js/commit/942f4f2508fab697e796ee9f691341b86ccd34be))
+- change provider keys to snake case ([2ee4b0b](https://github.com/0xs34n/starknet.js/commit/2ee4b0bf0892a3bd54e6d188990f979298814551))
+- getStorageAt block param ([d89bf30](https://github.com/0xs34n/starknet.js/commit/d89bf307796e69627ffd91ebd97c787e4a7a77e7))
+- implement new interface on account class ([b202f37](https://github.com/0xs34n/starknet.js/commit/b202f37ab72fd310a8c99b28863f38b8d142d2a7))
+- implement new interface on contract class ([e942a9d](https://github.com/0xs34n/starknet.js/commit/e942a9d88479d88b82a3dbc05ec2f60ab9ad1f19))
+- use shared describe block for providers ([b525a60](https://github.com/0xs34n/starknet.js/commit/b525a60eb77647962f4509bb02f64bb66071c9c2))
+
 ## [3.18.2](https://github.com/0xs34n/starknet.js/compare/v3.18.1...v3.18.2) (2022-07-25)
 
 ### Bug Fixes

package/README.md

@@ -40,7 +40,7 @@ Install starknet with `npm`
 
 ```bash
 $ npm install starknet
-# or for pre-release features:
+# or for starknet.js v4:
 $ npm install starknet@next
 ```
 
@@ -85,4 +85,3 @@ This library would not be possible without these rockstars.
 Copyright (c) 2022 0xs34n
 
 Licensed under the [MIT license](https://github.com/0xs34n/starknet.js/blob/main/LICENSE).
-

package/__tests__/account.test.ts

@@ -1,19 +1,13 @@
 import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import { Account, Contract, Provider, ec, number, stark } from '../src';
+import { Account, Contract, Provider, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import {
-  compiledErc20,
-  compiledOpenZeppelinAccount,
-  compiledTestDapp,
-  getTestAccount,
-  getTestProvider,
-} from './fixtures';
+import { compiledErc20, compiledTestDapp, getTestAccount, getTestProvider } from './fixtures';
 
 describe('deploy and test Wallet', () => {
-  const account = getTestAccount();
   const provider = getTestProvider();
+  const account = getTestAccount(provider);
   let erc20: Contract;
   let erc20Address: string;
   let dapp: Contract;
@@ -25,9 +19,8 @@ describe('deploy and test Wallet', () => {
       contract: compiledErc20,
     });
 
-    erc20Address = erc20Response.address!;
+    erc20Address = erc20Response.contract_address;
     erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
-    expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
     await provider.waitForTransaction(erc20Response.transaction_hash);
 
@@ -37,8 +30,6 @@ describe('deploy and test Wallet', () => {
       calldata: [account.address, '1000'],
     });
 
-    expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
-
     await provider.waitForTransaction(mintResponse.transaction_hash);
 
     const x = await erc20.balance_of(account.address);
@@ -48,20 +39,18 @@ describe('deploy and test Wallet', () => {
     const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
     });
-    dapp = new Contract(compiledTestDapp.abi, dappResponse.address!, provider);
-    expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
+    dapp = new Contract(compiledTestDapp.abi, dappResponse.contract_address!, provider);
 
     await provider.waitForTransaction(dappResponse.transaction_hash);
   });
 
   test('estimate fee', async () => {
-    const { amount, unit } = await account.estimateFee({
+    const { overall_fee } = await account.estimateFee({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
       calldata: [erc20.address, '10'],
     });
-    expect(isBN(amount)).toBe(true);
-    expect(typeof unit).toBe('string');
+    expect(isBN(overall_fee)).toBe(true);
   });
 
   test('read balance of wallet', async () => {
@@ -71,13 +60,12 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute by wallet owner', async () => {
-    const { code, transaction_hash } = await account.execute({
+    const { transaction_hash } = await account.execute({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
       calldata: [erc20.address, '10'],
     });
 
-    expect(code).toBe('TRANSACTION_RECEIVED');
     await provider.waitForTransaction(transaction_hash);
   });
 
@@ -93,7 +81,7 @@ describe('deploy and test Wallet', () => {
       entrypoint: 'get_nonce',
     });
     const nonce = toBN(result[0]).toNumber();
-    const { code, transaction_hash } = await account.execute(
+    const { transaction_hash } = await account.execute(
       {
         contractAddress: erc20Address,
         entrypoint: 'transfer',
@@ -103,12 +91,11 @@ describe('deploy and test Wallet', () => {
       { nonce }
     );
 
-    expect(code).toBe('TRANSACTION_RECEIVED');
     await provider.waitForTransaction(transaction_hash);
   });
 
   test('execute multiple transactions', async () => {
-    const { code, transaction_hash } = await account.execute([
+    const { transaction_hash } = await account.execute([
       {
         contractAddress: dapp.address,
         entrypoint: 'set_number',
@@ -121,7 +108,6 @@ describe('deploy and test Wallet', () => {
       },
     ]);
 
-    expect(code).toBe('TRANSACTION_RECEIVED');
     await provider.waitForTransaction(transaction_hash);
 
     const response = await dapp.get_number(account.address);
@@ -140,34 +126,6 @@ describe('deploy and test Wallet', () => {
     expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
   });
 
-  describe('new deployed account', () => {
-    let newAccount: Account;
-
-    beforeAll(async () => {
-      const starkKeyPair = ec.genKeyPair();
-      const starkKeyPub = ec.getStarkKey(starkKeyPair);
-
-      const accountResponse = await provider.deployContract({
-        contract: compiledOpenZeppelinAccount,
-        constructorCalldata: [starkKeyPub],
-      });
-
-      await provider.waitForTransaction(accountResponse.transaction_hash);
-
-      newAccount = new Account(provider, accountResponse.address!, starkKeyPair);
-    });
-
-    test('read nonce', async () => {
-      const { result } = await account.callContract({
-        contractAddress: newAccount.address,
-        entrypoint: 'get_nonce',
-      });
-      const nonce = result[0];
-
-      expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
-    });
-  });
-
   describe('Contract interaction with Account', () => {
     const wallet = stark.randomAddress();
 
@@ -178,8 +136,6 @@ describe('deploy and test Wallet', () => {
         calldata: [wallet, '1000'],
       });
 
-      expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
-
       await provider.waitForTransaction(mintResponse.transaction_hash);
     });
 
@@ -191,8 +147,7 @@ describe('deploy and test Wallet', () => {
 
     test('estimate gas fee for `mint`', async () => {
       const res = await erc20.estimateFee.mint(wallet, '10');
-      expect(res).toHaveProperty('amount');
-      expect(res).toHaveProperty('unit');
+      expect(res).toHaveProperty('overall_fee');
     });
   });
 });

package/__tests__/contract.test.ts

@@ -1,6 +1,6 @@
 import { isBN } from 'bn.js';
 
-import { Account, Contract, ContractFactory, Provider, stark } from '../src';
+import { Contract, ContractFactory, stark } from '../src';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
@@ -8,7 +8,6 @@ import {
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
-  getTestAccount,
   getTestProvider,
 } from './fixtures';
 
@@ -22,26 +21,20 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await provider.deployContract({
+      const { transaction_hash, contract_address } = await provider.deployContract({
         contract: compiledErc20,
       });
-      erc20 = new Contract(compiledErc20.abi, address!, provider);
-      expect(code).toBe('TRANSACTION_RECEIVED');
+      erc20 = new Contract(compiledErc20.abi, contract_address!, provider);
       await provider.waitForTransaction(transaction_hash);
       // Deploy Multicall
 
-      const {
-        code: m_code,
-        transaction_hash: m_transaction_hash,
-        address: multicallAddress,
-      } = await provider.deployContract({
-        contract: compiledMulticall,
-      });
+      const { transaction_hash: m_transaction_hash, contract_address: multicallAddress } =
+        await provider.deployContract({
+          contract: compiledMulticall,
+        });
 
       contract = new Contract(compiledMulticall.abi, multicallAddress!, provider);
 
-      expect(m_code).toBe('TRANSACTION_RECEIVED');
-
       await provider.waitForTransaction(m_transaction_hash);
     });
 
@@ -92,11 +85,10 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await provider.deployContract({
+      const { transaction_hash, contract_address } = await provider.deployContract({
         contract: compiledTypeTransformation,
       });
-      contract = new Contract(compiledTypeTransformation.abi, address!, provider);
-      expect(code).toBe('TRANSACTION_RECEIVED');
+      contract = new Contract(compiledTypeTransformation.abi, contract_address!, provider);
       await provider.waitForTransaction(transaction_hash);
     });
 
@@ -195,46 +187,16 @@ describe('class Contract {}', () => {
       });
     });
   });
-
-  describe('Contract interaction with Account', () => {
-    const account = getTestAccount();
-    let erc20: Contract;
-    let erc20Address: string;
-
-    beforeAll(async () => {
-      const erc20Response = await provider.deployContract({
-        contract: compiledErc20,
-      });
-      erc20Address = erc20Response.address!;
-      erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
-      expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
-      await provider.waitForTransaction(erc20Response.transaction_hash);
-    });
-
-    test('read balance of wallet', async () => {
-      const result = await erc20.balance_of(account.address);
-      const [res] = result;
-      expect(res).toStrictEqual(toBN(0));
-      expect(res).toStrictEqual(result.res);
-    });
-
-    test('change from provider to account', async () => {
-      expect(erc20.providerOrAccount instanceof Provider);
-      erc20.connect(account);
-      expect(erc20.providerOrAccount instanceof Account);
-    });
-  });
 });
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
   beforeAll(async () => {
-    const { code, transaction_hash, address } = await provider.deployContract({
+    const { transaction_hash, contract_address } = await provider.deployContract({
       contract: compiledErc20,
     });
-    expect(code).toBe('TRANSACTION_RECEIVED');
     await provider.waitForTransaction(transaction_hash);
-    erc20Address = address!;
+    erc20Address = contract_address;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20, provider);

package/__tests__/defaultProvider.test.ts

@@ -0,0 +1,321 @@
+import {
+  BlockNumber,
+  DeclareContractResponse,
+  DeployContractResponse,
+  GetBlockResponse,
+  stark,
+} from '../src';
+import { toBN } from '../src/utils/number';
+import {
+  compiledErc20,
+  compiledOpenZeppelinAccount,
+  describeIfNotDevnet,
+  getTestProvider,
+} from './fixtures';
+
+const { compileCalldata } = stark;
+
+const testProvider = getTestProvider();
+
+describe('defaultProvider', () => {
+  let exampleTransactionHash: string;
+  let exampleContractAddress: string;
+
+  let exampleBlock: GetBlockResponse;
+  let exampleBlockNumber: BlockNumber;
+  let exampleBlockHash: string;
+
+  beforeAll(async () => {
+    const { transaction_hash, contract_address } = await testProvider.deployContract({
+      contract: compiledErc20,
+    });
+    await testProvider.waitForTransaction(transaction_hash);
+    exampleTransactionHash = transaction_hash;
+    exampleContractAddress = contract_address;
+
+    exampleBlock = await testProvider.getBlock('latest');
+    exampleBlockHash = exampleBlock.block_hash;
+    exampleBlockNumber = exampleBlock.block_number;
+  });
+
+  describe('endpoints', () => {
+    test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, () => {
+      return expect(testProvider.getBlock(exampleBlockNumber)).resolves.not.toThrow();
+    });
+
+    test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, () => {
+      return expect(testProvider.getBlock(exampleBlockHash)).resolves.not.toThrow();
+    });
+
+    test('getBlock(blockIdentifier=latest)', async () => {
+      expect(exampleBlock).not.toBeNull();
+
+      const { block_number, accepted_time } = exampleBlock;
+
+      expect(typeof block_number).toEqual('number');
+
+      return expect(typeof accepted_time).toEqual('number');
+    });
+
+    test('getBlock() -> { blockNumber }', async () => {
+      const block = await testProvider.getBlock();
+      return expect(block).toHaveProperty('block_number');
+    });
+
+    describe('getStorageAt', () => {
+      test('with "key" type of number', () => {
+        return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
+      });
+
+      test('"key" type of string', () => {
+        return expect(
+          testProvider.getStorageAt(exampleContractAddress, '0x0')
+        ).resolves.not.toThrow();
+      });
+
+      test('with "key" type of BN', () => {
+        return expect(
+          testProvider.getStorageAt(exampleContractAddress, toBN('0x0'))
+        ).resolves.not.toThrow();
+      });
+    });
+
+    test('getTransaction() - successful transaction', async () => {
+      const transaction = await testProvider.getTransaction(exampleTransactionHash);
+
+      expect(transaction).toHaveProperty('transaction_hash');
+    });
+
+    test('getTransactionReceipt() - successful transaction', async () => {
+      const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
+
+      return expect(transactionReceipt).toHaveProperty('actual_fee');
+    });
+
+    test('callContract()', () => {
+      return expect(
+        testProvider.callContract({
+          contractAddress: exampleContractAddress,
+          entrypoint: 'balance_of',
+          calldata: compileCalldata({
+            user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+          }),
+        })
+      ).resolves.not.toThrow();
+    });
+
+    test('callContract() - gateway error', async () => {
+      return expect(
+        testProvider.callContract({
+          contractAddress: exampleContractAddress,
+          entrypoint: 'non_existent_entrypoint',
+          calldata: compileCalldata({
+            user: '0xdeadbeef',
+          }),
+        })
+      ).rejects.toThrowError();
+    });
+  });
+
+  describe('addTransaction()', () => {
+    test('declareContract()', async () => {
+      const response = await testProvider.declareContract({
+        contract: compiledErc20,
+      });
+
+      expect(response.transaction_hash).toBeDefined();
+      expect(response.class_hash).toBeDefined();
+    });
+
+    test('deployContract()', async () => {
+      const response = await testProvider.deployContract({
+        contract: compiledOpenZeppelinAccount,
+      });
+
+      expect(response.transaction_hash).toBeDefined();
+      expect(response.contract_address).toBeDefined();
+    });
+  });
+
+  describeIfNotDevnet('Provider', () => {
+    const provider = getTestProvider();
+    describe(`Provider methods`, () => {
+      describe('getBlock', () => {
+        test('pending', async () => {
+          const latestBlock = await provider.getBlock();
+          expect(latestBlock).toHaveProperty('block_hash');
+          expect(latestBlock).toHaveProperty('parent_hash');
+          expect(latestBlock).toHaveProperty('block_number');
+          expect(latestBlock).toHaveProperty('status');
+          expect(latestBlock).toHaveProperty('sequencer');
+          expect(latestBlock).toHaveProperty('new_root');
+          expect(latestBlock).toHaveProperty('old_root');
+          expect(latestBlock).toHaveProperty('accepted_time');
+          expect(latestBlock).toHaveProperty('gas_price');
+          expect(latestBlock).toHaveProperty('transactions');
+          expect(Array.isArray(latestBlock.transactions)).toBe(true);
+        });
+
+        test('Block Hash 0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43', async () => {
+          const block = await provider.getBlock(
+            '0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43'
+          );
+
+          expect(block).toHaveProperty('block_hash');
+          expect(block).toHaveProperty('parent_hash');
+          expect(block).toHaveProperty('block_number');
+          expect(block).toHaveProperty('status');
+          expect(block).toHaveProperty('sequencer');
+          expect(block).toHaveProperty('new_root');
+          expect(block).toHaveProperty('old_root');
+          expect(block).toHaveProperty('accepted_time');
+          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('transactions');
+          expect(Array.isArray(block.transactions)).toBe(true);
+        });
+
+        test('Block Number 102634', async () => {
+          const block = await provider.getBlock(102634);
+          expect(block).toHaveProperty('block_hash');
+          expect(block).toHaveProperty('parent_hash');
+          expect(block).toHaveProperty('block_number');
+          expect(block).toHaveProperty('status');
+          expect(block).toHaveProperty('sequencer');
+          expect(block).toHaveProperty('new_root');
+          expect(block).toHaveProperty('old_root');
+          expect(block).toHaveProperty('accepted_time');
+          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('transactions');
+          expect(Array.isArray(block.transactions)).toBe(true);
+        });
+      });
+
+      describe('getStorageAt', () => {
+        test('pending', async () => {
+          const storage = await provider.getStorageAt(
+            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+            0
+          );
+          expect(typeof storage).toBe('string');
+        });
+
+        test('Block Hash 0x7104702055c2a5773a870ceada9552ec659d69c18053b14078983f07527dea8', async () => {
+          const storage = await provider.getStorageAt(
+            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+            0,
+            '0x7225762c7ff5e7e5f0867f0a8e73594df4f44f05a65375339a76398e8ae3e64'
+          );
+          expect(typeof storage).toBe('string');
+        });
+      });
+
+      describe('getTransaction', () => {
+        test('Deploy Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
+          const transaction = await provider.getTransaction(
+            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
+          );
+
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction.contract_address).toBeTruthy();
+        });
+
+        test('Invoke Transaction Hash 0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b', async () => {
+          const transaction = await provider.getTransaction(
+            '0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b'
+          );
+
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction.contract_address).toBeTruthy();
+          expect(Array.isArray(transaction.calldata)).toBe(true);
+          expect(transaction.entry_point_selector).toBeTruthy();
+          expect(Array.isArray(transaction.signature)).toBe(true);
+          expect(transaction.max_fee).toBeTruthy();
+        });
+
+        test('Declare Transaction Hash 0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea', async () => {
+          const transaction = await provider.getTransaction(
+            '0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea'
+          );
+
+          expect(transaction.max_fee).toBeTruthy();
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction).toHaveProperty('nonce');
+          expect(transaction).toHaveProperty('sender_address');
+          expect(transaction).toHaveProperty('version');
+        });
+      });
+
+      describe('getTransactionReceipt', () => {
+        test('Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
+          const receipt = await provider.getTransactionReceipt(
+            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
+          );
+
+          expect(receipt).toHaveProperty('transaction_hash');
+          expect(receipt).toHaveProperty('status');
+          expect(receipt).toHaveProperty('status_data');
+          expect(receipt).toHaveProperty('messages_sent');
+          expect(receipt).toHaveProperty('l1_origin_message');
+          expect(receipt).toHaveProperty('events');
+        });
+      });
+
+      describe('Contract methods', () => {
+        let contractAddress: string;
+        let deployResponse: DeployContractResponse;
+        let declareResponse: DeclareContractResponse;
+
+        beforeAll(async () => {
+          deployResponse = await provider.deployContract({ contract: compiledErc20 });
+          contractAddress = deployResponse.contract_address;
+          declareResponse = await provider.declareContract({ contract: compiledErc20 });
+          await Promise.all([
+            provider.waitForTransaction(deployResponse.transaction_hash),
+            provider.waitForTransaction(declareResponse.transaction_hash),
+          ]);
+        });
+
+        describe('deployContract', () => {
+          test('response', () => {
+            expect(deployResponse.contract_address).toBeTruthy();
+            expect(deployResponse.transaction_hash).toBeTruthy();
+          });
+        });
+
+        describe('declareContract', () => {
+          test('response', async () => {
+            expect(declareResponse.class_hash).toBeTruthy();
+            expect(declareResponse.transaction_hash).toBeTruthy();
+          });
+        });
+
+        describe('getClassAt', () => {
+          test('response', async () => {
+            const classResponse = await provider.getClassAt(contractAddress);
+
+            expect(classResponse).toHaveProperty('program');
+            expect(classResponse).toHaveProperty('entry_points_by_type');
+          });
+        });
+
+        describe('callContract', () => {
+          test('result', () => {
+            return expect(
+              provider
+                .callContract({
+                  contractAddress: deployResponse.contract_address,
+                  entrypoint: 'balance_of',
+                  calldata: compileCalldata({
+                    user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+                  }),
+                })
+                .then((res) => {
+                  expect(Array.isArray(res.result)).toBe(true);
+                })
+            ).resolves.not.toThrow();
+          });
+        });
+      });
+    });
+  });
+});