starknet 4.17.0 → 4.18.0

package/__tests__/contract.test.ts

@@ -1,249 +0,0 @@
-import { isBN } from 'bn.js';
-
-import { Contract, ContractFactory, stark } from '../src';
-import { getSelectorFromName } from '../src/utils/hash';
-import { BigNumberish, toBN } from '../src/utils/number';
-import { encodeShortString } from '../src/utils/shortString';
-import { compileCalldata } from '../src/utils/stark';
-import {
-  compiledErc20,
-  compiledMulticall,
-  compiledTypeTransformation,
-  getTestAccount,
-  getTestProvider,
-} from './fixtures';
-
-describe('contract module', () => {
-  let erc20Address: string;
-  const provider = getTestProvider();
-  const wallet = stark.randomAddress();
-  const account = getTestAccount(provider);
-  const constructorCalldata = [encodeShortString('Token'), encodeShortString('ERC20'), wallet];
-  const classHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
-
-  describe('class Contract {}', () => {
-    describe('Basic Interaction', () => {
-      let erc20Contract: Contract;
-      let multicallContract: Contract;
-
-      beforeAll(async () => {
-        const { deploy } = await account.declareDeploy({
-          contract: compiledErc20,
-          classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
-          constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
-        });
-
-        erc20Contract = new Contract(compiledErc20.abi, deploy.contract_address!, provider);
-
-        const { deploy: multicallDeploy } = await account.declareDeploy({
-          contract: compiledMulticall,
-          classHash: '0x06f94f3229a8d9c1d51cb84f1f5ec306c8552a805e307540727dda53c4936b43',
-        });
-
-        multicallContract = new Contract(
-          compiledMulticall.abi,
-          multicallDeploy.contract_address!,
-          provider
-        );
-      });
-
-      test('populate transaction for initial balance of that account', async () => {
-        const res = await erc20Contract.populateTransaction.balanceOf(wallet);
-        expect(res).toHaveProperty('contractAddress');
-        expect(res).toHaveProperty('entrypoint');
-        expect(res).toHaveProperty('calldata');
-      });
-
-      test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
-        expect(erc20Contract.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
-      });
-
-      test('read initial balance of that account', async () => {
-        const result = await erc20Contract.balanceOf(wallet);
-        const [res] = result;
-        expect(res.low).toStrictEqual(toBN(1000));
-        expect(res).toStrictEqual(result.balance);
-      });
-
-      test('read balance in a multicall', async () => {
-        const args1 = { user: wallet };
-        const args2 = {};
-        const calls = [
-          erc20Contract.address,
-          getSelectorFromName('balanceOf'),
-          Object.keys(args1).length,
-          ...compileCalldata(args1),
-
-          erc20Contract.address,
-          getSelectorFromName('decimals'),
-          Object.keys(args2).length,
-          ...compileCalldata(args2),
-        ];
-        const result = await multicallContract.aggregate(calls);
-        const [block_number, res] = result;
-        expect(isBN(block_number));
-        expect(Array.isArray(res));
-        (res as BigNumberish[]).forEach((el) => expect(isBN(el)));
-        expect(block_number).toStrictEqual(result.block_number);
-        expect(res).toStrictEqual(result.result);
-      });
-    });
-
-    describe('Type Transformation', () => {
-      let typeTransformedContract: Contract;
-
-      beforeAll(async () => {
-        const { deploy } = await account.declareDeploy({
-          contract: compiledTypeTransformation,
-          classHash: '0x022a0e662b13d18a2aaa3ee54ae290de6569621b549022c18169c6e7893809ea',
-        });
-
-        typeTransformedContract = new Contract(
-          compiledTypeTransformation.abi,
-          deploy.contract_address!,
-          provider
-        );
-      });
-
-      describe('Request Type Transformation', () => {
-        test('Parsing the felt in request', async () => {
-          return expect(typeTransformedContract.request_felt(3)).resolves.not.toThrow();
-        });
-
-        test('Parsing the array of felt in request', async () => {
-          return expect(
-            typeTransformedContract.request_array_of_felts([1, 2])
-          ).resolves.not.toThrow();
-        });
-
-        test('Parsing the struct in request', async () => {
-          return expect(
-            typeTransformedContract.request_struct({ x: 1, y: 2 })
-          ).resolves.not.toThrow();
-        });
-
-        test('Parsing the array of structs in request', async () => {
-          return expect(
-            typeTransformedContract.request_array_of_structs([{ x: 1, y: 2 }])
-          ).resolves.not.toThrow();
-        });
-
-        test('Parsing the nested structs in request', async () => {
-          return expect(
-            typeTransformedContract.request_nested_structs({
-              p1: { x: 1, y: 2 },
-              p2: { x: 3, y: 4 },
-              extra: 5,
-            })
-          ).resolves.not.toThrow();
-        });
-
-        test('Parsing the tuple in request', async () => {
-          return expect(typeTransformedContract.request_tuple([1, 2])).resolves.not.toThrow();
-        });
-
-        test('Parsing the multiple types in request', async () => {
-          return expect(
-            typeTransformedContract.request_mixed_types(2, { x: 1, y: 2 }, [1])
-          ).resolves.not.toThrow();
-        });
-      });
-
-      describe('Response Type Transformation', () => {
-        test('Parsing the felt in response', async () => {
-          const { res } = await typeTransformedContract.get_felt();
-          expect(res).toStrictEqual(toBN(4));
-        });
-
-        test('Parsing the array of felt in response', async () => {
-          const result = await typeTransformedContract.get_array_of_felts();
-          const [res] = result;
-          expect(res).toStrictEqual([toBN(4), toBN(5)]);
-          expect(res).toStrictEqual(result.res);
-        });
-
-        test('Parsing the array of structs in response', async () => {
-          const result = await typeTransformedContract.get_struct();
-          const [res] = result;
-          expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
-          expect(res).toStrictEqual(result.res);
-        });
-
-        test('Parsing the array of structs in response', async () => {
-          const result = await typeTransformedContract.get_array_of_structs();
-          const [res] = result;
-          expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
-          expect(res).toStrictEqual(result.res);
-        });
-
-        test('Parsing the nested structs in response', async () => {
-          const result = await typeTransformedContract.get_nested_structs();
-          const [res] = result;
-          expect(res).toStrictEqual({
-            p1: { x: toBN(1), y: toBN(2) },
-            p2: { x: toBN(3), y: toBN(4) },
-            extra: toBN(5),
-          });
-          expect(res).toStrictEqual(result.res);
-        });
-
-        test('Parsing the tuple in response', async () => {
-          const result = await typeTransformedContract.get_tuple();
-          const [res] = result;
-          expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
-          expect(res).toStrictEqual(result.res);
-        });
-
-        test('Parsing the multiple types in response', async () => {
-          const result = await typeTransformedContract.get_mixed_types();
-          const [tuple, number, array, point] = result;
-          expect(tuple).toStrictEqual([toBN(1), toBN(2)]);
-          expect(number).toStrictEqual(toBN(3));
-          expect(array).toStrictEqual([toBN(4)]);
-          expect(point).toStrictEqual({ x: toBN(1), y: toBN(2) });
-          expect(tuple).toStrictEqual(result.tuple);
-          expect(number).toStrictEqual(result.number);
-          expect(array).toStrictEqual(result.array);
-          expect(point).toStrictEqual(result.point);
-        });
-      });
-    });
-  });
-
-  describe('class ContractFactory {}', () => {
-    beforeAll(async () => {
-      await account.declareDeploy({
-        contract: compiledErc20,
-        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
-        constructorCalldata,
-      });
-    });
-    test('deployment of new contract', async () => {
-      const factory = new ContractFactory(compiledErc20, classHash, account);
-      const erc20 = await factory.deploy(
-        compileCalldata({
-          name: encodeShortString('Token'),
-          symbol: encodeShortString('ERC20'),
-          recipient: wallet,
-        })
-      );
-      expect(erc20 instanceof Contract);
-    });
-    test('wait for deployment transaction', async () => {
-      const factory = new ContractFactory(compiledErc20, classHash, account);
-      const contract = await factory.deploy(
-        compileCalldata({
-          name: encodeShortString('Token'),
-          symbol: encodeShortString('ERC20'),
-          recipient: wallet,
-        })
-      );
-      expect(contract.deployed()).resolves.not.toThrow();
-    });
-    test('attach new contract', async () => {
-      const factory = new ContractFactory(compiledErc20, classHash, account);
-      const erc20 = factory.attach(erc20Address);
-      expect(erc20 instanceof Contract);
-    });
-  });
-});

