starknet 4.13.2 → 4.14.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [4.14.0](https://github.com/0xs34n/starknet.js/compare/v4.13.2...v4.14.0) (2022-11-29)
+
+### Bug Fixes
+
+- account test removed provider deployContract ([605c2a9](https://github.com/0xs34n/starknet.js/commit/605c2a9426f8ef5bc3c16803db0055550ca58da3))
+- cleanup after refactor and remove branch split ([f695629](https://github.com/0xs34n/starknet.js/commit/f69562960877bc37d38e2964a88569c9ae9bedca))
+- properly parse blockIdentifier in buildCall function ([d09affd](https://github.com/0xs34n/starknet.js/commit/d09affd57c260eccf2f59c9cb7dd8c668fe8a5b3))
+- remove deployMaxFee from deploy ([6d5fa24](https://github.com/0xs34n/starknet.js/commit/6d5fa2461def5caad3cdd71af8a4e6c61d88092e))
+- rpc tests ([cd913ee](https://github.com/0xs34n/starknet.js/commit/cd913ee93df433eb3730e6aae43dd22b0c8aed32))
+- split getNonce interface ([7b7acd9](https://github.com/0xs34n/starknet.js/commit/7b7acd9f5ebe0b2b97e389fb3a68249dd72224ce))
+- tiping issue ([78aa340](https://github.com/0xs34n/starknet.js/commit/78aa3402131f51e83287eada7499ea01de41efa0))
+- udc require L2 status for deployed contract to be awailable to use ([afba8d0](https://github.com/0xs34n/starknet.js/commit/afba8d068685c1c9b03126e5de13a5dfddb2925e))
+
+### Features
+
+- account deployContract ts overide base class ([dd4502d](https://github.com/0xs34n/starknet.js/commit/dd4502d76fb73f04e8e512336f6e5924c55b2f39))
+- extend acc interface, use deploy estimate fee ([da7392a](https://github.com/0xs34n/starknet.js/commit/da7392a65fa2b261cc1c6916739c1a59ecf9330f))
+- r p.deployCo. C tests, CF fixtures, cleanHex, DeclareDeploy, F Provider, seq.waitFor ret.txRec ([bb50f53](https://github.com/0xs34n/starknet.js/commit/bb50f5312f2b8618a26eaf13f1f851a645f5b670))
+- return from wait Transaction,Account deployContract and declareDeploy ([724975d](https://github.com/0xs34n/starknet.js/commit/724975dd92cc764208e1cf70c6f0d4089f0d363d))
+
 ## [4.13.2](https://github.com/0xs34n/starknet.js/compare/v4.13.1...v4.13.2) (2022-11-25)
 
 ### Bug Fixes

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+tt@shardlabs.io.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

package/README.md

@@ -48,7 +48,7 @@ $ npm install starknet@next
 
 Import `starknet` and use the [API](https://www.starknetjs.com/docs/API/)
 
-Please refer to the following code example [here](https://github.com/0xs34n/starknet.js-workshop/blob/main/index.js)
+Please refer to the following code example [here](https://github.com/0xs34n/starknet.js-workshop)
 
 Guides can be found [here](https://www.starknetjs.com/guides/intro)
 
@@ -62,7 +62,7 @@ Guides can be found [here](https://www.starknetjs.com/guides/intro)
 - [Braavos - your new wallet on top of StarkNet](https://chrome.google.com/webstore/detail/braavos-wallet/jnlgamecbpmbajjfhmmmlhejkemejdma)
 - [React + Starknet.js boilerplate](https://github.com/fracek/starknet-react-example)
 - [AMM Demo](https://www.starknetswap.com/)
-- [mySwap - the first DeFi app to launch on StarkNet](myswap.xyz)
+- [mySwap - the first DeFi app to launch on StarkNet](https://myswap.xyz)
 
 ## ✏️ Contributing
 

package/__tests__/account.test.ts

@@ -3,14 +3,13 @@ import { isBN } from 'bn.js';
 import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
 import { feeTransactionVersion } from '../src/utils/hash';
-import { toBN } from '../src/utils/number';
+import { hexToDecimalString, toBN } from '../src/utils/number';
 import { encodeShortString } from '../src/utils/shortString';
 import { randomAddress } from '../src/utils/stark';
 import {
   compiledErc20,
   compiledTestDapp,
   erc20ClassHash,
-  getERC20DeployPayload,
   getTestAccount,
   getTestProvider,
 } from './fixtures';
@@ -25,25 +24,29 @@ describe('deploy and test Wallet', () => {
   beforeAll(async () => {
     expect(account).toBeInstanceOf(Account);
 
-    const erc20DeployPayload = getERC20DeployPayload(account.address);
-
-    const erc20Response = await provider.deployContract(erc20DeployPayload);
+    const declareDeploy = await account.declareDeploy({
+      contract: compiledErc20,
+      classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      constructorCalldata: [
+        encodeShortString('Token'),
+        encodeShortString('ERC20'),
+        account.address,
+      ],
+    });
 
-    erc20Address = erc20Response.contract_address;
+    erc20Address = declareDeploy.deploy.contract_address;
     erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
 
-    await provider.waitForTransaction(erc20Response.transaction_hash);
-
     const x = await erc20.balanceOf(account.address);
 
     expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
 
-    const dappResponse = await provider.deployContract({
+    const dappResponse = await account.declareDeploy({
       contract: compiledTestDapp,
+      classHash: '0x04367b26fbb92235e8d1137d19c080e6e650a6889ded726d00658411cc1046f5',
     });
-    dapp = new Contract(compiledTestDapp.abi, dappResponse.contract_address!, provider);
 
-    await provider.waitForTransaction(dappResponse.transaction_hash);
+    dapp = new Contract(compiledTestDapp.abi, dappResponse.deploy.contract_address!, provider);
   });
 
   test('estimate fee', async () => {
@@ -71,7 +74,7 @@ describe('deploy and test Wallet', () => {
       calldata: [erc20.address, '10', '0'],
     });
 
-    await provider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash, ['ACCEPTED_ON_L2']);
   });
 
   test('read balance of wallet after transfer', async () => {
@@ -110,7 +113,7 @@ describe('deploy and test Wallet', () => {
       },
     ]);
 
-    await provider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash, ['ACCEPTED_ON_L2']);
 
     const response = await dapp.get_number(account.address);
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
@@ -173,7 +176,28 @@ describe('deploy and test Wallet', () => {
       await provider.waitForTransaction(declareTx.transaction_hash);
 
       expect(declareTx).toHaveProperty('class_hash');
-      expect(declareTx.class_hash).toEqual(erc20ClassHash);
+      expect(hexToDecimalString(declareTx.class_hash)).toEqual(hexToDecimalString(erc20ClassHash));
+    });
+
+    test('UDC DeployContract', async () => {
+      const deployResponse = await account.deployContract({
+        classHash: erc20ClassHash,
+        constructorCalldata: [
+          encodeShortString('Token'),
+          encodeShortString('ERC20'),
+          account.address,
+        ],
+      });
+
+      expect(deployResponse.contract_address).toBeDefined();
+      expect(deployResponse.transaction_hash).toBeDefined();
+      expect(deployResponse.address).toBeDefined();
+      expect(deployResponse.deployer).toBeDefined();
+      expect(deployResponse.unique).toBeDefined();
+      expect(deployResponse.classHash).toBeDefined();
+      expect(deployResponse.calldata_len).toBeDefined();
+      expect(deployResponse.calldata).toBeDefined();
+      expect(deployResponse.salt).toBeDefined();
     });
 
     test('UDC Deploy', async () => {

package/__tests__/contract.test.ts

@@ -1,15 +1,15 @@
 import { isBN } from 'bn.js';
 
 import { Contract, ContractFactory, stark } from '../src';
-import { DeployContractPayload } from '../src/types';
 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,
-  getERC20DeployPayload,
+  getTestAccount,
   getTestProvider,
 } from './fixtures';
 
@@ -17,45 +17,46 @@ const provider = getTestProvider();
 
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
+  const account = getTestAccount(provider);
 
   describe('Basic Interaction', () => {
-    let erc20: Contract;
-    let contract: Contract;
+    let erc20Contract: Contract;
+    let multicallContract: Contract;
 
     beforeAll(async () => {
-      const erc20DeployPayload = getERC20DeployPayload(wallet);
-
-      const { contract_address, transaction_hash } = await provider.deployContract(
-        erc20DeployPayload
-      );
-
-      erc20 = new Contract(compiledErc20.abi, contract_address!, provider);
-      await provider.waitForTransaction(transaction_hash);
-      // Deploy Multicall
+      const { deploy } = await account.declareDeploy({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+        constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
+      });
 
-      const { transaction_hash: m_transaction_hash, contract_address: multicallAddress } =
-        await provider.deployContract({
-          contract: compiledMulticall,
-        });
+      erc20Contract = new Contract(compiledErc20.abi, deploy.contract_address!, provider);
 
-      contract = new Contract(compiledMulticall.abi, multicallAddress!, provider);
+      const { deploy: multicallDeploy } = await account.declareDeploy({
+        contract: compiledMulticall,
+        classHash: '0x06f94f3229a8d9c1d51cb84f1f5ec306c8552a805e307540727dda53c4936b43',
+      });
 
-      await provider.waitForTransaction(m_transaction_hash);
+      multicallContract = new Contract(
+        compiledMulticall.abi,
+        multicallDeploy.contract_address!,
+        provider
+      );
     });
 
     test('populate transaction for initial balance of that account', async () => {
-      const res = await erc20.populateTransaction.balanceOf(wallet);
+      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(erc20.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
+      expect(erc20Contract.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
     });
 
     test('read initial balance of that account', async () => {
-      const result = await erc20.balanceOf(wallet);
+      const result = await erc20Contract.balanceOf(wallet);
       const [res] = result;
       expect(res.low).toStrictEqual(toBN(1000));
       expect(res).toStrictEqual(result.balance);
@@ -65,17 +66,17 @@ describe('class Contract {}', () => {
       const args1 = { user: wallet };
       const args2 = {};
       const calls = [
-        erc20.address,
+        erc20Contract.address,
         getSelectorFromName('balanceOf'),
         Object.keys(args1).length,
         ...compileCalldata(args1),
 
-        erc20.address,
+        erc20Contract.address,
         getSelectorFromName('decimals'),
         Object.keys(args2).length,
         ...compileCalldata(args2),
       ];
-      const result = await contract.aggregate(calls);
+      const result = await multicallContract.aggregate(calls);
       const [block_number, res] = result;
       expect(isBN(block_number));
       expect(Array.isArray(res));
@@ -86,36 +87,47 @@ describe('class Contract {}', () => {
   });
 
   describe('Type Transformation', () => {
-    let contract: Contract;
+    let typeTransformedContract: Contract;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
+      const { deploy } = await account.declareDeploy({
         contract: compiledTypeTransformation,
+        classHash: '0x022a0e662b13d18a2aaa3ee54ae290de6569621b549022c18169c6e7893809ea',
       });
-      contract = new Contract(compiledTypeTransformation.abi, contract_address!, provider);
-      await provider.waitForTransaction(transaction_hash);
+
+      typeTransformedContract = new Contract(
+        compiledTypeTransformation.abi,
+        deploy.contract_address!,
+        provider
+      );
     });
 
     describe('Request Type Transformation', () => {
       test('Parsing the felt in request', async () => {
-        return expect(contract.request_felt(3)).resolves.not.toThrow();
+        return expect(typeTransformedContract.request_felt(3)).resolves.not.toThrow();
       });
 
       test('Parsing the array of felt in request', async () => {
-        return expect(contract.request_array_of_felts([1, 2])).resolves.not.toThrow();
+        return expect(
+          typeTransformedContract.request_array_of_felts([1, 2])
+        ).resolves.not.toThrow();
       });
 
       test('Parsing the struct in request', async () => {
-        return expect(contract.request_struct({ x: 1, y: 2 })).resolves.not.toThrow();
+        return expect(
+          typeTransformedContract.request_struct({ x: 1, y: 2 })
+        ).resolves.not.toThrow();
       });
 
       test('Parsing the array of structs in request', async () => {
-        return expect(contract.request_array_of_structs([{ x: 1, y: 2 }])).resolves.not.toThrow();
+        return expect(
+          typeTransformedContract.request_array_of_structs([{ x: 1, y: 2 }])
+        ).resolves.not.toThrow();
       });
 
       test('Parsing the nested structs in request', async () => {
         return expect(
-          contract.request_nested_structs({
+          typeTransformedContract.request_nested_structs({
             p1: { x: 1, y: 2 },
             p2: { x: 3, y: 4 },
             extra: 5,
@@ -124,43 +136,45 @@ describe('class Contract {}', () => {
       });
 
       test('Parsing the tuple in request', async () => {
-        return expect(contract.request_tuple([1, 2])).resolves.not.toThrow();
+        return expect(typeTransformedContract.request_tuple([1, 2])).resolves.not.toThrow();
       });
 
       test('Parsing the multiple types in request', async () => {
-        return expect(contract.request_mixed_types(2, { x: 1, y: 2 }, [1])).resolves.not.toThrow();
+        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 contract.get_felt();
+        const { res } = await typeTransformedContract.get_felt();
         expect(res).toStrictEqual(toBN(4));
       });
 
       test('Parsing the array of felt in response', async () => {
-        const result = await contract.get_array_of_felts();
+        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 contract.get_struct();
+        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 contract.get_array_of_structs();
+        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 contract.get_nested_structs();
+        const result = await typeTransformedContract.get_nested_structs();
         const [res] = result;
         expect(res).toStrictEqual({
           p1: { x: toBN(1), y: toBN(2) },
@@ -171,14 +185,14 @@ describe('class Contract {}', () => {
       });
 
       test('Parsing the tuple in response', async () => {
-        const result = await contract.get_tuple();
+        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 contract.get_mixed_types();
+        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));
@@ -196,30 +210,29 @@ describe('class Contract {}', () => {
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
   const wallet = stark.randomAddress();
-  let erc20DeployPayload: DeployContractPayload;
+  const account = getTestAccount(provider);
+  const constructorCalldata = [encodeShortString('Token'), encodeShortString('ERC20'), wallet];
+  const classHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
 
   beforeAll(async () => {
-    erc20DeployPayload = getERC20DeployPayload(wallet);
-
-    const { contract_address, transaction_hash } = await provider.deployContract(
-      erc20DeployPayload
-    );
-
-    await provider.waitForTransaction(transaction_hash);
-    erc20Address = contract_address;
+    await account.declareDeploy({
+      contract: compiledErc20,
+      classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      constructorCalldata,
+    });
   });
   test('deployment of new contract', async () => {
-    const factory = new ContractFactory(compiledErc20, provider);
-    const erc20 = await factory.deploy(erc20DeployPayload.constructorCalldata);
+    const factory = new ContractFactory(compiledErc20, classHash, account);
+    const erc20 = await factory.deploy(constructorCalldata);
     expect(erc20 instanceof Contract);
   });
   test('wait for deployment transaction', async () => {
-    const factory = new ContractFactory(compiledErc20, provider);
-    const contract = await factory.deploy(erc20DeployPayload.constructorCalldata);
+    const factory = new ContractFactory(compiledErc20, classHash, account);
+    const contract = await factory.deploy(constructorCalldata);
     expect(contract.deployed()).resolves.not.toThrow();
   });
   test('attach new contract', async () => {
-    const factory = new ContractFactory(compiledErc20, provider);
+    const factory = new ContractFactory(compiledErc20, classHash, account);
     const erc20 = factory.attach(erc20Address);
     expect(erc20 instanceof Contract);
   });

package/__tests__/defaultProvider.test.ts

@@ -1,6 +1,7 @@
 import { BlockNumber, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { erc20ClassHash, getERC20DeployPayload, getTestProvider } from './fixtures';
+import { encodeShortString } from '../src/utils/shortString';
+import { compiledErc20, erc20ClassHash, getTestAccount, getTestProvider } from './fixtures';
 
 const { compileCalldata } = stark;
 
@@ -9,21 +10,21 @@ const testProvider = 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 () => {
-    const erc20DeployPayload = getERC20DeployPayload(wallet);
+    const { deploy } = await account.declareDeploy({
+      contract: compiledErc20,
+      classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
+    });
 
-    const { contract_address, transaction_hash } = await testProvider.deployContract(
-      erc20DeployPayload
-    );
-    await testProvider.waitForTransaction(transaction_hash);
-    exampleTransactionHash = transaction_hash;
-    erc20ContractAddress = contract_address;
+    exampleTransactionHash = deploy.transaction_hash;
+    erc20ContractAddress = deploy.contract_address;
 
     exampleBlock = await testProvider.getBlock('latest');
     exampleBlockHash = exampleBlock.block_hash;
@@ -31,7 +32,7 @@ describe('defaultProvider', () => {
   });
 
   describe('endpoints', () => {
-    test('deployContract()', () => {
+    test('declareDeploy()', () => {
       expect(erc20ContractAddress).toBeTruthy();
       expect(exampleTransactionHash).toBeTruthy();
     });
@@ -74,9 +75,9 @@ describe('defaultProvider', () => {
       });
     });
 
-    test('getNonce()', async () => {
-      const nonce = await testProvider.getNonce(erc20ContractAddress);
-      return expect(nonce).toEqual('0x0');
+    test('getNonceForAddress()', async () => {
+      const nonce = await testProvider.getNonceForAddress(erc20ContractAddress);
+      return expect(toBN(nonce)).toEqual(toBN('0x0'));
     });
 
     test('getClassAt(contractAddress, blockNumber="latest")', async () => {