starknet 4.16.0 → 4.17.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# [4.17.0](https://github.com/0xs34n/starknet.js/compare/v4.16.0...v4.17.0) (2022-12-13)
+
+### Bug Fixes
+
+- merge conflicts ([92a3be8](https://github.com/0xs34n/starknet.js/commit/92a3be8500153d4b87b888f454bb4140edb88411))
+
+### Features
+
+- contract factory deploy arguments ([9eff7f4](https://github.com/0xs34n/starknet.js/commit/9eff7f4ccc74cb5f0c0594e88c0292600f20ec09))
+- update contractFactory docs ([76f8440](https://github.com/0xs34n/starknet.js/commit/76f8440233c4a1e24e3dfff25fe02525e86a8258))
+
 # [4.16.0](https://github.com/0xs34n/starknet.js/compare/v4.15.1...v4.16.0) (2022-12-12)
 
 ### Bug Fixes

package/__tests__/account.test.ts

@@ -338,6 +338,8 @@ describe('deploy and test Wallet', () => {
       expect(deployments).toHaveProperty('transaction_hash');
       expect(deployments.contract_address[0]).toBeDefined();
       expect(deployments.contract_address[1]).toBeDefined();
+
+      await provider.waitForTransaction(deployments.transaction_hash);
     });
   });
 });

package/__tests__/contract.test.ts

@@ -220,12 +220,24 @@ describe('contract module', () => {
     });
     test('deployment of new contract', async () => {
       const factory = new ContractFactory(compiledErc20, classHash, account);
-      const erc20 = await factory.deploy(constructorCalldata);
+      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(constructorCalldata);
+      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 () => {

package/__tests__/defaultProvider.test.ts

@@ -1,11 +1,11 @@
-import { BlockNumber, GetBlockResponse, stark } from '../src';
+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 = getTestProvider();
+const testProvider = new Provider(getTestProvider());
 
 describe('defaultProvider', () => {
   let exampleTransactionHash: string;
@@ -17,6 +17,8 @@ describe('defaultProvider', () => {
   const account = getTestAccount(testProvider);
 
   beforeAll(async () => {
+    expect(testProvider).toBeInstanceOf(Provider);
+
     const { deploy } = await account.declareDeploy({
       contract: compiledErc20,
       classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',

package/__tests__/fixtures.ts

@@ -47,7 +47,7 @@ export const getTestProvider = (): ProviderInterface => {
   if (IS_LOCALHOST_DEVNET) {
     // accelerate the tests when running locally
     const originalWaitForTransaction = provider.waitForTransaction.bind(provider);
-    provider.waitForTransaction = (txHash, retryInterval) => {
+    provider.waitForTransaction = (txHash: string, retryInterval?: number) => {
       return originalWaitForTransaction(txHash, retryInterval || 1000);
     };
   }

package/__tests__/rpcProvider.test.ts

@@ -86,8 +86,8 @@ describeIfRpc('RPCProvider', () => {
     });
 
     describe('deploy contract related tests', () => {
-      let contract_address;
-      let transaction_hash;
+      let contract_address: string;
+      let transaction_hash: string;
 
       beforeAll(async () => {
         const { deploy } = await account.declareDeploy({
@@ -128,9 +128,5 @@ describeIfRpc('RPCProvider', () => {
       expect(contractClass).toHaveProperty('program');
       expect(contractClass).toHaveProperty('entry_points_by_type');
     });
-
-    test.todo('getEstimateFee');
-
-    test.todo('invokeFunction');
   });
 });

package/dist/index.d.ts

@@ -1477,7 +1477,7 @@ declare abstract class ProviderInterface {
     abstract deployAccountContract(payload: DeployAccountContractPayload, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
     /**
      * Invokes a function on starknet
-     * @deprecated This method wont be supported as soon as fees are mandatory
+     * @deprecated This method wont be supported as soon as fees are mandatory. Should not be used outside of Account class
      *
      * @param invocation the invocation object containing:
      * - contractAddress - the address of the contract
@@ -1506,7 +1506,7 @@ declare abstract class ProviderInterface {
     abstract declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
     /**
      * Estimates the fee for a given INVOKE transaction
-     * @deprecated Please use getInvokeEstimateFee or getDeclareEstimateFee instead
+     * @deprecated Please use getInvokeEstimateFee or getDeclareEstimateFee instead. Should not be used outside of Account class
      *
      * @param invocation the invocation object containing:
      * - contractAddress - the address of the contract
@@ -1737,13 +1737,13 @@ declare class Provider implements ProviderInterface {
     get chainId(): StarknetChainId;
     getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
-    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<ContractClass>;
+    getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getClassHashAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<string>;
     getClassByHash(classHash: string): Promise<ContractClass>;
     getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier: BlockIdentifier): Promise<EstimateFeeResponse>;
     getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier: BlockIdentifier): Promise<BigNumberish>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
@@ -2322,6 +2322,7 @@ declare class Contract implements ContractInterface {
         [name: string]: ContractFunction;
     };
     readonly [key: string]: AsyncContractFunction | any;
+    private checkCalldata;
     /**
      * Contract class to handle contract methods
      *
@@ -2337,29 +2338,6 @@ declare class Contract implements ContractInterface {
     invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
     estimate(method: string, args?: Array<any>): Promise<EstimateFeeResponse>;
     populate(method: string, args?: Array<any>): Call;
-    /**
-     * Deep parse of the object that has been passed to the method
-     *
-     * @param struct - struct that needs to be calculated
-     * @return {number} - number of members for the given struct
-     */
-    private calculateStructMembers;
-    /**
-     * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
-     *
-     * @param type - type of the method
-     * @param method  - name of the method
-     * @param args - arguments that are passed to the method
-     */
-    protected validateMethodAndArgs(type: 'INVOKE' | 'CALL', method: string, args?: Array<any>): void;
-    /**
-     * Deep parse of the object that has been passed to the method
-     *
-     * @param element - element that needs to be parsed
-     * @param type  - name of the method
-     * @return {string | string[]} - parsed arguments in format that contract is expecting
-     */
-    protected parseCalldataValue(element: ParsedStruct | BigNumberish | BigNumberish[], type: string): string | string[];
     /**
      * Parse of the response elements that are converted to Object (Struct) by using the abi
      *
@@ -2368,22 +2346,6 @@ declare class Contract implements ContractInterface {
      * @return {BigNumberish | ParsedStruct} - parsed arguments in format that contract is expecting
      */
     protected parseResponseStruct(responseIterator: Iterator<string>, type: string): BigNumberish | ParsedStruct;
-    /**
-     * Parse one field of the calldata by using input field from the abi for that method
-     *
-     * @param args - value of the field
-     * @param input  - input(field) information from the abi that will be used to parse the data
-     * @return {string | string[]} - parsed arguments in format that contract is expecting
-     */
-    protected parseCalldataField(argsIterator: Iterator<any>, input: AbiEntry): string | string[];
-    /**
-     * Parse the calldata by using input fields from the abi for that method
-     *
-     * @param args - arguments passed the the method
-     * @param inputs  - list of inputs(fields) that are in the abi
-     * @return {Calldata} - parsed arguments in format that contract is expecting
-     */
-    protected compileCalldata(args: Array<any>, inputs: AbiEntry[]): Calldata;
     /**
      * Parse elements of the response and structuring them into one field by using output property from the abi for that method
      *
@@ -2407,15 +2369,16 @@ declare class ContractFactory {
     compiledContract: CompiledContract;
     classHash: string;
     account: AccountInterface;
+    private checkCalldata;
     constructor(compiledContract: CompiledContract, classHash: string, account: AccountInterface, abi?: Abi);
     /**
      * Deploys contract and returns new instance of the Contract
      *
-     * @param constructorCalldata - Constructor Calldata
+     * @param args - Array of the constructor arguments for deployment
      * @param addressSalt (optional) - Address Salt for deployment
      * @returns deployed Contract
      */
-    deploy(constructorCalldata?: RawArgs, addressSalt?: string | undefined): Promise<Contract>;
+    deploy(args?: Array<any>, addressSalt?: string | undefined): Promise<Contract>;
     /**
      * Attaches to new Provider or Account
      *