package/__tests__/defaultProvider.test.ts

@@ -1,177 +0,0 @@
-import { BlockNumber, GetBlockResponse, Provider, stark } from '../src';
-import { toBN } from '../src/utils/number';
-import { encodeShortString } from '../src/utils/shortString';
-import { compiledErc20, erc20ClassHash, getTestAccount, getTestProvider } from './fixtures';
-
-const { compileCalldata } = stark;
-
-const testProvider = new Provider(getTestProvider());
-
-describe('defaultProvider', () => {
-  let exampleTransactionHash: string;
-  let erc20ContractAddress: string;
-  let exampleBlock: GetBlockResponse;
-  let exampleBlockNumber: BlockNumber;
-  let exampleBlockHash: string;
-  const wallet = stark.randomAddress();
-  const account = getTestAccount(testProvider);
-
-  beforeAll(async () => {
-    expect(testProvider).toBeInstanceOf(Provider);
-
-    const { deploy } = await account.declareDeploy({
-      contract: compiledErc20,
-      classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
-      constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
-    });
-
-    exampleTransactionHash = deploy.transaction_hash;
-    erc20ContractAddress = deploy.contract_address;
-
-    exampleBlock = await testProvider.getBlock('latest');
-    exampleBlockHash = exampleBlock.block_hash;
-    exampleBlockNumber = exampleBlock.block_number;
-  });
-
-  describe('endpoints', () => {
-    test('declareDeploy()', () => {
-      expect(erc20ContractAddress).toBeTruthy();
-      expect(exampleTransactionHash).toBeTruthy();
-    });
-
-    describe('getBlock', () => {
-      test('getBlock(blockIdentifier=latest)', async () => {
-        expect(exampleBlock).not.toBeNull();
-        const { block_number, timestamp } = exampleBlock;
-        expect(typeof block_number).toEqual('number');
-        return expect(typeof timestamp).toEqual('number');
-      });
-
-      test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, async () => {
-        const block = await testProvider.getBlock(exampleBlockNumber);
-        expect(block).toHaveProperty('block_hash');
-        expect(block).toHaveProperty('parent_hash');
-        expect(block).toHaveProperty('block_number');
-        expect(block).toHaveProperty('status');
-        expect(block).toHaveProperty('new_root');
-        expect(block).toHaveProperty('timestamp');
-        expect(block).toHaveProperty('transactions');
-        expect(Array.isArray(block.transactions)).toBe(true);
-      });
-
-      test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, async () => {
-        const block = await testProvider.getBlock(exampleBlockHash);
-        expect(block).toHaveProperty('block_hash');
-        expect(block).toHaveProperty('parent_hash');
-        expect(block).toHaveProperty('block_number');
-        expect(block).toHaveProperty('status');
-        expect(block).toHaveProperty('new_root');
-        expect(block).toHaveProperty('timestamp');
-        expect(block).toHaveProperty('transactions');
-        expect(Array.isArray(block.transactions)).toBe(true);
-      });
-
-      test('getBlock() -> { blockNumber }', async () => {
-        const block = await testProvider.getBlock('latest');
-        return expect(block).toHaveProperty('block_number');
-      });
-    });
-
-    test('getNonceForAddress()', async () => {
-      const nonce = await testProvider.getNonceForAddress(erc20ContractAddress);
-      return expect(toBN(nonce)).toEqual(toBN('0x0'));
-    });
-
-    test('getClassAt(contractAddress, blockNumber="latest")', async () => {
-      const classResponse = await testProvider.getClassAt(erc20ContractAddress);
-
-      expect(classResponse).toHaveProperty('program');
-      expect(classResponse).toHaveProperty('entry_points_by_type');
-    });
-
-    // TODO see if feasible to split
-    describe('GetClassByHash', () => {
-      test('responses', async () => {
-        const classResponse = await testProvider.getClassByHash(erc20ClassHash);
-        expect(classResponse).toHaveProperty('program');
-        expect(classResponse).toHaveProperty('entry_points_by_type');
-        expect(classResponse).toHaveProperty('abi');
-      });
-    });
-
-    describe('getStorageAt', () => {
-      test('with "key" type of number', () => {
-        return expect(testProvider.getStorageAt(erc20ContractAddress, 0)).resolves.not.toThrow();
-      });
-
-      test('"key" type of string', () => {
-        return expect(
-          testProvider.getStorageAt(erc20ContractAddress, '0x0')
-        ).resolves.not.toThrow();
-      });
-
-      test('with "key" type of BN', () => {
-        return expect(
-          testProvider.getStorageAt(erc20ContractAddress, toBN('0x0'))
-        ).resolves.not.toThrow();
-      });
-    });
-
-    test('getTransaction() - successful deploy transaction', async () => {
-      const transaction = await testProvider.getTransaction(exampleTransactionHash);
-
-      expect(transaction).toHaveProperty('transaction_hash');
-    });
-
-    test('getTransactionReceipt() - successful transaction', async () => {
-      const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
-
-      expect(transactionReceipt).toHaveProperty('actual_fee');
-      expect(transactionReceipt).toHaveProperty('transaction_hash');
-      expect(transactionReceipt).toHaveProperty('status');
-      expect(transactionReceipt).toHaveProperty('actual_fee');
-    });
-
-    describe('callContract()', () => {
-      test('callContract()', () => {
-        return expect(
-          testProvider.callContract({
-            contractAddress: erc20ContractAddress,
-            entrypoint: 'balanceOf',
-            calldata: compileCalldata({
-              user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
-            }),
-          })
-        ).resolves.not.toThrow();
-      });
-
-      test('callContract() - user wallet', () => {
-        return expect(
-          testProvider
-            .callContract({
-              contractAddress: erc20ContractAddress,
-              entrypoint: 'balanceOf',
-              calldata: compileCalldata({
-                user: wallet,
-              }),
-            })
-            .then((res) => {
-              expect(Array.isArray(res.result)).toBe(true);
-            })
-        ).resolves.not.toThrow();
-      });
-
-      test('callContract() - gateway error', async () => {
-        return expect(
-          testProvider.callContract({
-            contractAddress: erc20ContractAddress,
-            entrypoint: 'non_existent_entrypoint',
-            calldata: compileCalldata({
-              user: '0xdeadbeef',
-            }),
-          })
-        ).rejects.toThrowError();
-      });
-    });
-  });
-});

