starknet 3.0.0 → 3.3.0

package/contract.js

@@ -184,7 +184,8 @@ var __importDefault =
     return mod && mod.__esModule ? mod : { default: mod };
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.Contract = exports.compileCalldata = void 0;
+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');
@@ -195,42 +196,6 @@ function parseFelt(candidate) {
     throw Error('Couldnt parse felt');
   }
 }
-function isFelt(candidate) {
-  try {
-    parseFelt(candidate);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-function compileCalldata(args) {
-  return Object.values(args).flatMap(function (value) {
-    if (Array.isArray(value))
-      return __spreadArray(
-        [(0, number_1.toBN)(value.length).toString()],
-        __read(
-          value.map(function (x) {
-            return (0, number_1.toBN)(x).toString();
-          })
-        ),
-        false
-      );
-    if (typeof value === 'object' && 'type' in value)
-      return Object.entries(value)
-        .filter(function (_a) {
-          var _b = __read(_a, 1),
-            k = _b[0];
-          return k !== 'type';
-        })
-        .map(function (_a) {
-          var _b = __read(_a, 2),
-            v = _b[1];
-          return (0, number_1.toBN)(v).toString();
-        });
-    return (0, number_1.toBN)(value).toString();
-  });
-}
-exports.compileCalldata = compileCalldata;
 var Contract = /** @class */ (function () {
   /**
    * Contract class to handle contract methods
@@ -258,11 +223,25 @@ var Contract = /** @class */ (function () {
         return __assign(__assign({}, acc), ((_a = {}), (_a[abiEntry.name] = abiEntry), _a));
       }, {});
   }
+  /**
+   * 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;
   };
+  /**
+   * 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
+   */
   Contract.prototype.validateMethodAndArgs = function (type, method, args) {
+    var _this = this;
     if (args === void 0) {
       args = {};
     }
@@ -289,58 +268,225 @@ var Contract = /** @class */ (function () {
       if (arg !== undefined) {
         if (input.type === 'felt') {
           (0, minimalistic_assert_1.default)(
-            typeof arg === 'string',
-            'arg ' + input.name + ' should be a felt (string)'
-          );
-          (0, minimalistic_assert_1.default)(
-            isFelt(arg),
-            'arg ' + input.name + ' should be decimal or hexadecimal'
-          );
-        } else if (typeof arg === 'object' && 'type' in arg) {
-          (0, minimalistic_assert_1.default)(
-            arg.type === 'struct',
-            'arg ' + input.name + ' should be a struct'
+            typeof arg === 'string' || typeof arg === 'number' || arg instanceof bn_js_1.default,
+            'arg ' + input.name + ' should be a felt (string, number, BigNumber)'
           );
+        } else if (typeof arg === 'object' && input.type in _this.structs) {
+          _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);
+          });
         } else {
           (0, minimalistic_assert_1.default)(
             Array.isArray(arg),
-            'arg ' + input.name + ' should be a felt* (string[])'
+            'arg ' + input.name + ' should be an Array'
           );
-          arg.forEach(function (felt, i) {
-            (0,
-            minimalistic_assert_1.default)(typeof felt === 'string', 'arg ' + input.name + '[' + i + '] should be a felt (string) as part of a felt* (string[])');
-            (0,
-            minimalistic_assert_1.default)(isFelt(felt), 'arg ' + input.name + '[' + i + '] should be decimal or hexadecimal as part of a felt* (string[])');
-          });
+          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);
+              });
+            });
+          }
         }
       }
     });
   };
