starknet 3.2.0 → 3.5.0

package/{contract.js → contract/default.js}

@@ -187,8 +187,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 exports.Contract = void 0;
 var bn_js_1 = __importDefault(require('bn.js'));
 var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
-var provider_1 = require('./provider');
-var number_1 = require('./utils/number');
+var account_1 = require('../account');
+var provider_1 = require('../provider');
+var hash_1 = require('../utils/hash');
+var number_1 = require('../utils/number');
 function parseFelt(candidate) {
   try {
     return (0, number_1.toBN)(candidate);
@@ -196,23 +198,91 @@ function parseFelt(candidate) {
     throw Error('Couldnt parse felt');
   }
 }
+/**
+ * Adds call methods to the contract
+ *
+ */
+function buildCall(contract, functionAbi) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, contract.call(functionAbi.name, args)];
+      });
+    });
+  };
+}
+/**
+ * Adds invoke methods to the contract
+ *
+ */
+function buildInvoke(contract, functionAbi) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, contract.invoke(functionAbi.name, args)];
+      });
+    });
+  };
+}
+/**
+ * Adds call/invoke methods to the contract
+ *
+ */
+function buildDefault(contract, functionAbi) {
+  if (functionAbi.stateMutability === 'view') {
+    return buildCall(contract, functionAbi);
+  }
+  return buildInvoke(contract, functionAbi);
+}
+/**
+ * Adds populate for methods to the contract
+ *
+ */
+function buildPopulate(contract, functionAbi) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return contract.populate(functionAbi.name, args);
+  };
+}
+/**
+ * Adds estimateFee for methods to the contract
+ *
+ */
+function buildEstimate(contract, functionAbi) {
+  return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return contract.estimate(functionAbi.name, args);
+  };
+}
 var Contract = /** @class */ (function () {
   /**
    * Contract class to handle contract methods
    *
    * @param abi - Abi of the contract object
    * @param address (optional) - address to connect to
+   * @param providerOrAccount (optional) - Provider or Account to attach to
    */
-  function Contract(abi, address, provider) {
-    if (address === void 0) {
-      address = null;
-    }
-    if (provider === void 0) {
-      provider = provider_1.defaultProvider;
+  function Contract(abi, address, providerOrAccount) {
+    var _this = this;
+    if (providerOrAccount === void 0) {
+      providerOrAccount = provider_1.defaultProvider;
     }
-    this.connectedTo = null;
-    this.connectedTo = address;
-    this.provider = provider;
+    this.address = address;
+    this.providerOrAccount = providerOrAccount;
     this.abi = abi;
     this.structs = abi
       .filter(function (abiEntry) {
@@ -222,16 +292,109 @@ var Contract = /** @class */ (function () {
         var _a;
         return __assign(__assign({}, acc), ((_a = {}), (_a[abiEntry.name] = abiEntry), _a));
       }, {});
+    Object.defineProperty(this, 'functions', {
+      enumerable: true,
+      value: {},
+      writable: false,
+    });
+    Object.defineProperty(this, 'callStatic', {
+      enumerable: true,
+      value: {},
+      writable: false,
+    });
+    Object.defineProperty(this, 'populateTransaction', {
+      enumerable: true,
+      value: {},
+      writable: false,
+    });
+    Object.defineProperty(this, 'estimateFee', {
+      enumerable: true,
+      value: {},
+      writable: false,
+    });
+    this.abi.forEach(function (abiElement) {
+      if (abiElement.type !== 'function') {
+        return;
+      }
+      var signature = abiElement.name;
+      if (!_this[signature]) {
+        Object.defineProperty(_this, signature, {
+          enumerable: true,
+          value: buildDefault(_this, abiElement),
+          writable: false,
+        });
+      }
+      if (!_this.functions[signature]) {
+        Object.defineProperty(_this.functions, signature, {
+          enumerable: true,
+          value: buildDefault(_this, abiElement),
+          writable: false,
+        });
+      }
+      if (!_this.callStatic[signature]) {
+        Object.defineProperty(_this.callStatic, signature, {
+          enumerable: true,
+          value: buildCall(_this, abiElement),
+          writable: false,
+        });
+      }
+      if (!_this.populateTransaction[signature]) {
+        Object.defineProperty(_this.populateTransaction, signature, {
+          enumerable: true,
+          value: buildPopulate(_this, abiElement),
+          writable: false,
+        });
+      }
+      if (!_this.estimateFee[signature]) {
+        Object.defineProperty(_this.estimateFee, signature, {
+          enumerable: true,
+          value: buildEstimate(_this, abiElement),
+          writable: false,
+        });
+      }
+    });
   }
   /**
    * Saves the address of the contract deployed on network that will be used for interaction
    *
    * @param address - address of the contract
-   * @returns Contract
    */
-  Contract.prototype.connect = function (address) {
-    this.connectedTo = address;
-    return this;
+  Contract.prototype.attach = function (address) {
+    this.address = address;
+  };
+  /**
+   * Attaches to new Provider or Account
+   *
+   * @param providerOrAccount - new Provider or Account to attach to
+   */
+  Contract.prototype.connect = function (providerOrAccount) {
+    this.providerOrAccount = providerOrAccount;
+  };
+  /**
+   * Resolves when contract is deployed on the network or when no deployment transaction is found
+   *
+   * @returns Promise that resolves when contract is deployed on the network or when no deployment transaction is found
+   * @throws When deployment fails
+   */
+  Contract.prototype.deployed = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (!this.deployTransactionHash) return [3 /*break*/, 2];
+            return [
+              4 /*yield*/,
+              this.providerOrAccount.waitForTransaction(this.deployTransactionHash),
+            ];
+          case 1:
+            _a.sent();
+            this.deployTransactionHash = undefined;
+            _a.label = 2;
+          case 2:
+            return [2 /*return*/, this];
+        }
+      });
+    });
   };
   /**
    * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
@@ -243,7 +406,7 @@ var Contract = /** @class */ (function () {
   Contract.prototype.validateMethodAndArgs = function (type, method, args) {
     var _this = this;
     if (args === void 0) {
-      args = {};
+      args = [];
     }
     // ensure provided method exists
     var invokeableFunctionNames = this.abi
@@ -263,54 +426,95 @@ var Contract = /** @class */ (function () {
     var methodAbi = this.abi.find(function (abi) {
       return abi.name === method && abi.type === 'function';
     });
+    var argPosition = 0;
     methodAbi.inputs.forEach(function (input) {
-      var arg = args[input.name];
-      if (arg !== undefined) {
-        if (input.type === 'felt') {
+      if (/_len$/.test(input.name)) {
+        return;
+      }
+      if (input.type === 'felt') {
+        (0, minimalistic_assert_1.default)(
+          typeof args[argPosition] === 'string' ||
+            typeof args[argPosition] === 'number' ||
+            args[argPosition] instanceof bn_js_1.default,
+          '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])) {
+          var structMembersLength = _this.calculateStructMembers(input.type);
           (0, minimalistic_assert_1.default)(
-            typeof arg === 'string' || typeof arg === 'number' || arg instanceof bn_js_1.default,
-            'arg ' + input.name + ' should be a felt (string, number, BigNumber)'
+            args[argPosition].length === structMembersLength,
+            'arg should be of length ' + structMembersLength
           );
-        } else if (typeof arg === 'object' && input.type in _this.structs) {
+        } else {
           _this.structs[input.type].members.forEach(function (_a) {
             var name = _a.name;
             (0,
-            minimalistic_assert_1.default)(Object.keys(arg).includes(name), 'arg should have a property ' + name);
+            minimalistic_assert_1.default)(Object.keys(args[argPosition]).includes(name), 'arg should have a property ' + name);
           });
-        } else {
+        }
+        argPosition += 1;
+      } else {
+        (0, minimalistic_assert_1.default)(
+          Array.isArray(args[argPosition]),
+          'arg ' + input.name + ' should be an Array'
+        );
+        if (input.type === 'felt*') {
+          args[argPosition].forEach(function (felt) {
+            (0,
+            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
+          });
+          argPosition += 1;
+        } else if (/\(felt/.test(input.type)) {
+          var tupleLength = input.type.split(',').length;
           (0, minimalistic_assert_1.default)(
-            Array.isArray(arg),
-            'arg ' + input.name + ' should be an Array'
+            args[argPosition].length === tupleLength,
+            'arg ' + input.name + ' should have ' + tupleLength + ' elements in tuple'
           );
-          if (input.type === 'felt*') {
-            arg.forEach(function (felt) {
-              (0,
-              minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
-            });
-          } else if (/\(felt/.test(input.type)) {
-            var tupleLength = input.type.split(',').length;
-            (0, minimalistic_assert_1.default)(
-              arg.length === tupleLength,
-              'arg ' + input.name + ' should have ' + tupleLength + ' elements in tuple'
-            );
-            arg.forEach(function (felt) {
-              (0,
-              minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
-            });
-          } else {
-            var arrayType_1 = input.type.replace('*', '');
-            arg.forEach(function (struct) {
-              _this.structs[arrayType_1].members.forEach(function (_a) {
-                var name = _a.name;
-                (0,
-                minimalistic_assert_1.default)(Object.keys(struct).includes(name), 'arg ' + input.name + ' should be an array of ' + arrayType_1);
-              });
+          args[argPosition].forEach(function (felt) {
+            (0,
+            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
+          });
+          argPosition += 1;
+        } else {
+          var arrayType_1 = input.type.replace('*', '');
+          args[argPosition].forEach(function (struct) {
+            _this.structs[arrayType_1].members.forEach(function (_a) {
+              var name = _a.name;
+              if (Array.isArray(struct)) {
+                var structMembersLength = _this.calculateStructMembers(arrayType_1);
+                (0, minimalistic_assert_1.default)(
+                  struct.length === structMembersLength,
+                  'arg should be of length ' + structMembersLength
+                );
+              } else {
+                (0, minimalistic_assert_1.default)(
+                  Object.keys(struct).includes(name),
+                  'arg ' + input.name + ' should be an array of ' + arrayType_1
+                );
+              }
             });
-          }
+          });
+          argPosition += 1;
         }
       }
     });
   };
+  /**
+   * 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
+   */
+  Contract.prototype.calculateStructMembers = function (struct) {
+    var _this = this;
+    return this.structs[struct].members.reduce(function (acc, member) {
+      if (member.type === 'felt') {
+        return acc + 1;
+      }
+      return acc + _this.structMemberNum(member.type);
+    }, 0);
+  };
   /**
    * Deep parse of the object that has been passed to the method
    *
@@ -318,10 +522,19 @@ var Contract = /** @class */ (function () {
    * @param type  - name of the method
    * @return {string | string[]} - parsed arguments in format that contract is expecting
    */
-  Contract.prototype.parseCalldataObject = function (element, type) {
+  Contract.prototype.parseCalldataValue = function (element, type) {
     var _this = this;
     if (element === undefined) {
-      throw Error('Missing element in calldata object');
+      throw Error('Missing element in calldata');
+    }
+    if (Array.isArray(element)) {
+      var structMemberNum = this.calculateStructMembers(type);
+      if (element.length !== structMemberNum) {
+        throw Error('Missing element in calldata');
+      }
+      return element.map(function (el) {
+        return (0, number_1.toFelt)(el);
+      });
     }
     // checking if the passed element is struct or element in struct
     if (this.structs[type] && this.structs[type].members.length) {
@@ -330,7 +543,7 @@ var Contract = /** @class */ (function () {
         // 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 */
-        var parsedData = _this.parseCalldataObject(element[member.name], member.type);
+        var parsedData = _this.parseCalldataValue(element[member.name], member.type);
         if (typeof parsedData === 'string') {
           acc.push(parsedData);
         } else {
@@ -367,21 +580,16 @@ var Contract = /** @class */ (function () {
    * @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
    */
-  Contract.prototype.parsCalldataField = function (args, input) {
+  Contract.prototype.parseCalldataField = function (argsIterator, input) {
     var _this = this;
     var name = input.name,
       type = input.type;
-    var value = args[name];
-    var propName = name.replace(/_len$/, '');
+    var value = argsIterator.next().value;
+    var parsedCalldata = [];
     switch (true) {
-      case /_len$/.test(name):
-        if (Array.isArray(args[propName])) {
-          var arr = args[propName];
-          return (0, number_1.toFelt)(arr.length);
-        }
-        throw Error('Expected ' + propName + ' to be array');
       case /\*/.test(type):
         if (Array.isArray(value)) {
+          parsedCalldata.push((0, number_1.toFelt)(value.length));
           return value.reduce(function (acc, el) {
             if (/felt/.test(type)) {
               acc.push((0, number_1.toFelt)(el));
@@ -390,17 +598,17 @@ var Contract = /** @class */ (function () {
                 acc,
                 __spreadArray(
                   [],
-                  __read(_this.parseCalldataObject(el, type.replace('*', ''))),
+                  __read(_this.parseCalldataValue(el, type.replace('*', ''))),
                   false
                 )
               );
             }
             return acc;
-          }, []);
+          }, parsedCalldata);
         }
         throw Error('Expected ' + name + ' to be array');
       case type in this.structs:
-        return this.parseCalldataObject(value, type);
+        return this.parseCalldataValue(value, type);
       case /\(felt/.test(type):
         if (Array.isArray(value)) {
           return value.map(function (el) {
@@ -421,8 +629,12 @@ var Contract = /** @class */ (function () {
    */
   Contract.prototype.compileCalldata = function (args, inputs) {
     var _this = this;
+    var argsIterator = args[Symbol.iterator]();
     return inputs.reduce(function (acc, input) {
-      var parsedData = _this.parsCalldataField(args, input);
+      if (/_len$/.test(input.name)) {
+        return acc;
+      }
+      var parsedData = _this.parseCalldataField(argsIterator, input);
       if (Array.isArray(parsedData)) {
         acc.push.apply(acc, __spreadArray([], __read(parsedData), false));
       } else {
@@ -441,7 +653,6 @@ var Contract = /** @class */ (function () {
   Contract.prototype.parseResponseField = function (responseIterator, output, parsedResult) {
     var name = output.name,
       type = output.type;
-    var arrLen;
     var parsedDataArr = [];
     switch (true) {
       case /_len$/.test(name):
@@ -453,7 +664,7 @@ var Contract = /** @class */ (function () {
         }, []);
       case /\*/.test(type):
         if (parsedResult && parsedResult[name + '_len']) {
-          arrLen = parsedResult[name + '_len'];
+          var arrLen = parsedResult[name + '_len'];
           while (parsedDataArr.length < arrLen) {
             parsedDataArr.push(
               this.parseResponseStruct(responseIterator, output.type.replace('*', ''))
@@ -480,21 +691,29 @@ var Contract = /** @class */ (function () {
       return abi.name === method;
     }).outputs;
     var responseIterator = response.flat()[Symbol.iterator]();
-    return outputs.flat().reduce(function (acc, output) {
+    var resultObject = outputs.flat().reduce(function (acc, output) {
       acc[output.name] = _this.parseResponseField(responseIterator, output, acc);
       if (acc[output.name] && acc[output.name + '_len']) {
         delete acc[output.name + '_len'];
       }
       return acc;
     }, {});
+    return Object.entries(resultObject).reduce(function (acc, _a) {
+      var _b = __read(_a, 2),
+        key = _b[0],
+        value = _b[1];
+      acc.push(value);
+      acc[key] = value;
+      return acc;
+    }, []);
   };
-  Contract.prototype.invoke = function (method, args, signature) {
+  Contract.prototype.invoke = function (method, args) {
     if (args === void 0) {
-      args = {};
+      args = [];
     }
     // ensure contract is connected
     (0, minimalistic_assert_1.default)(
-      this.connectedTo !== null,
+      this.address !== null,
       'contract isnt connected to an address'
     );
     // validate method and args
@@ -502,45 +721,72 @@ var Contract = /** @class */ (function () {
     var inputs = this.abi.find(function (abi) {
       return abi.name === method;
     }).inputs;
+    var inputsLength = inputs.reduce(function (acc, input) {
+      if (!/_len$/.test(input.name)) {
+        return acc + 1;
+      }
+      return acc;
+    }, 0);
+    var signature = [];
+    if (args.length === inputsLength + 1 && Array.isArray(args[args.length - 1])) {
+      signature.push.apply(signature, __spreadArray([], __read(args.pop()), false));
+    }
+    if (args.length !== inputsLength) {
+      throw Error(
+        'Invalid number of arguments, expected ' +
+          inputsLength +
+          ' arguments, but got ' +
+          args.length
+      );
+    }
     // compile calldata
     var calldata = this.compileCalldata(args, inputs);
-    return this.provider.invokeFunction({
-      contractAddress: this.connectedTo,
-      signature: signature,
+    var invocation = {
+      contractAddress: this.address,
       calldata: calldata,
       entrypoint: method,
-    });
+    };
+    if (this.providerOrAccount instanceof account_1.Account) {
+      return this.providerOrAccount.execute(invocation);
+    }
+    return this.providerOrAccount.invokeFunction(
+      __assign(__assign({}, invocation), { signature: signature })
+    );
   };
-  Contract.prototype.call = function (method, args, blockIdentifier) {
+  Contract.prototype.call = function (method, args) {
     if (args === void 0) {
-      args = {};
-    }
-    if (blockIdentifier === void 0) {
-      blockIdentifier = null;
+      args = [];
     }
     return __awaiter(this, void 0, void 0, function () {
-      var inputs, calldata;
+      var inputs, inputsLength, options, calldata;
       var _this = this;
       return __generator(this, function (_a) {
         // ensure contract is connected
         (0,
-        minimalistic_assert_1.default)(this.connectedTo !== null, 'contract isnt connected to an address');
+        minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
         // validate method and args
         this.validateMethodAndArgs('CALL', method, args);
         inputs = this.abi.find(function (abi) {
           return abi.name === method;
         }).inputs;
+        inputsLength = inputs.length;
+        options = {
+          blockIdentifier: null,
+        };
+        if (args.length === inputsLength + 1 && typeof args[args.length - 1] === 'object') {
+          Object.assign(options, args.pop());
+        }
         calldata = this.compileCalldata(args, inputs);
         return [
           2 /*return*/,
-          this.provider
+          this.providerOrAccount
             .callContract(
               {
-                contractAddress: this.connectedTo,
+                contractAddress: this.address,
                 calldata: calldata,
                 entrypoint: method,
               },
-              blockIdentifier
+              options
             )
             .then(function (x) {
               return _this.parseResponse(method, x.result);
@@ -549,6 +795,31 @@ var Contract = /** @class */ (function () {
       });
     });
   };
+  Contract.prototype.estimate = function (_method, _args) {
+    if (_args === void 0) {
+      _args = [];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        //  TODO; remove error as soon as estimate fees are supported
+        throw Error('Estimation of the fees are not yet supported');
+      });
+    });
+  };
+  Contract.prototype.populate = function (method, args) {
+    if (args === void 0) {
+      args = [];
+    }
+    var inputs = this.abi.find(function (abi) {
+      return abi.name === method;
+    }).inputs;
+    return {
+      contractAddress: this.address,
+      entrypoint: (0, hash_1.getSelectorFromName)(method),
+      calldata: this.compileCalldata(args, inputs),
+      signature: [],
+    };
+  };
   return Contract;
 })();
 exports.Contract = Contract;

package/contract/index.d.ts

@@ -0,0 +1,3 @@
+export * from './default';
+export * from './interface';
+export * from './contractFactory';

package/contract/index.js

@@ -0,0 +1,28 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, {
+          enumerable: true,
+          get: function () {
+            return m[k];
+          },
+        });
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p))
+        __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+__exportStar(require('./default'), exports);
+__exportStar(require('./interface'), exports);
+__exportStar(require('./contractFactory'), exports);