starknet 4.13.2 → 4.15.0

package/__tests__/account.test.ts

@@ -1,16 +1,17 @@
 import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import { Account, Contract, Provider, number, stark } from '../src';
+import { Account, Contract, DeployContractPayload, 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,
+  compiledNamingContract,
+  compiledStarknetId,
   compiledTestDapp,
   erc20ClassHash,
-  getERC20DeployPayload,
   getTestAccount,
   getTestProvider,
 } from './fixtures';
@@ -25,25 +26,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 +76,7 @@ describe('deploy and test Wallet', () => {
       calldata: [erc20.address, '10', '0'],
     });
 
-    await provider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash, undefined, ['ACCEPTED_ON_L2']);
   });
 
   test('read balance of wallet after transfer', async () => {
@@ -110,7 +115,7 @@ describe('deploy and test Wallet', () => {
       },
     ]);
 
-    await provider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash, undefined, ['ACCEPTED_ON_L2']);
 
     const response = await dapp.get_number(account.address);
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
@@ -161,6 +166,65 @@ describe('deploy and test Wallet', () => {
 
       expect(declareTx.class_hash).toBeDefined();
     });
+
+    test('Get the stark name of the account and account from stark name (using starknet.id)', async () => {
+      // Deploy naming contract
+      const namingPlayLoad: DeployContractPayload = { contract: compiledNamingContract };
+      const namingResponse = await provider.deployContract(namingPlayLoad);
+      const namingAddress = namingResponse.contract_address;
+
+      // Deploy Starknet id contract
+      const idPlayLoad: DeployContractPayload = { contract: compiledStarknetId };
+      const idResponse = await provider.deployContract(idPlayLoad);
+      const idAddress = idResponse.contract_address;
+
+      const { transaction_hash } = await account.execute([
+        {
+          contractAddress: namingAddress,
+          entrypoint: 'initializer',
+          calldata: [
+            idAddress, // starknetid_contract_addr
+            '0', // pricing_contract_addr
+            account.address, // admin
+            '1576987121283045618657875225183003300580199140020787494777499595331436496159', // whitelisting_key
+            '0', // l1_contract
+          ],
+        },
+        {
+          contractAddress: idAddress,
+          entrypoint: 'mint',
+          calldata: ['1'], // TokenId
+        },
+        {
+          contractAddress: namingAddress,
+          entrypoint: 'whitelisted_mint',
+          calldata: [
+            '18925', // Domain encoded "ben"
+            '1697380617', // Expiry
+            '1', // Starknet id linked
+            account.address, // receiver_address
+            '1249449923402095645023546949816521361907869702415870903008894560968474148064', // sig 0 for whitelist
+            '543901326374961504443808953662149863005450004831659662383974986108355067943', // sig 1 for whitelist
+          ],
+        },
+        {
+          contractAddress: namingAddress,
+          entrypoint: 'set_address_to_domain',
+          calldata: [
+            '1', // length
+            '18925', // Domain encoded "ben"
+          ],
+        },
+      ]);
+
+      await provider.waitForTransaction(transaction_hash);
+
+      const address = await account.getAddressFromStarkName('ben.stark', namingAddress);
+      expect(hexToDecimalString(address as string)).toEqual(hexToDecimalString(account.address));
+
+      const name = await account.getStarkName(namingAddress);
+      expect(name).toEqual('ben.stark');
+    });
   });
 
   describe('Declare and UDC Deploy Flow', () => {
@@ -173,7 +237,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 () => {

package/__tests__/fixtures.ts

@@ -1,11 +1,13 @@
 import fs from 'fs';
+import path from 'path';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract, DeployContractPayload } from '../src/types';
-import { encodeShortString } from '../src/utils/shortString';
+import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
-  json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
+  json.parse(
+    fs.readFileSync(path.resolve(__dirname, `../__mocks__/${name}.json`)).toString('ascii')
+  );
 
 export const compiledOpenZeppelinAccount = readContract('Account');
 export const compiledErc20 = readContract('ERC20');
@@ -13,30 +15,36 @@ 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');
 
-const DEFAULT_TEST_PROVIDER_BASE_URL = 'http://127.0.0.1:5050/';
-const DEFAULT_TEST_ACCOUNT_ADDRESS = // run `starknet-devnet --seed 0` and this will be the first account
+/* 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';
 
-const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_BASE_URL;
+/* 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;
 
-const IS_RPC = !!RPC_URL;
-const IS_RPC_DEVNET = Boolean(
-  RPC_URL && (RPC_URL.includes('localhost') || RPC_URL.includes('127.0.0.1'))
-);
-const IS_SEQUENCER = !IS_RPC;
-const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
-export const IS_SEQUENCER_GOERLI = BASE_URL === 'https://alpha4-2.starknet.io';
-export const IS_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
+/* 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_DEVNET) {
+  if (IS_LOCALHOST_DEVNET) {
     // accelerate the tests when running locally
     const originalWaitForTransaction = provider.waitForTransaction.bind(provider);
     provider.waitForTransaction = (txHash, retryInterval) => {
@@ -52,11 +60,10 @@ export const getTestAccount = (provider: ProviderInterface) => {
   let testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS;
   let testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
 
-  if (!IS_DEVNET) {
+  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');
     }
@@ -69,15 +76,9 @@ export const getTestAccount = (provider: ProviderInterface) => {
 };
 
 const describeIf = (condition: boolean) => (condition ? describe : describe.skip);
-export const describeIfSequencer = describeIf(IS_DEVNET);
+export const describeIfSequencer = describeIf(IS_SEQUENCER);
 export const describeIfRpc = describeIf(IS_RPC);
-export const describeIfNotDevnet = describeIf(!IS_DEVNET);
+export const describeIfNotDevnet = describeIf(!IS_LOCALHOST_DEVNET);
+export const describeIfDevnet = describeIf(IS_LOCALHOST_DEVNET);
 
 export const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
-
-export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
-  return {
-    contract: compiledErc20,
-    constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), recipient],
-  };
-};