-  Contract.prototype.parseResponseField = function (element, responseIterator) {
+  /**
+   * 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
+   */
+  Contract.prototype.parseCalldataObject = function (element, type) {
     var _this = this;
-    var entries = [];
-    if (['felt', 'felt*'].includes(element.type)) {
-      return responseIterator.next().value;
+    if (element === undefined) {
+      throw Error('Missing element in calldata object');
     }
-    if (element.type in this.structs) {
-      entries = this.structs[element.type].members;
-    } else if ('outputs' in element) {
-      entries = element.outputs;
+    // 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(function (acc, member) {
+        // 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);
+        if (typeof parsedData === 'string') {
+          acc.push(parsedData);
+        } else {
+          acc.push.apply(acc, __spreadArray([], __read(parsedData), false));
+        }
+        return acc;
+      }, []);
     }
-    return entries.reduce(function (acc, member) {
-      var _a;
-      return __assign(
-        __assign({}, acc),
-        ((_a = {}), (_a[member.name] = _this.parseResponseField(member, responseIterator)), _a)
-      );
-    }, {});
+    return (0, number_1.toFelt)(element);
+  };
+  /**
+   * Parse of the response elements that are converted to Object (Struct) by using the abi
+   *
+   * @param responseIterator - iterator of the response
+   * @param type - type of the struct
+   * @return {BigNumberish | ParsedStruct} - parsed arguments in format that contract is expecting
+   */
+  Contract.prototype.parseResponseStruct = function (responseIterator, type) {
+    var _this = this;
+    // check the type of current element
+    if (type in this.structs && this.structs[type]) {
+      return this.structs[type].members.reduce(function (acc, el) {
+        // parse each member of the struct (member can felt or nested struct)
+        acc[el.name] = _this.parseResponseStruct(responseIterator, el.type);
+        return acc;
+      }, {});
+    }
+    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
+   */
+  Contract.prototype.parsCalldataField = function (args, input) {
+    var _this = this;
+    var name = input.name,
+      type = input.type;
+    var value = args[name];
+    var propName = name.replace(/_len$/, '');
+    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)) {
+          return value.reduce(function (acc, el) {
+            if (/felt/.test(type)) {
+              acc.push((0, number_1.toFelt)(el));
+            } else {
+              acc.push.apply(
+                acc,
+                __spreadArray(
+                  [],
+                  __read(_this.parseCalldataObject(el, type.replace('*', ''))),
+                  false
+                )
+              );
+            }
+            return acc;
+          }, []);
+        }
+        throw Error('Expected ' + name + ' to be array');
+      case type in this.structs:
+        return this.parseCalldataObject(value, type);
+      case /\(felt/.test(type):
+        if (Array.isArray(value)) {
+          return value.map(function (el) {
+            return (0, number_1.toFelt)(el);
+          });
+        }
+        throw Error('Expected ' + name + ' to be array');
+      default:
+        return (0, number_1.toFelt)(value);
+    }
+  };
+  /**
+   * 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
+   */
+  Contract.prototype.compileCalldata = function (args, inputs) {
+    var _this = this;
+    return inputs.reduce(function (acc, input) {
+      var parsedData = _this.parsCalldataField(args, input);
+      if (Array.isArray(parsedData)) {
+        acc.push.apply(acc, __spreadArray([], __read(parsedData), false));
+      } else {
+        acc.push(parsedData);
+      }
+      return acc;
+    }, []);
+  };
+  /**
+   * Parse elements of the response and structuring them into one field by using output property from the abi for that method
+   *
+   * @param responseIterator - iterator of the response
+   * @param output  - output(field) information from the abi that will be used to parse the data
+   * @return - parsed response corresponding to the abi structure of the field
+   */
+  Contract.prototype.parseResponseField = function (responseIterator, output, parsedResult) {
+    var name = output.name,
+      type = output.type;
+    var arrLen;
+    var parsedDataArr = [];
+    switch (true) {
+      case /_len$/.test(name):
+        return parseFelt(responseIterator.next().value).toNumber();
+      case /\(felt/.test(type):
+        return type.split(',').reduce(function (acc) {
+          acc.push(parseFelt(responseIterator.next().value));
+          return acc;
+        }, []);
+      case /\*/.test(type):
+        if (parsedResult && parsedResult[name + '_len']) {
+          arrLen = parsedResult[name + '_len'];
+          while (parsedDataArr.length < arrLen) {
+            parsedDataArr.push(
+              this.parseResponseStruct(responseIterator, output.type.replace('*', ''))
+            );
+          }
+        }
+        return parsedDataArr;
+      case type in this.structs:
+        return this.parseResponseStruct(responseIterator, type);
+      default:
+        return parseFelt(responseIterator.next().value);
+    }
+  };
+  /**
+   * Parse elements of the response array and structuring them into response object
+   *
+   * @param method - method name
+   * @param response  - response from the method
+   * @return - parsed response corresponding to the abi
+   */
   Contract.prototype.parseResponse = function (method, response) {
-    var methodAbi = this.abi.find(function (abi) {
+    var _this = this;
+    var outputs = this.abi.find(function (abi) {
       return abi.name === method;
-    });
+    }).outputs;
     var responseIterator = response.flat()[Symbol.iterator]();
-    return this.parseResponseField(methodAbi, responseIterator);
+    return 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;
+    }, {});
   };
   Contract.prototype.invoke = function (method, args, signature) {
     if (args === void 0) {
@@ -353,8 +499,11 @@ var Contract = /** @class */ (function () {
     );
     // validate method and args
     this.validateMethodAndArgs('INVOKE', method, args);
+    var inputs = this.abi.find(function (abi) {
+      return abi.name === method;
+    }).inputs;
     // compile calldata
-    var calldata = compileCalldata(args);
+    var calldata = this.compileCalldata(args, inputs);
     return this.provider.invokeFunction({
       contractAddress: this.connectedTo,
       signature: signature,
@@ -370,7 +519,7 @@ var Contract = /** @class */ (function () {
       blockIdentifier = null;
     }
     return __awaiter(this, void 0, void 0, function () {
-      var calldata;
+      var inputs, calldata;
       var _this = this;
       return __generator(this, function (_a) {
         // ensure contract is connected
@@ -378,15 +527,18 @@ var Contract = /** @class */ (function () {
         minimalistic_assert_1.default)(this.connectedTo !== null, 'contract isnt connected to an address');
         // validate method and args
         this.validateMethodAndArgs('CALL', method, args);
-        calldata = compileCalldata(args);
+        inputs = this.abi.find(function (abi) {
+          return abi.name === method;
+        }).inputs;
+        calldata = this.compileCalldata(args, inputs);
         return [
           2 /*return*/,
           this.provider
             .callContract(
               {
                 contractAddress: this.connectedTo,
-                entrypoint: method,
                 calldata: calldata,
+                entrypoint: method,
               },
               blockIdentifier
             )

package/dist/account/default.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from '../provider';
-import { Abi, AddTransactionResponse, ExecuteInvocation, InvocationsDetails, KeyPair, Signature } from '../types';
+import { Abi, AddTransactionResponse, Call, InvocationsDetails, KeyPair, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -16,7 +16,7 @@ export declare class Account extends Provider implements AccountInterface {
      * @param transaction - transaction to be invoked
      * @returns a confirmation of invoking a function on the starknet contract
      */
-    execute(transactions: ExecuteInvocation | ExecuteInvocation[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
+    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
     /**
      * Sign an JSON object with the starknet private key and return the signature
      *
@@ -36,7 +36,7 @@ export declare class Account extends Provider implements AccountInterface {
     /**
      * Verify a signature of a JSON object
      *
-     * @param json - JSON object to be verified
+     * @param hash - JSON object to be verified
      * @param signature - signature of the JSON object
      * @returns true if the signature is valid, false otherwise
      * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature

package/dist/account/default.js

@@ -14,17 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -61,17 +50,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -99,11 +77,12 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Account = void 0;
-var contract_1 = require("../contract");
 var provider_1 = require("../provider");
 var signer_1 = require("../signer");
+var hash_1 = require("../utils/hash");
 var number_1 = require("../utils/number");
 var stark_1 = require("../utils/stark");
+var transaction_1 = require("../utils/transaction");
 var typedData_1 = require("../utils/typedData");
 var Account = /** @class */ (function (_super) {
     __extends(Account, _super);
@@ -137,47 +116,42 @@ var Account = /** @class */ (function (_super) {
      * @param transaction - transaction to be invoked
      * @returns a confirmation of invoking a function on the starknet contract
      */
-    Account.prototype.execute = function (transactions, abis, transactionsDetail) {
-        if (abis === void 0) { abis = []; }
+    Account.prototype.execute = function (calls, abis, transactionsDetail) {
+        var _a, _b;
+        if (abis === void 0) { abis = undefined; }
         if (transactionsDetail === void 0) { transactionsDetail = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var _a, contractAddress, _b, calldata, entrypoint, invocation, nonce, nonceBn, _c, _d, calldataDecimal, signature, entrypointSelector;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+            var transactions, signerDetails, _c, _d, signature, calldata;
+            var _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
                     case 0:
-                        if (Array.isArray(transactions) && transactions.length !== 1) {
-                            throw new Error('Only one transaction at a time is currently supported');
-                        }
-                        _a = Array.isArray(transactions) ? transactions[0] : transactions, contractAddress = _a.contractAddress, _b = _a.calldata, calldata = _b === void 0 ? [] : _b, entrypoint = _a.entrypoint, invocation = __rest(_a, ["contractAddress", "calldata", "entrypoint"]);
-                        nonce = transactionsDetail.nonce;
+                        transactions = Array.isArray(calls) ? calls : [calls];
+                        _e = {
+                            walletAddress: this.address
+                        };
                         _c = number_1.toBN;
-                        if (!(nonce !== null && nonce !== void 0)) return [3 /*break*/, 1];
-                        _d = nonce;
+                        if (!((_a = transactionsDetail.nonce) !== null && _a !== void 0)) return [3 /*break*/, 1];
+                        _d = _a;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, this.getNonce()];
                     case 2:
-                        _d = (_e.sent());
-                        _e.label = 3;
+                        _d = (_f.sent());
+                        _f.label = 3;
                     case 3:
-                        nonceBn = _c.apply(void 0, [_d]);
-                        calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
-                        return [4 /*yield*/, this.signer.signTransaction([
-                                __assign(__assign({}, invocation), { contractAddress: contractAddress, calldata: calldataDecimal, entrypoint: entrypoint }),
-                            ], { walletAddress: this.address, nonce: nonceBn }, abis)];
+                        signerDetails = (_e.nonce = _c.apply(void 0, [_d]),
+                            _e.maxFee = (0, number_1.toBN)((_b = transactionsDetail.maxFee) !== null && _b !== void 0 ? _b : '0'),
+                            _e);
+                        return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
                     case 4:
-                        signature = _e.sent();
-                        entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
-                        return [2 /*return*/, _super.prototype.invokeFunction.call(this, {
-                                contractAddress: this.address,
-                                entrypoint: 'execute',
-                                calldata: __spreadArray(__spreadArray([
-                                    contractAddress,
-                                    entrypointSelector,
-                                    calldataDecimal.length.toString()
-                                ], __read(calldataDecimal), false), [
-                                    nonceBn.toString(),
-                                ], false),
-                                signature: signature,
+                        signature = _f.sent();
+                        calldata = __spreadArray(__spreadArray([], __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)), false), [signerDetails.nonce.toString()], false);
+                        return [2 /*return*/, this.fetchEndpoint('add_transaction', undefined, {
+                                type: 'INVOKE_FUNCTION',
+                                contract_address: this.address,
+                                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
+                                calldata: calldata,
+                                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
                             })];
                 }
             });
@@ -214,7 +188,7 @@ var Account = /** @class */ (function (_super) {
     /**
      * Verify a signature of a JSON object
      *
-     * @param json - JSON object to be verified
+     * @param hash - JSON object to be verified
      * @param signature - signature of the JSON object
      * @returns true if the signature is valid, false otherwise
      * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
@@ -229,7 +203,7 @@ var Account = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.callContract({
                                 contractAddress: this.address,
                                 entrypoint: 'is_valid_signature',
-                                calldata: (0, contract_1.compileCalldata)({
+                                calldata: (0, stark_1.compileCalldata)({
                                     hash: (0, number_1.toBN)(hash).toString(),
                                     signature: signature.map(function (x) { return (0, number_1.toBN)(x).toString(); }),
                                 }),

package/dist/account/interface.d.ts

@@ -1,5 +1,5 @@
 import { ProviderInterface } from '../provider';
-import { Abi, AddTransactionResponse, DeployContractPayload, ExecuteInvocation, InvocationsDetails, Signature } from '../types';
+import { Abi, AddTransactionResponse, Call, DeployContractPayload, InvocationsDetails, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 export declare abstract class AccountInterface extends ProviderInterface {
@@ -27,7 +27,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
      *
      * @returns response from addTransaction
      */
-    abstract execute(transactions: ExecuteInvocation | ExecuteInvocation[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
+    abstract execute(transactions: Call | Call[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
     /**
      * Sign an JSON object for off-chain usage with the starknet private key and return the signature
      * This adds a message prefix so it cant be interchanged with transactions

package/dist/contract.d.ts

@@ -1,14 +1,17 @@
 import { Provider } from './provider';
 import { BlockIdentifier } from './provider/utils';
-import { Abi, RawCalldata, Signature, StructAbi } from './types';
+import { Abi, Signature, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
+export declare type Struct = {
+    type: 'struct';
+    [k: string]: BigNumberish;
+};
+export declare type ParsedStruct = {
+    [key: string]: BigNumberish | ParsedStruct;
+};
 export declare type Args = {
-    [inputName: string]: string | string[] | {
-        type: 'struct';
-        [k: string]: BigNumberish;
-    };
+    [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
 };
-export declare function compileCalldata(args: Args): RawCalldata;
 export declare class Contract {
     connectedTo: string | null;
     abi: Abi;
@@ -23,9 +26,68 @@ export declare class Contract {
      * @param address (optional) - address to connect to
      */
     constructor(abi: Abi, address?: string | null, provider?: Provider);
+    /**
+     * Saves the address of the contract deployed on network that will be used for interaction
+     *
+     * @param address - address of the contract
+     * @returns Contract
+     */
     connect(address: string): Contract;
+    /**
+     * 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
+     */
     private validateMethodAndArgs;
+    /**
+     * 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
+     */
+    private parseCalldataObject;
+    /**
+     * Parse of the response elements that are converted to Object (Struct) by using the abi
+     *
+     * @param responseIterator - iterator of the response
+     * @param type - type of the struct
+     * @return {BigNumberish | ParsedStruct} - parsed arguments in format that contract is expecting
+     */
+    private parseResponseStruct;
+    /**
+     * 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
+     */
+    private parsCalldataField;
+    /**
+     * 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
+     */
+    private compileCalldata;
+    /**
+     * Parse elements of the response and structuring them into one field by using output property from the abi for that method
+     *
+     * @param responseIterator - iterator of the response
+     * @param output  - output(field) information from the abi that will be used to parse the data
+     * @return - parsed response corresponding to the abi structure of the field
+     */
     private parseResponseField;
+    /**
+     * Parse elements of the response array and structuring them into response object
+     *
+     * @param method - method name
+     * @param response  - response from the method
+     * @return - parsed response corresponding to the abi
+     */
     private parseResponse;
     invoke(method: string, args?: Args, signature?: Signature): Promise<import("./types").AddTransactionResponse>;
     call(method: string, args?: Args, blockIdentifier?: BlockIdentifier): Promise<Args>;