package/__tests__/fixtures.ts

@@ -1,84 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract } from '../src/types';
-
-const readContract = (name: string): CompiledContract =>
-  json.parse(
-    fs.readFileSync(path.resolve(__dirname, `../__mocks__/${name}.json`)).toString('ascii')
-  );
-
-export const compiledOpenZeppelinAccount = readContract('Account');
-export const compiledErc20 = readContract('ERC20');
-export const compiledL1L2 = readContract('l1l2_compiled');
-export const compiledTypeTransformation = readContract('contract');
-export const compiledMulticall = readContract('multicall');
-export const compiledTestDapp = readContract('TestDapp');
-export const compiledStarknetId = readContract('starknetId_compiled');
-export const compiledNamingContract = readContract('naming_compiled');
-
-/* Default test config based on run `starknet-devnet --seed 0` */
-const DEFAULT_TEST_PROVIDER_SEQUENCER_URL = 'http://127.0.0.1:5050/';
-const DEFAULT_TEST_ACCOUNT_ADDRESS =
-  '0x7e00d496e324876bbc8531f2d9a82bf154d1a04a50218ee74cdd372f75a551a';
-const DEFAULT_TEST_ACCOUNT_PRIVATE_KEY = '0xe3e70682c2094cac629f6fbed82c07cd';
-
-/* User defined config or default one */
-const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_SEQUENCER_URL;
-const RPC_URL = process.env.TEST_RPC_URL;
-
-/* Detect user defined node or sequencer, if none default to sequencer if both default to node */
-const PROVIDER_URL = RPC_URL || BASE_URL;
-
-/* Detect is localhost devnet */
-export const IS_LOCALHOST_DEVNET =
-  PROVIDER_URL.includes('localhost') || PROVIDER_URL.includes('127.0.0.1');
-
-/* Definitions */
-export const IS_RPC = !!RPC_URL;
-export const IS_SEQUENCER = !RPC_URL;
-
-export const getTestProvider = (): ProviderInterface => {
-  const provider = RPC_URL
-    ? new RpcProvider({ nodeUrl: RPC_URL })
-    : new SequencerProvider({ baseUrl: BASE_URL });
-
-  if (IS_LOCALHOST_DEVNET) {
-    // accelerate the tests when running locally
-    const originalWaitForTransaction = provider.waitForTransaction.bind(provider);
-    provider.waitForTransaction = (txHash: string, retryInterval?: number) => {
-      return originalWaitForTransaction(txHash, retryInterval || 1000);
-    };
-  }
-
-  return provider;
-};
-
-// test account with fee token balance
-export const getTestAccount = (provider: ProviderInterface) => {
-  let testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS;
-  let testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
-
-  if (!IS_LOCALHOST_DEVNET) {
-    if (!testAccountPrivateKey) {
-      throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
-    }
-    if (!testAccountAddress) {
-      throw new Error('TEST_ACCOUNT_ADDRESS is not set');
-    }
-  } else {
-    testAccountAddress = DEFAULT_TEST_ACCOUNT_ADDRESS;
-    testAccountPrivateKey = DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
-  }
-
-  return new Account(provider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
-};
-
-const describeIf = (condition: boolean) => (condition ? describe : describe.skip);
-export const describeIfSequencer = describeIf(IS_SEQUENCER);
-export const describeIfRpc = describeIf(IS_RPC);
-export const describeIfNotDevnet = describeIf(!IS_LOCALHOST_DEVNET);
-export const describeIfDevnet = describeIf(IS_LOCALHOST_DEVNET);
-
-export const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';

package/__tests__/jest.setup.ts

@@ -1,30 +0,0 @@
-import 'isomorphic-fetch';
-
-/* eslint-disable no-console */
-import { register } from 'fetch-intercept';
-
-jest.setTimeout(50 * 60 * 1000);
-
-if (process.env.DEBUG === 'true') {
-  register({
-    request(url, config) {
-      console.log('[fetch.request]', [url, config]);
-      return [url, config];
-    },
-
-    requestError(error) {
-      console.log('[fetch.requestError]', error);
-      return Promise.reject(error);
-    },
-
-    response(response) {
-      console.log('[fetch.response]', response);
-      return response;
-    },
-
-    responseError(error) {
-      console.log('[fetch.responseError]', error);
-      return Promise.reject(error);
-    },
-  });
-}

package/__tests__/rpcProvider.test.ts

@@ -1,132 +0,0 @@
-import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
-import { StarknetChainId } from '../src/constants';
-import {
-  compiledOpenZeppelinAccount,
-  describeIfNotDevnet,
-  describeIfRpc,
-  getTestAccount,
-  getTestProvider,
-} from './fixtures';
-
-describeIfRpc('RPCProvider', () => {
-  const rpcProvider = getTestProvider() as RpcProvider;
-  const account = getTestAccount(rpcProvider);
-  let accountPublicKey: string;
-
-  beforeAll(async () => {
-    expect(account).toBeInstanceOf(Account);
-    const accountKeyPair = ec.genKeyPair();
-    accountPublicKey = ec.getStarkKey(accountKeyPair);
-  });
-
-  test('getChainId', async () => {
-    const chainId = await rpcProvider.getChainId();
-    expect([StarknetChainId.TESTNET2, StarknetChainId.MAINNET, StarknetChainId.TESTNET]).toContain(
-      chainId
-    );
-  });
-
-  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 - pathfinder not implement', async () => {
-    await rpcProvider.getProtocolVersion();
-  });
-
-  describeIfNotDevnet('devnet not implement', () => {
-    test('getPendingTransactions', async () => {
-      const transactions = await rpcProvider.getPendingTransactions();
-      expect(Array.isArray(transactions)).toBe(true);
-    });
-  });
-
-  describe('RPC methods', () => {
-    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: string;
-      let transaction_hash: string;
-
-      beforeAll(async () => {
-        const { deploy } = await account.declareDeploy({
-          contract: compiledOpenZeppelinAccount,
-          classHash: '0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854',
-          constructorCalldata: [accountPublicKey],
-          salt: accountPublicKey,
-        });
-
-        contract_address = deploy.contract_address;
-        transaction_hash = deploy.transaction_hash;
-      });
-
-      test('declareDeploy()', () => {
-        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(contract_address);
-        expect(typeof classHash).toBe('string');
-      });
-
-      xtest('traceTransaction', async () => {
-        await rpcProvider.traceTransaction(transaction_hash);
-      });
-    });
-
-    test('getClass classHash 0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854', async () => {
-      const contractClass = await rpcProvider.getClass(
-        '0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854'
-      );
-      expect(contractClass).toHaveProperty('program');
-      expect(contractClass).toHaveProperty('entry_points_by_type');
-    });
-  });
-});