starknet 4.16.0 → 4.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.16.0",
+  "version": "4.17.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,13 +21,14 @@
     "build:esm": "tsup --clean false --format esm --platform node",
     "build:iife": "tsup --clean false --format iife --platform browser",
     "build:dts": "tsup --clean false --dts-only",
-    "pretest": "npm run lint",
+    "pretest": "npm run lint && npm run ts:check",
     "test": "jest -i",
     "posttest": "npm run format",
     "test:watch": "jest --watch",
     "docs": "cd www && npm run start",
     "format": "prettier --loglevel warn --write \"**/*.{ts,js,md,yml,json}\"",
-    "lint": "eslint . --cache --fix --ext .ts"
+    "lint": "eslint . --cache --fix --ext .ts",
+    "ts:check": "tsc --noEmit --resolveJsonModule --project tsconfig.eslint.json"
   },
   "keywords": [
     "starknet",

package/src/contract/contractFactory.ts

@@ -1,7 +1,8 @@
 import assert from 'minimalistic-assert';
 
 import { AccountInterface } from '../account';
-import { Abi, CompiledContract, RawArgs } from '../types';
+import { Abi, CompiledContract, FunctionAbi } from '../types';
+import { CheckCallData } from '../utils/calldata';
 import { Contract } from './default';
 
 export class ContractFactory {
@@ -13,6 +14,8 @@ export class ContractFactory {
 
   account: AccountInterface;
 
+  private checkCalldata: CheckCallData;
+
   constructor(
     compiledContract: CompiledContract,
     classHash: string,
@@ -23,19 +26,23 @@ export class ContractFactory {
     this.compiledContract = compiledContract;
     this.account = account;
     this.classHash = classHash;
+    this.checkCalldata = new CheckCallData(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
    */
-  public async deploy(
-    constructorCalldata?: RawArgs,
-    addressSalt?: string | undefined
-  ): Promise<Contract> {
+  public async deploy(args: Array<any> = [], addressSalt?: string | undefined): Promise<Contract> {
+    this.checkCalldata.validateMethodAndArgs('DEPLOY', 'constructor', args);
+    const { inputs } = this.abi.find((abi) => abi.type === 'constructor') as FunctionAbi;
+
+    // compile calldata
+    const constructorCalldata = this.checkCalldata.compileCalldata(args, inputs);
+
     const {
       deploy: { contract_address, transaction_hash },
     } = await this.account.declareDeploy({

package/src/contract/default.ts

@@ -10,7 +10,6 @@ import {
   AsyncContractFunction,
   BlockTag,
   Call,
-  Calldata,
   ContractFunction,
   FunctionAbi,
   InvokeFunctionResponse,
@@ -19,7 +18,8 @@ import {
   Result,
   StructAbi,
 } from '../types';
-import { BigNumberish, toBN, toFelt } from '../utils/number';
+import { CheckCallData } from '../utils/calldata';
+import { BigNumberish, toBN } from '../utils/number';
 import { CallOptions, ContractInterface } from './interface';
 
 function parseFelt(candidate: string): BN {
@@ -121,6 +121,8 @@ export class Contract implements ContractInterface {
 
   readonly [key: string]: AsyncContractFunction | any;
 
+  private checkCalldata: CheckCallData;
+
   /**
    * Contract class to handle contract methods
    *
@@ -145,6 +147,7 @@ export class Contract implements ContractInterface {
         }),
         {}
       );
+    this.checkCalldata = new CheckCallData(abi);
 
     Object.defineProperty(this, 'functions', {
       enumerable: true,
@@ -240,11 +243,11 @@ export class Contract implements ContractInterface {
     assert(this.address !== null, 'contract is not connected to an address');
 
     // validate method and args
-    this.validateMethodAndArgs('CALL', method, args);
+    this.checkCalldata.validateMethodAndArgs('CALL', method, args);
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
 
     // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
+    const calldata = this.checkCalldata.compileCalldata(args, inputs);
     return this.providerOrAccount
       .callContract(
         {
@@ -265,7 +268,7 @@ export class Contract implements ContractInterface {
     // ensure contract is connected
     assert(this.address !== null, 'contract is not connected to an address');
     // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
+    this.checkCalldata.validateMethodAndArgs('INVOKE', method, args);
 
     const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
     const inputsLength = inputs.reduce((acc, input) => {
@@ -281,7 +284,7 @@ export class Contract implements ContractInterface {
       );
     }
     // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
+    const calldata = this.checkCalldata.compileCalldata(args, inputs);
 
     const invocation = {
       contractAddress: this.address,
@@ -318,7 +321,7 @@ export class Contract implements ContractInterface {
     assert(this.address !== null, 'contract is not connected to an address');
 
     // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
+    this.checkCalldata.validateMethodAndArgs('INVOKE', method, args);
     const invocation = this.populateTransaction[method](...args);
     if ('estimateInvokeFee' in this.providerOrAccount) {
       return this.providerOrAccount.estimateInvokeFee(invocation);
@@ -331,167 +334,10 @@ export class Contract implements ContractInterface {
     return {
       contractAddress: this.address,
       entrypoint: method,
-      calldata: this.compileCalldata(args, inputs),
+      calldata: this.checkCalldata.compileCalldata(args, inputs),
     };
   }
 
-  /**
-   * 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(struct: string): number {
-    return this.structs[struct].members.reduce((acc, member) => {
-      if (member.type === 'felt') {
-        return acc + 1;
-      }
-      return acc + this.calculateStructMembers(member.type);
-    }, 0);
-  }
-
-  /**
-   * 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> = []) {
-    // ensure provided method exists
-    const invocableFunctionNames = this.abi
-      .filter((abi) => {
-        if (abi.type !== 'function') return false;
-        const isView = abi.stateMutability === 'view';
-        return type === 'INVOKE' ? !isView : isView;
-      })
-      .map((abi) => abi.name);
-    assert(
-      invocableFunctionNames.includes(method),
-      `${type === 'INVOKE' ? 'invocable' : 'viewable'} method not found in abi`
-    );
-
-    // ensure args match abi type
-    const methodAbi = this.abi.find(
-      (abi) => abi.name === method && abi.type === 'function'
-    ) as FunctionAbi;
-    let argPosition = 0;
-    methodAbi.inputs.forEach((input) => {
-      if (/_len$/.test(input.name)) {
-        return;
-      }
-      if (input.type === 'felt') {
-        assert(
-          typeof args[argPosition] === 'string' ||
-            typeof args[argPosition] === 'number' ||
-            args[argPosition] instanceof BN,
-          `arg ${input.name} should be a felt (string, number, BigNumber)`
-        );
-        argPosition += 1;
-      } else if (input.type in this.structs && typeof args[argPosition] === 'object') {
-        if (Array.isArray(args[argPosition])) {
-          const structMembersLength = this.calculateStructMembers(input.type);
-          assert(
-            args[argPosition].length === structMembersLength,
-            `arg should be of length ${structMembersLength}`
-          );
-        } else {
-          this.structs[input.type].members.forEach(({ name }) => {
-            assert(
-              Object.keys(args[argPosition]).includes(name),
-              `arg should have a property ${name}`
-            );
-          });
-        }
-        argPosition += 1;
-      } else {
-        assert(Array.isArray(args[argPosition]), `arg ${input.name} should be an Array`);
-        if (input.type === 'felt*') {
-          args[argPosition].forEach((felt: BigNumberish) => {
-            assert(
-              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
-              `arg ${input.name} should be an array of string, number or BigNumber`
-            );
-          });
-          argPosition += 1;
-        } else if (/\(felt/.test(input.type)) {
-          const tupleLength = input.type.split(',').length;
-          assert(
-            args[argPosition].length === tupleLength,
-            `arg ${input.name} should have ${tupleLength} elements in tuple`
-          );
-          args[argPosition].forEach((felt: BigNumberish) => {
-            assert(
-              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
-              `arg ${input.name} should be an array of string, number or BigNumber`
-            );
-          });
-          argPosition += 1;
-        } else {
-          const arrayType = input.type.replace('*', '');
-          args[argPosition].forEach((struct: any) => {
-            this.structs[arrayType].members.forEach(({ name }) => {
-              if (Array.isArray(struct)) {
-                const structMembersLength = this.calculateStructMembers(arrayType);
-                assert(
-                  struct.length === structMembersLength,
-                  `arg should be of length ${structMembersLength}`
-                );
-              } else {
-                assert(
-                  Object.keys(struct).includes(name),
-                  `arg ${input.name} should be an array of ${arrayType}`
-                );
-              }
-            });
-          });
-          argPosition += 1;
-        }
-      }
-    });
-  }
-
-  /**
-   * 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[] {
-    if (element === undefined) {
-      throw Error('Missing element in calldata');
-    }
-    if (Array.isArray(element)) {
-      const structMemberNum = this.calculateStructMembers(type);
-      if (element.length !== structMemberNum) {
-        throw Error('Missing element in calldata');
-      }
-      return element.map((el) => toFelt(el));
-    }
-    // checking if the passed element is struct or element in struct
-    if (this.structs[type] && this.structs[type].members.length) {
-      // going through all the members of the struct and parsing the value
-      return this.structs[type].members.reduce((acc, member: AbiEntry) => {
-        // if the member of the struct is another struct this will return array of the felts if not it will be single felt
-        // TODO: refactor types so member name can be used as keyof ParsedStruct
-        /* @ts-ignore */
-        const parsedData = this.parseCalldataValue(element[member.name], member.type);
-        if (typeof parsedData === 'string') {
-          acc.push(parsedData);
-        } else {
-          acc.push(...parsedData);
-        }
-        return acc;
-      }, [] as string[]);
-    }
-    return toFelt(element as BigNumberish);
-  }
-
   /**
    * Parse of the response elements that are converted to Object (Struct) by using the abi
    *
@@ -514,67 +360,6 @@ export class Contract implements ContractInterface {
     return parseFelt(responseIterator.next().value);
   }
 
-  /**
-   * 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[] {
-    const { name, type } = input;
-    const { value } = argsIterator.next();
-
-    const parsedCalldata: string[] = [];
-    switch (true) {
-      case /\*/.test(type):
-        if (Array.isArray(value)) {
-          parsedCalldata.push(toFelt(value.length));
-          return (value as (BigNumberish | ParsedStruct)[]).reduce((acc, el) => {
-            if (/felt/.test(type)) {
-              acc.push(toFelt(el as BigNumberish));
-            } else {
-              acc.push(...this.parseCalldataValue(el, type.replace('*', '')));
-            }
-            return acc;
-          }, parsedCalldata);
-        }
-        throw Error(`Expected ${name} to be array`);
-      case type in this.structs:
-        return this.parseCalldataValue(value as ParsedStruct | BigNumberish[], type);
-      case /\(felt/.test(type):
-        if (Array.isArray(value)) {
-          return value.map((el) => toFelt(el as BigNumberish));
-        }
-        throw Error(`Expected ${name} to be array`);
-      default:
-        return toFelt(value as BigNumberish);
-    }
-  }
-
-  /**
-   * 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 {
-    const argsIterator = args[Symbol.iterator]();
-    return inputs.reduce((acc, input) => {
-      if (/_len$/.test(input.name)) {
-        return acc;
-      }
-      const parsedData = this.parseCalldataField(argsIterator, input);
-      if (Array.isArray(parsedData)) {
-        acc.push(...parsedData);
-      } else {
-        acc.push(parsedData);
-      }
-      return acc;
-    }, [] as Calldata);
-  }
-
   /**
    * Parse elements of the response and structuring them into one field by using output property from the abi for that method
    *

package/src/provider/default.ts

@@ -67,7 +67,7 @@ export class Provider implements ProviderInterface {
 
   public async getClassAt(
     contractAddress: string,
-    blockIdentifier: BlockIdentifier
+    blockIdentifier?: BlockIdentifier
   ): Promise<ContractClass> {
     return this.provider.getClassAt(contractAddress, blockIdentifier);
   }
@@ -113,7 +113,7 @@ export class Provider implements ProviderInterface {
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockIdentifier: BlockIdentifier
+    blockIdentifier?: BlockIdentifier
   ): Promise<BigNumberish> {
     return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
   }

package/src/provider/interface.ts

@@ -150,7 +150,7 @@ export abstract class ProviderInterface {
 
   /**
    * 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
@@ -187,7 +187,7 @@ export abstract class ProviderInterface {
 
   /**
    * 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

package/src/utils/calldata.ts

@@ -0,0 +1,250 @@
+import BN from 'bn.js';
+import assert from 'minimalistic-assert';
+
+import { Abi, AbiEntry, Calldata, FunctionAbi, ParsedStruct, StructAbi } from '../types';
+import { BigNumberish, toFelt } from './number';
+
+export class CheckCallData {
+  abi: Abi;
+
+  protected readonly structs: { [name: string]: StructAbi };
+
+  constructor(abi: Abi) {
+    this.abi = abi;
+    this.structs = abi
+      .filter((abiEntry) => abiEntry.type === 'struct')
+      .reduce(
+        (acc, abiEntry) => ({
+          ...acc,
+          [abiEntry.name]: abiEntry,
+        }),
+        {}
+      );
+  }
+
+  /**
+   * 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
+   */
+  public compileCalldata(args: Array<any>, inputs: AbiEntry[]): Calldata {
+    const argsIterator = args[Symbol.iterator]();
+    return inputs.reduce((acc, input) => {
+      if (/_len$/.test(input.name)) {
+        return acc;
+      }
+      const parsedData = this.parseCalldataField(argsIterator, input);
+      if (Array.isArray(parsedData)) {
+        acc.push(...parsedData);
+      } else {
+        acc.push(parsedData);
+      }
+      return acc;
+    }, [] as Calldata);
+  }
+
+  /**
+   * 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
+   */
+  public validateMethodAndArgs(
+    type: 'INVOKE' | 'CALL' | 'DEPLOY',
+    method: string,
+    args: Array<any> = []
+  ) {
+    // ensure provided method exists
+    if (type !== 'DEPLOY') {
+      const invocableFunctionNames = this.abi
+        .filter((abi) => {
+          if (abi.type !== 'function') return false;
+          const isView = abi.stateMutability === 'view';
+          return type === 'INVOKE' ? !isView : isView;
+        })
+        .map((abi) => abi.name);
+      assert(
+        invocableFunctionNames.includes(method),
+        `${type === 'INVOKE' ? 'invocable' : 'viewable'} method not found in abi`
+      );
+    }
+
+    // ensure args match abi type
+    const methodAbi = this.abi.find((abi) =>
+      type === 'DEPLOY'
+        ? abi.name === method && abi.type === method
+        : abi.name === method && abi.type === 'function'
+    ) as FunctionAbi;
+    let argPosition = 0;
+    methodAbi.inputs.forEach((input) => {
+      if (/_len$/.test(input.name)) {
+        return;
+      }
+      if (input.type === 'felt') {
+        assert(
+          typeof args[argPosition] === 'string' ||
+            typeof args[argPosition] === 'number' ||
+            args[argPosition] instanceof BN,
+          `arg ${input.name} should be a felt (string, number, BigNumber)`
+        );
+        argPosition += 1;
+      } else if (input.type in this.structs && typeof args[argPosition] === 'object') {
+        if (Array.isArray(args[argPosition])) {
+          const structMembersLength = this.calculateStructMembers(input.type);
+          assert(
+            args[argPosition].length === structMembersLength,
+            `arg should be of length ${structMembersLength}`
+          );
+        } else {
+          this.structs[input.type].members.forEach(({ name }) => {
+            assert(
+              Object.keys(args[argPosition]).includes(name),
+              `arg should have a property ${name}`
+            );
+          });
+        }
+        argPosition += 1;
+      } else {
+        assert(Array.isArray(args[argPosition]), `arg ${input.name} should be an Array`);
+        if (input.type === 'felt*') {
+          args[argPosition].forEach((felt: BigNumberish) => {
+            assert(
+              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
+              `arg ${input.name} should be an array of string, number or BigNumber`
+            );
+          });
+          argPosition += 1;
+        } else if (/\(felt/.test(input.type)) {
+          const tupleLength = input.type.split(',').length;
+          assert(
+            args[argPosition].length === tupleLength,
+            `arg ${input.name} should have ${tupleLength} elements in tuple`
+          );
+          args[argPosition].forEach((felt: BigNumberish) => {
+            assert(
+              typeof felt === 'string' || typeof felt === 'number' || felt instanceof BN,
+              `arg ${input.name} should be an array of string, number or BigNumber`
+            );
+          });
+          argPosition += 1;
+        } else {
+          const arrayType = input.type.replace('*', '');
+          args[argPosition].forEach((struct: any) => {
+            this.structs[arrayType].members.forEach(({ name }) => {
+              if (Array.isArray(struct)) {
+                const structMembersLength = this.calculateStructMembers(arrayType);
+                assert(
+                  struct.length === structMembersLength,
+                  `arg should be of length ${structMembersLength}`
+                );
+              } else {
+                assert(
+                  Object.keys(struct).includes(name),
+                  `arg ${input.name} should be an array of ${arrayType}`
+                );
+              }
+            });
+          });
+          argPosition += 1;
+        }
+      }
+    });
+  }
+
+  /**
+   * 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[] {
+    const { name, type } = input;
+    const { value } = argsIterator.next();
+
+    const parsedCalldata: string[] = [];
+    switch (true) {
+      case /\*/.test(type):
+        if (Array.isArray(value)) {
+          parsedCalldata.push(toFelt(value.length));
+          return (value as (BigNumberish | ParsedStruct)[]).reduce((acc, el) => {
+            if (/felt/.test(type)) {
+              acc.push(toFelt(el as BigNumberish));
+            } else {
+              acc.push(...this.parseCalldataValue(el, type.replace('*', '')));
+            }
+            return acc;
+          }, parsedCalldata);
+        }
+        throw Error(`Expected ${name} to be array`);
+      case type in this.structs:
+        return this.parseCalldataValue(value as ParsedStruct | BigNumberish[], type);
+      case /\(felt/.test(type):
+        if (Array.isArray(value)) {
+          return value.map((el) => toFelt(el as BigNumberish));
+        }
+        throw Error(`Expected ${name} to be array`);
+      default:
+        return toFelt(value as BigNumberish);
+    }
+  }
+
+  /**
+   * 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[] {
+    if (element === undefined) {
+      throw Error('Missing element in calldata');
+    }
+    if (Array.isArray(element)) {
+      const structMemberNum = this.calculateStructMembers(type);
+      if (element.length !== structMemberNum) {
+        throw Error('Missing element in calldata');
+      }
+      return element.map((el) => toFelt(el));
+    }
+    // checking if the passed element is struct or element in struct
+    if (this.structs[type] && this.structs[type].members.length) {
+      // going through all the members of the struct and parsing the value
+      return this.structs[type].members.reduce((acc, member: AbiEntry) => {
+        // if the member of the struct is another struct this will return array of the felts if not it will be single felt
+        // TODO: refactor types so member name can be used as keyof ParsedStruct
+        /* @ts-ignore */
+        const parsedData = this.parseCalldataValue(element[member.name], member.type);
+        if (typeof parsedData === 'string') {
+          acc.push(parsedData);
+        } else {
+          acc.push(...parsedData);
+        }
+        return acc;
+      }, [] as string[]);
+    }
+    return toFelt(element as BigNumberish);
+  }
+
+  /**
+   * 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(struct: string): number {
+    return this.structs[struct].members.reduce((acc, member) => {
+      if (member.type === 'felt') {
+        return acc + 1;
+      }
+      return acc + this.calculateStructMembers(member.type);
+    }, 0);
+  }
+}