starknet 4.16.0 → 4.17.0

package/dist/index.mjs

@@ -5,8 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/contract/default.ts
-import BN3 from "bn.js";
-import assert4 from "minimalistic-assert";
+import assert5 from "minimalistic-assert";
 
 // src/utils/fetchPonyfill.ts
 import isomorphicFetch from "isomorphic-fetch";
@@ -3467,6 +3466,187 @@ var ProviderInterface = class {
 // src/provider/index.ts
 var defaultProvider = new Provider();
 
+// src/utils/calldata.ts
+import BN3 from "bn.js";
+import assert4 from "minimalistic-assert";
+var CheckCallData = class {
+  constructor(abi) {
+    this.abi = abi;
+    this.structs = abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+      (acc, abiEntry) => ({
+        ...acc,
+        [abiEntry.name]: abiEntry
+      }),
+      {}
+    );
+  }
+  compileCalldata(args, inputs) {
+    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;
+    }, []);
+  }
+  validateMethodAndArgs(type, method, args = []) {
+    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);
+      assert4(
+        invocableFunctionNames.includes(method),
+        `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
+      );
+    }
+    const methodAbi = this.abi.find(
+      (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+    );
+    let argPosition = 0;
+    methodAbi.inputs.forEach((input) => {
+      if (/_len$/.test(input.name)) {
+        return;
+      }
+      if (input.type === "felt") {
+        assert4(
+          typeof args[argPosition] === "string" || typeof args[argPosition] === "number" || args[argPosition] instanceof BN3,
+          `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);
+          assert4(
+            args[argPosition].length === structMembersLength,
+            `arg should be of length ${structMembersLength}`
+          );
+        } else {
+          this.structs[input.type].members.forEach(({ name }) => {
+            assert4(
+              Object.keys(args[argPosition]).includes(name),
+              `arg should have a property ${name}`
+            );
+          });
+        }
+        argPosition += 1;
+      } else {
+        assert4(Array.isArray(args[argPosition]), `arg ${input.name} should be an Array`);
+        if (input.type === "felt*") {
+          args[argPosition].forEach((felt) => {
+            assert4(
+              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
+              `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;
+          assert4(
+            args[argPosition].length === tupleLength,
+            `arg ${input.name} should have ${tupleLength} elements in tuple`
+          );
+          args[argPosition].forEach((felt) => {
+            assert4(
+              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
+              `arg ${input.name} should be an array of string, number or BigNumber`
+            );
+          });
+          argPosition += 1;
+        } else {
+          const arrayType = input.type.replace("*", "");
+          args[argPosition].forEach((struct) => {
+            this.structs[arrayType].members.forEach(({ name }) => {
+              if (Array.isArray(struct)) {
+                const structMembersLength = this.calculateStructMembers(arrayType);
+                assert4(
+                  struct.length === structMembersLength,
+                  `arg should be of length ${structMembersLength}`
+                );
+              } else {
+                assert4(
+                  Object.keys(struct).includes(name),
+                  `arg ${input.name} should be an array of ${arrayType}`
+                );
+              }
+            });
+          });
+          argPosition += 1;
+        }
+      }
+    });
+  }
+  parseCalldataField(argsIterator, input) {
+    const { name, type } = input;
+    const { value } = argsIterator.next();
+    const parsedCalldata = [];
+    switch (true) {
+      case /\*/.test(type):
+        if (Array.isArray(value)) {
+          parsedCalldata.push(toFelt(value.length));
+          return value.reduce((acc, el) => {
+            if (/felt/.test(type)) {
+              acc.push(toFelt(el));
+            } 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, type);
+      case /\(felt/.test(type):
+        if (Array.isArray(value)) {
+          return value.map((el) => toFelt(el));
+        }
+        throw Error(`Expected ${name} to be array`);
+      default:
+        return toFelt(value);
+    }
+  }
+  parseCalldataValue(element, type) {
+    if (element === void 0) {
+      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));
+    }
+    if (this.structs[type] && this.structs[type].members.length) {
+      return this.structs[type].members.reduce((acc, member) => {
+        const parsedData = this.parseCalldataValue(element[member.name], member.type);
+        if (typeof parsedData === "string") {
+          acc.push(parsedData);
+        } else {
+          acc.push(...parsedData);
+        }
+        return acc;
+      }, []);
+    }
+    return toFelt(element);
+  }
+  calculateStructMembers(struct) {
+    return this.structs[struct].members.reduce((acc, member) => {
+      if (member.type === "felt") {
+        return acc + 1;
+      }
+      return acc + this.calculateStructMembers(member.type);
+    }, 0);
+  }
+};
+
 // src/contract/default.ts
 function parseFelt(candidate) {
   try {
@@ -3530,6 +3710,7 @@ var Contract = class {
       }),
       {}
     );
+    this.checkCalldata = new CheckCallData(abi);
     Object.defineProperty(this, "functions", {
       enumerable: true,
       value: {},
@@ -3607,10 +3788,10 @@ var Contract = class {
   }
   async call(method, args = [], options = {}) {
     const blockIdentifier = (options == null ? void 0 : options.blockIdentifier) || void 0;
-    assert4(this.address !== null, "contract is not connected to an address");
-    this.validateMethodAndArgs("CALL", method, args);
+    assert5(this.address !== null, "contract is not connected to an address");
+    this.checkCalldata.validateMethodAndArgs("CALL", method, args);
     const { inputs } = this.abi.find((abi) => abi.name === method);
-    const calldata = this.compileCalldata(args, inputs);
+    const calldata = this.checkCalldata.compileCalldata(args, inputs);
     return this.providerOrAccount.callContract(
       {
         contractAddress: this.address,
@@ -3621,8 +3802,8 @@ var Contract = class {
     ).then((x) => this.parseResponse(method, x.result));
   }
   invoke(method, args = [], options = {}) {
-    assert4(this.address !== null, "contract is not connected to an address");
-    this.validateMethodAndArgs("INVOKE", method, args);
+    assert5(this.address !== null, "contract is not connected to an address");
+    this.checkCalldata.validateMethodAndArgs("INVOKE", method, args);
     const { inputs } = this.abi.find((abi) => abi.name === method);
     const inputsLength = inputs.reduce((acc, input) => {
       if (!/_len$/.test(input.name)) {
@@ -3635,7 +3816,7 @@ var Contract = class {
         `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
       );
     }
-    const calldata = this.compileCalldata(args, inputs);
+    const calldata = this.checkCalldata.compileCalldata(args, inputs);
     const invocation = {
       contractAddress: this.address,
       calldata,
@@ -3662,8 +3843,8 @@ var Contract = class {
     );
   }
   async estimate(method, args = []) {
-    assert4(this.address !== null, "contract is not connected to an address");
-    this.validateMethodAndArgs("INVOKE", method, args);
+    assert5(this.address !== null, "contract is not connected to an address");
+    this.checkCalldata.validateMethodAndArgs("INVOKE", method, args);
     const invocation = this.populateTransaction[method](...args);
     if ("estimateInvokeFee" in this.providerOrAccount) {
       return this.providerOrAccount.estimateInvokeFee(invocation);
@@ -3675,128 +3856,9 @@ var Contract = class {
     return {
       contractAddress: this.address,
       entrypoint: method,
-      calldata: this.compileCalldata(args, inputs)
+      calldata: this.checkCalldata.compileCalldata(args, inputs)
     };
   }
-  calculateStructMembers(struct) {
-    return this.structs[struct].members.reduce((acc, member) => {
-      if (member.type === "felt") {
-        return acc + 1;
-      }
-      return acc + this.calculateStructMembers(member.type);
-    }, 0);
-  }
-  validateMethodAndArgs(type, method, args = []) {
-    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);
-    assert4(
-      invocableFunctionNames.includes(method),
-      `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
-    );
-    const methodAbi = this.abi.find(
-      (abi) => abi.name === method && abi.type === "function"
-    );
-    let argPosition = 0;
-    methodAbi.inputs.forEach((input) => {
-      if (/_len$/.test(input.name)) {
-        return;
-      }
-      if (input.type === "felt") {
-        assert4(
-          typeof args[argPosition] === "string" || typeof args[argPosition] === "number" || args[argPosition] instanceof BN3,
-          `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);
-          assert4(
-            args[argPosition].length === structMembersLength,
-            `arg should be of length ${structMembersLength}`
-          );
-        } else {
-          this.structs[input.type].members.forEach(({ name }) => {
-            assert4(
-              Object.keys(args[argPosition]).includes(name),
-              `arg should have a property ${name}`
-            );
-          });
-        }
-        argPosition += 1;
-      } else {
-        assert4(Array.isArray(args[argPosition]), `arg ${input.name} should be an Array`);
-        if (input.type === "felt*") {
-          args[argPosition].forEach((felt) => {
-            assert4(
-              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
-              `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;
-          assert4(
-            args[argPosition].length === tupleLength,
-            `arg ${input.name} should have ${tupleLength} elements in tuple`
-          );
-          args[argPosition].forEach((felt) => {
-            assert4(
-              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
-              `arg ${input.name} should be an array of string, number or BigNumber`
-            );
-          });
-          argPosition += 1;
-        } else {
-          const arrayType = input.type.replace("*", "");
-          args[argPosition].forEach((struct) => {
-            this.structs[arrayType].members.forEach(({ name }) => {
-              if (Array.isArray(struct)) {
-                const structMembersLength = this.calculateStructMembers(arrayType);
-                assert4(
-                  struct.length === structMembersLength,
-                  `arg should be of length ${structMembersLength}`
-                );
-              } else {
-                assert4(
-                  Object.keys(struct).includes(name),
-                  `arg ${input.name} should be an array of ${arrayType}`
-                );
-              }
-            });
-          });
-          argPosition += 1;
-        }
-      }
-    });
-  }
-  parseCalldataValue(element, type) {
-    if (element === void 0) {
-      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));
-    }
-    if (this.structs[type] && this.structs[type].members.length) {
-      return this.structs[type].members.reduce((acc, member) => {
-        const parsedData = this.parseCalldataValue(element[member.name], member.type);
-        if (typeof parsedData === "string") {
-          acc.push(parsedData);
-        } else {
-          acc.push(...parsedData);
-        }
-        return acc;
-      }, []);
-    }
-    return toFelt(element);
-  }
   parseResponseStruct(responseIterator, type) {
     if (type in this.structs && this.structs[type]) {
       return this.structs[type].members.reduce((acc, el) => {
@@ -3806,50 +3868,6 @@ var Contract = class {
     }
     return parseFelt(responseIterator.next().value);
   }
-  parseCalldataField(argsIterator, input) {
-    const { name, type } = input;
-    const { value } = argsIterator.next();
-    const parsedCalldata = [];
-    switch (true) {
-      case /\*/.test(type):
-        if (Array.isArray(value)) {
-          parsedCalldata.push(toFelt(value.length));
-          return value.reduce((acc, el) => {
-            if (/felt/.test(type)) {
-              acc.push(toFelt(el));
-            } 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, type);
-      case /\(felt/.test(type):
-        if (Array.isArray(value)) {
-          return value.map((el) => toFelt(el));
-        }
-        throw Error(`Expected ${name} to be array`);
-      default:
-        return toFelt(value);
-    }
-  }
-  compileCalldata(args, inputs) {
-    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;
-    }, []);
-  }
   parseResponseField(responseIterator, output, parsedResult) {
     const { name, type } = output;
     const parsedDataArr = [];
@@ -3900,15 +3918,19 @@ var ContractInterface = class {
 };
 
 // src/contract/contractFactory.ts
-import assert5 from "minimalistic-assert";
+import assert6 from "minimalistic-assert";
 var ContractFactory = class {
   constructor(compiledContract, classHash, account, abi = compiledContract.abi) {
     this.abi = abi;
     this.compiledContract = compiledContract;
     this.account = account;
     this.classHash = classHash;
+    this.checkCalldata = new CheckCallData(abi);
   }
-  async deploy(constructorCalldata, addressSalt) {
+  async deploy(args = [], addressSalt) {
+    this.checkCalldata.validateMethodAndArgs("DEPLOY", "constructor", args);
+    const { inputs } = this.abi.find((abi) => abi.type === "constructor");
+    const constructorCalldata = this.checkCalldata.compileCalldata(args, inputs);
     const {
       deploy: { contract_address, transaction_hash }
     } = await this.account.declareDeploy({
@@ -3917,7 +3939,7 @@ var ContractFactory = class {
       constructorCalldata,
       salt: addressSalt
     });
-    assert5(Boolean(contract_address), "Deployment of the contract failed");
+    assert6(Boolean(contract_address), "Deployment of the contract failed");
     const contractInstance = new Contract(
       this.compiledContract.abi,
       contract_address,