starknet 4.8.0 → 4.10.0

package/__tests__/account.test.ts

@@ -3,7 +3,13 @@ import { isBN } from 'bn.js';
 import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledErc20, compiledTestDapp, getTestAccount, getTestProvider } from './fixtures';
+import {
+  compiledErc20,
+  compiledTestDapp,
+  getERC20DeployPayload,
+  getTestAccount,
+  getTestProvider,
+} from './fixtures';
 
 describe('deploy and test Wallet', () => {
   const provider = getTestProvider();
@@ -15,26 +21,18 @@ describe('deploy and test Wallet', () => {
   beforeAll(async () => {
     expect(account).toBeInstanceOf(Account);
 
-    const erc20Response = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(account.address);
+
+    const erc20Response = await provider.deployContract(erc20DeployPayload);
 
     erc20Address = erc20Response.contract_address;
     erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
 
     await provider.waitForTransaction(erc20Response.transaction_hash);
 
-    const mintResponse = await account.execute({
-      contractAddress: erc20Address,
-      entrypoint: 'mint',
-      calldata: [account.address, '1000'],
-    });
-
-    await provider.waitForTransaction(mintResponse.transaction_hash);
+    const x = await erc20.balanceOf(account.address);
 
-    const x = await erc20.balance_of(account.address);
-
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
 
     const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
@@ -45,34 +43,34 @@ describe('deploy and test Wallet', () => {
   });
 
   test('estimate fee', async () => {
-    const { overall_fee } = await account.estimateFee({
+    const { overall_fee } = await account.estimateInvokeFee({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
     expect(isBN(overall_fee)).toBe(true);
   });
 
   test('read balance of wallet', async () => {
-    const x = await erc20.balance_of(account.address);
+    const x = await erc20.balanceOf(account.address);
 
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
   });
 
   test('execute by wallet owner', async () => {
     const { transaction_hash } = await account.execute({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
 
     await provider.waitForTransaction(transaction_hash);
   });
 
   test('read balance of wallet after transfer', async () => {
-    const { res } = await erc20.balance_of(account.address);
+    const { balance } = await erc20.balanceOf(account.address);
 
-    expect(res).toStrictEqual(toBN(990));
+    expect(balance.low).toStrictEqual(toBN(990));
   });
 
   test('execute with custom nonce', async () => {
@@ -82,7 +80,7 @@ describe('deploy and test Wallet', () => {
       {
         contractAddress: erc20Address,
         entrypoint: 'transfer',
-        calldata: [account.address, '10'],
+        calldata: [account.address, '10', '0'],
       },
       undefined,
       { nonce }
@@ -130,7 +128,7 @@ describe('deploy and test Wallet', () => {
       const mintResponse = await account.execute({
         contractAddress: erc20Address,
         entrypoint: 'mint',
-        calldata: [wallet, '1000'],
+        calldata: [wallet, '1000', '0'],
       });
 
       await provider.waitForTransaction(mintResponse.transaction_hash);
@@ -143,8 +141,18 @@ describe('deploy and test Wallet', () => {
     });
 
     test('estimate gas fee for `mint`', async () => {
-      const res = await erc20.estimateFee.mint(wallet, '10');
+      const res = await erc20.estimateFee.mint(wallet, ['10', '0']);
       expect(res).toHaveProperty('overall_fee');
     });
+
+    test('Declare ERC20 contract', async () => {
+      const declareTx = await account.declare({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      });
+      await provider.waitForTransaction(declareTx.transaction_hash);
+
+      expect(declareTx.class_hash).toBeDefined();
+    });
   });
 });

package/__tests__/contract.test.ts

@@ -1,6 +1,7 @@
 import { isBN } from 'bn.js';
 
 import { Contract, ContractFactory, stark } from '../src';
+import { DeployContractPayload } from '../src/types/lib';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
@@ -8,6 +9,7 @@ import {
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -21,9 +23,12 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
-        contract: compiledErc20,
-      });
+      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
@@ -39,21 +44,21 @@ describe('class Contract {}', () => {
     });
 
     test('populate transaction for initial balance of that account', async () => {
-      const res = await erc20.populateTransaction.balance_of(wallet);
+      const res = await erc20.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')).rejects.toThrow();
+      expect(erc20.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
     });
 
     test('read initial balance of that account', async () => {
-      const result = await erc20.balance_of(wallet);
+      const result = await erc20.balanceOf(wallet);
       const [res] = result;
-      expect(res).toStrictEqual(toBN(0));
-      expect(res).toStrictEqual(result.res);
+      expect(res.low).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(result.balance);
     });
 
     test('read balance in a multicall', async () => {
@@ -61,7 +66,7 @@ describe('class Contract {}', () => {
       const args2 = {};
       const calls = [
         erc20.address,
-        getSelectorFromName('balance_of'),
+        getSelectorFromName('balanceOf'),
         Object.keys(args1).length,
         ...compileCalldata(args1),
 
@@ -190,21 +195,27 @@ describe('class Contract {}', () => {
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
+  const wallet = stark.randomAddress();
+  let erc20DeployPayload: DeployContractPayload;
+
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await provider.deployContract(
+      erc20DeployPayload
+    );
+
     await provider.waitForTransaction(transaction_hash);
     erc20Address = contract_address;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const erc20 = await factory.deploy();
+    const erc20 = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(erc20 instanceof Contract);
   });
   test('wait for deployment transaction', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const contract = await factory.deploy();
+    const contract = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(contract.deployed()).resolves.not.toThrow();
   });
   test('attach new contract', async () => {

package/__tests__/defaultProvider.test.ts

@@ -1,17 +1,6 @@
-import {
-  BlockNumber,
-  DeclareContractResponse,
-  DeployContractResponse,
-  GetBlockResponse,
-  stark,
-} from '../src';
+import { BlockNumber, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import {
-  compiledErc20,
-  compiledOpenZeppelinAccount,
-  describeIfNotDevnet,
-  getTestProvider,
-} from './fixtures';
+import { getERC20DeployPayload, getTestProvider } from './fixtures';
 
 const { compileCalldata } = stark;
 
@@ -24,11 +13,14 @@ describe('defaultProvider', () => {
   let exampleBlock: GetBlockResponse;
   let exampleBlockNumber: BlockNumber;
   let exampleBlockHash: string;
+  const wallet = stark.randomAddress();
 
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await testProvider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await testProvider.deployContract(
+      erc20DeployPayload
+    );
     await testProvider.waitForTransaction(transaction_hash);
     exampleTransactionHash = transaction_hash;
     exampleContractAddress = contract_address;
@@ -39,27 +31,47 @@ describe('defaultProvider', () => {
   });
 
   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('deployContract()', () => {
+      expect(exampleContractAddress).toBeTruthy();
+      expect(exampleTransactionHash).toBeTruthy();
     });
 
-    test('getBlock(blockIdentifier=latest)', async () => {
-      expect(exampleBlock).not.toBeNull();
-
-      const { block_number, timestamp } = exampleBlock;
+    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');
+      });
 
-      expect(typeof block_number).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);
+      });
 
-      return expect(typeof timestamp).toEqual('number');
-    });
+      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();
-      return expect(block).toHaveProperty('block_number');
+      test('getBlock() -> { blockNumber }', async () => {
+        const block = await testProvider.getBlock('latest');
+        return expect(block).toHaveProperty('block_number');
+      });
     });
 
     test('getNonce()', async () => {
@@ -67,6 +79,13 @@ describe('defaultProvider', () => {
       return expect(nonce).toEqual('0x0');
     });
 
+    test('getClassAt(contractAddress, blockNumber="latest")', async () => {
+      const classResponse = await testProvider.getClassAt(exampleContractAddress);
+
+      expect(classResponse).toHaveProperty('program');
+      expect(classResponse).toHaveProperty('entry_points_by_type');
+    });
+
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
@@ -85,7 +104,7 @@ describe('defaultProvider', () => {
       });
     });
 
-    test('getTransaction() - successful transaction', async () => {
+    test('getTransaction() - successful deploy transaction', async () => {
       const transaction = await testProvider.getTransaction(exampleTransactionHash);
 
       expect(transaction).toHaveProperty('transaction_hash');
@@ -94,219 +113,51 @@ describe('defaultProvider', () => {
     test('getTransactionReceipt() - successful transaction', async () => {
       const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
 
-      return expect(transactionReceipt).toHaveProperty('actual_fee');
+      expect(transactionReceipt).toHaveProperty('actual_fee');
+      expect(transactionReceipt).toHaveProperty('transaction_hash');
+      expect(transactionReceipt).toHaveProperty('status');
+      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();
-    let latestBlock;
-    describe(`Provider methods if not devnet`, () => {
-      describe('getBlock', () => {
-        test('getBlock by tag pending', async () => {
-          latestBlock = await provider.getBlock();
-          expect(latestBlock).toHaveProperty('block_hash');
-          expect(latestBlock).toHaveProperty('parent_hash');
-          expect(latestBlock).toHaveProperty('block_number');
-          expect(latestBlock).toHaveProperty('status');
-          expect(latestBlock).toHaveProperty('new_root');
-          expect(latestBlock).toHaveProperty('timestamp');
-          expect(latestBlock).toHaveProperty('transactions');
-          expect(Array.isArray(latestBlock.transactions)).toBe(true);
-        });
-
-        test('getBlock by Hash', async () => {
-          const block = await provider.getBlock(latestBlock.block_hash);
-          expect(block).toHaveProperty('block_hash');
-          expect(block).toHaveProperty('parent_hash');
-          expect(block).toHaveProperty('block_number');
-          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 by Number', async () => {
-          const block = await provider.getBlock(latestBlock.block_number);
-          expect(block).toHaveProperty('block_hash');
-          expect(block).toHaveProperty('parent_hash');
-          expect(block).toHaveProperty('block_number');
-          expect(block).toHaveProperty('status');
-          expect(block).toHaveProperty('new_root');
-          expect(block).toHaveProperty('timestamp');
-          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(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('version');
-        });
+    describe('callContract()', () => {
+      test('callContract()', () => {
+        return expect(
+          testProvider.callContract({
+            contractAddress: exampleContractAddress,
+            entrypoint: 'balanceOf',
+            calldata: compileCalldata({
+              user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+            }),
+          })
+        ).resolves.not.toThrow();
       });
 
-      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('messages_sent');
-          expect(receipt).toHaveProperty('events');
-        });
+      test('callContract() - user wallet', () => {
+        return expect(
+          testProvider
+            .callContract({
+              contractAddress: exampleContractAddress,
+              entrypoint: 'balanceOf',
+              calldata: compileCalldata({
+                user: wallet,
+              }),
+            })
+            .then((res) => {
+              expect(Array.isArray(res.result)).toBe(true);
+            })
+        ).resolves.not.toThrow();
       });
 
-      describe('Contract methods', () => {
-        let contractAddress: string;
-        let deployResponse: DeployContractResponse;
-        let declareResponse: DeclareContractResponse;
-        let blockNumber: BlockNumber;
-
-        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),
-          ]);
-          ({ block_number: blockNumber } = await provider.getBlock('latest'));
-        });
-
-        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, blockNumber);
-
-            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();
-          });
-        });
+      test('callContract() - gateway error', async () => {
+        return expect(
+          testProvider.callContract({
+            contractAddress: exampleContractAddress,
+            entrypoint: 'non_existent_entrypoint',
+            calldata: compileCalldata({
+              user: '0xdeadbeef',
+            }),
+          })
+        ).rejects.toThrowError();
       });
     });
   });

package/__tests__/fixtures.ts

@@ -1,7 +1,8 @@
 import fs from 'fs';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract } from '../src/types';
+import { CompiledContract, DeployContractPayload } from '../src/types';
+import { encodeShortString } from '../src/utils/shortString';
 
 const readContract = (name: string): CompiledContract =>
   json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
@@ -27,7 +28,7 @@ const IS_RPC_DEVNET = Boolean(
 );
 const IS_SEQUENCER = !IS_RPC;
 const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
-export const IS_SEQUENCER_GOERLI = BASE_URL === 'https://alpha4.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;
 
 export const getTestProvider = () => {
@@ -71,3 +72,10 @@ const describeIf = (condition: boolean) => (condition ? describe : describe.skip
 export const describeIfSequencer = describeIf(IS_DEVNET);
 export const describeIfRpc = describeIf(IS_RPC);
 export const describeIfNotDevnet = describeIf(!IS_DEVNET);
+
+export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
+  return {
+    contract: compiledErc20,
+    constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), recipient],
+  };
+};