starknet 3.4.0 → 3.5.0

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

@@ -78,8 +78,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);
@@ -88,19 +90,89 @@ 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; }
-        this.connectedTo = null;
-        this.connectedTo = address;
-        this.provider = provider;
+    function Contract(abi, address, providerOrAccount) {
+        var _this = this;
+        if (providerOrAccount === void 0) { providerOrAccount = provider_1.defaultProvider; }
+        this.address = address;
+        this.providerOrAccount = providerOrAccount;
         this.abi = abi;
         this.structs = abi
             .filter(function (abiEntry) { return abiEntry.type === 'struct'; })
@@ -108,16 +180,105 @@ 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
@@ -128,7 +289,7 @@ var Contract = /** @class */ (function () {
      */
     Contract.prototype.validateMethodAndArgs = function (type, method, args) {
         var _this = this;
-        if (args === void 0) { args = {}; }
+        if (args === void 0) { args = []; }
         // ensure provided method exists
         var invokeableFunctionNames = this.abi
             .filter(function (abi) {
@@ -141,45 +302,80 @@ var Contract = /** @class */ (function () {
         (0, minimalistic_assert_1.default)(invokeableFunctionNames.includes(method), (type === 'INVOKE' ? 'invokeable' : 'viewable') + " method not found in abi");
         // ensure args match abi type
         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') {
-                    (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)");
+            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)(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);
+                        (0, minimalistic_assert_1.default)(Object.keys(args[argPosition]).includes(name), "arg should have a property " + name);
+                    });
+                }
+                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)(args[argPosition].length === tupleLength, "arg " + input.name + " should have " + tupleLength + " elements in tuple");
+                    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 {
-                    (0, minimalistic_assert_1.default)(Array.isArray(arg), "arg " + input.name + " should be an Array");
-                    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;
+                    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
      *
@@ -187,10 +383,17 @@ 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) {
@@ -199,7 +402,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);
                 }
@@ -237,33 +440,28 @@ 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));
                         }
                         else {
-                            acc.push.apply(acc, __spreadArray([], __read(_this.parseCalldataObject(el, type.replace('*', ''))), false));
+                            acc.push.apply(acc, __spreadArray([], __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) { return (0, number_1.toFelt)(el); });
@@ -282,8 +480,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));
             }
@@ -302,7 +504,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):
@@ -314,7 +515,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('*', '')));
                     }
@@ -337,53 +538,100 @@ var Contract = /** @class */ (function () {
         var _this = this;
         var outputs = this.abi.find(function (abi) { 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) {
-        if (args === void 0) { args = {}; }
+    Contract.prototype.invoke = function (method, args) {
+        if (args === void 0) { args = []; }
         // ensure contract is connected
-        (0, minimalistic_assert_1.default)(this.connectedTo !== null, 'contract isnt connected to an address');
+        (0, minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
         // validate method and args
         this.validateMethodAndArgs('INVOKE', method, args);
         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) {
-        if (args === void 0) { args = {}; }
-        if (blockIdentifier === void 0) { blockIdentifier = null; }
+    Contract.prototype.call = function (method, args) {
+        if (args === void 0) { 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');
+                (0, 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
+                return [2 /*return*/, this.providerOrAccount
                         .callContract({
-                        contractAddress: this.connectedTo,
+                        contractAddress: this.address,
                         calldata: calldata,
                         entrypoint: method,
-                    }, blockIdentifier)
+                    }, options)
                         .then(function (x) { return _this.parseResponse(method, x.result); })];
             });
         });
     };
+    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/dist/contract/index.d.ts

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

package/dist/contract/index.js

@@ -0,0 +1,15 @@
+"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);

package/dist/contract/interface.d.ts

@@ -0,0 +1,72 @@
+import { Account } from '../account';
+import { Provider } from '../provider';
+import { Abi, AddTransactionResponse, AsyncContractFunction, ContractFunction, Invocation, Result } from '../types';
+export declare abstract class ContractInterface {
+    abstract abi: Abi;
+    abstract address: string;
+    abstract providerOrAccount: Provider | Account;
+    abstract deployTransactionHash?: string;
+    readonly functions: {
+        [name: string]: AsyncContractFunction;
+    };
+    readonly callStatic: {
+        [name: string]: AsyncContractFunction;
+    };
+    readonly populateTransaction: {
+        [name: string]: ContractFunction;
+    };
+    readonly estimateFee: {
+        [name: string]: ContractFunction;
+    };
+    readonly [key: string]: AsyncContractFunction | any;
+    /**
+     * Saves the address of the contract deployed on network that will be used for interaction
+     *
+     * @param address - address of the contract
+     */
+    abstract attach(address: string): void;
+    /**
+     * Attaches to new Provider or Account
+     *
+     * @param providerOrAccount - new Provider or Account to attach to
+     */
+    abstract connect(providerOrAccount: Provider | Account): void;
+    /**
+     * 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
+     */
+    abstract deployed(): Promise<ContractInterface>;
+    /**
+     * Calls a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call
+     * @returns Result of the call as an array with key value pars
+     */
+    abstract call(method: string, args?: Array<any>): Promise<Result>;
+    /**
+     * Invokes a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the invoke
+     * @returns Add Transaction Response
+     */
+    abstract invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
+    /**
+     * Calls a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call
+     */
+    abstract estimate(method: string, args?: Array<any>): Promise<any>;
+    /**
+     * Calls a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call
+     * @returns Invocation objet
+     */
+    abstract populate(method: string, args?: Array<any>): Invocation;
+}

package/dist/contract/interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractInterface = void 0;
+var ContractInterface = /** @class */ (function () {
+    function ContractInterface() {
+    }
+    return ContractInterface;
+}());
+exports.ContractInterface = ContractInterface;

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Main
  */
-export * from './types';
 export * from './contract';
+export * from './types';
 export * from './provider';
 export * from './account';
 export * from './signer';