starknet 3.0.0 → 3.3.0

package/dist/contract.js

@@ -75,7 +75,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     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");
@@ -87,33 +88,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
@@ -135,11 +109,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 = {}; }
         // ensure provided method exists
         var invokeableFunctionNames = this.abi
@@ -157,43 +145,205 @@ var Contract = /** @class */ (function () {
             var arg = args[input.name];
             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");
+                    (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)");
                 }
-                else if (typeof arg === 'object' && 'type' in arg) {
-                    (0, minimalistic_assert_1.default)(arg.type === 'struct', "arg " + input.name + " should be a struct");
+                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.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[])");
-                    });
+                    (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;
+                                (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;
+        // 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;
+            }, []);
         }
-        else if ('outputs' in element) {
-            entries = element.outputs;
+        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 entries.reduce(function (acc, member) {
-            var _a;
-            return (__assign(__assign({}, acc), (_a = {}, _a[member.name] = _this.parseResponseField(member, responseIterator), _a)));
-        }, {});
+        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) { return abi.name === method; });
+        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) { args = {}; }
@@ -201,8 +351,9 @@ var Contract = /** @class */ (function () {
         (0, minimalistic_assert_1.default)(this.connectedTo !== 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;
         // compile calldata
-        var calldata = compileCalldata(args);
+        var calldata = this.compileCalldata(args, inputs);
         return this.provider.invokeFunction({
             contractAddress: this.connectedTo,
             signature: signature,
@@ -214,19 +365,20 @@ var Contract = /** @class */ (function () {
         if (args === void 0) { args = {}; }
         if (blockIdentifier === void 0) { 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
                 (0, 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)
                         .then(function (x) { return _this.parseResponse(method, x.result); })];
             });

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './types';
 export * from './contract';
 export * from './provider';
 export * from './account';
+export * from './signer';
 /**
  * Utils
  */

package/dist/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./contract"), exports);
 __exportStar(require("./provider"), exports);
 __exportStar(require("./account"), exports);
+__exportStar(require("./signer"), exports);
 /**
  * Utils
  */

package/dist/provider/default.d.ts

@@ -1,4 +1,4 @@
-import { Abi, AddTransactionResponse, Call, CallContractResponse, DeployContractPayload, Endpoints, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Invocation, TransactionReceipt } from '../types';
+import { Abi, AddTransactionResponse, Call, CallContractResponse, DeployContractPayload, Endpoints, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Invocation, Signature, TransactionReceipt } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier } from './utils';
@@ -109,6 +109,15 @@ export declare class Provider implements ProviderInterface {
      * @returns a confirmation of sending a transaction on the starknet contract
      */
     deployContract(payload: DeployContractPayload, _abi?: Abi): Promise<AddTransactionResponse>;
+    /**
+     * Invokes a function on starknet
+     * @deprecated This method wont be supported as soon as fees are mandatory
+     *
+     * @param invocation
+     * @param _abi - (optional) signature to send along
+     * @returns response from addTransaction
+     */
+    invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
     /**
      * Invokes a function on starknet
      * @deprecated This method wont be supported as soon as fees are mandatory
@@ -119,7 +128,11 @@ export declare class Provider implements ProviderInterface {
      * @param signature - (optional) signature to send along
      * @returns response from addTransaction
      */
-    invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
+    LEGACY_invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: Signature): Promise<AddTransactionResponse>;
+    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
     waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }
 export {};

package/dist/provider/default.js

@@ -69,6 +69,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Provider = void 0;
 var axios_1 = __importDefault(require("axios"));
 var url_join_1 = __importDefault(require("url-join"));
+var hash_1 = require("../utils/hash");
 var json_1 = require("../utils/json");
 var number_1 = require("../utils/number");
 var stark_1 = require("../utils/stark");
@@ -144,8 +145,9 @@ var Provider = /** @class */ (function () {
     };
     // typesafe fetch
     Provider.prototype.fetchEndpoint = function (endpoint) {
+        var _a;
         // typescript type magiuc to create a nice fitting function interface
-        var _a = []; // when both query and request are needed, we cant omit anything
+        var _b = []; // when both query and request are needed, we cant omit anything
         for (
         // typescript type magiuc to create a nice fitting function interface
         var _i = 1 // when both query and request are needed, we cant omit anything
@@ -157,28 +159,39 @@ var Provider = /** @class */ (function () {
         _i++ // when both query and request are needed, we cant omit anything
         ) {
             // typescript type magiuc to create a nice fitting function interface
-            _a[_i - 1] = arguments[_i]; // when both query and request are needed, we cant omit anything
+            _b[_i - 1] = arguments[_i]; // when both query and request are needed, we cant omit anything
         }
         // typescript type magiuc to create a nice fitting function interface
-        var _b = __read(_a, 2), query = _b[0], request = _b[1]; // when both query and request are needed, we cant omit anything
+        var _c = __read(_b, 2), query = _c[0], request = _c[1]; // when both query and request are needed, we cant omit anything
         return __awaiter(this, void 0, void 0, function () {
-            var baseUrl, method, queryString, headers, data;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var baseUrl, method, queryString, headers, data, error_1, data;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         baseUrl = this.getFetchUrl(endpoint);
                         method = this.getFetchMethod(endpoint);
                         queryString = this.getQueryString(query);
                         headers = this.getHeaders(method);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, axios_1.default.request({
                                 method: method,
                                 url: (0, url_join_1.default)(baseUrl, endpoint, queryString),
                                 data: (0, json_1.stringify)(request),
                                 headers: headers,
                             })];
-                    case 1:
-                        data = (_c.sent()).data;
+                    case 2:
+                        data = (_d.sent()).data;
                         return [2 /*return*/, data];
+                    case 3:
+                        error_1 = _d.sent();
+                        data = (_a = error_1 === null || error_1 === void 0 ? void 0 : error_1.response) === null || _a === void 0 ? void 0 : _a.data;
+                        if (data === null || data === void 0 ? void 0 : data.message) {
+                            throw new Error(data.code + ": " + data.message);
+                        }
+                        throw error_1;
+                    case 4: return [2 /*return*/];
                 }
             });
         });
@@ -216,7 +229,7 @@ var Provider = /** @class */ (function () {
                     }, {
                         signature: [],
                         contract_address: contractAddress,
-                        entry_point_selector: (0, stark_1.getSelectorFromName)(entrypoint),
+                        entry_point_selector: (0, hash_1.getSelectorFromName)(entrypoint),
                         calldata: calldata,
                     })];
             });
@@ -358,10 +371,8 @@ var Provider = /** @class */ (function () {
      * Invokes a function on starknet
      * @deprecated This method wont be supported as soon as fees are mandatory
      *
-     * @param contractAddress - target contract address for invoke
-     * @param entrypointSelector - target entrypoint selector for
-     * @param calldata - (optional, default []) calldata
-     * @param signature - (optional) signature to send along
+     * @param invocation
+     * @param _abi - (optional) signature to send along
      * @returns response from addTransaction
      */
     Provider.prototype.invokeFunction = function (invocation, _abi) {
@@ -369,15 +380,34 @@ var Provider = /** @class */ (function () {
         return this.fetchEndpoint('add_transaction', undefined, {
             type: 'INVOKE_FUNCTION',
             contract_address: invocation.contractAddress,
-            entry_point_selector: (0, stark_1.getSelectorFromName)(invocation.entrypoint),
+            entry_point_selector: (0, hash_1.getSelectorFromName)(invocation.entrypoint),
             calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)((_a = invocation.calldata) !== null && _a !== void 0 ? _a : []),
             signature: (0, number_1.bigNumberishArrayToDecimalStringArray)((_b = invocation.signature) !== null && _b !== void 0 ? _b : []),
         });
     };
-    Provider.prototype.waitForTx = function (txHash, retryInterval) {
+    /**
+     * Invokes a function on starknet
+     * @deprecated This method wont be supported as soon as fees are mandatory
+     *
+     * @param contractAddress - target contract address for invoke
+     * @param entrypointSelector - target entrypoint selector for
+     * @param calldata - (optional, default []) calldata
+     * @param signature - (optional) signature to send along
+     * @returns response from addTransaction
+     */
+    Provider.prototype.LEGACY_invokeFunction = function (contractAddress, entrypointSelector, calldata, signature) {
+        return this.fetchEndpoint('add_transaction', undefined, {
+            type: 'INVOKE_FUNCTION',
+            contract_address: contractAddress,
+            entry_point_selector: entrypointSelector,
+            calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata !== null && calldata !== void 0 ? calldata : []),
+            signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature !== null && signature !== void 0 ? signature : []),
+        });
+    };
+    Provider.prototype.waitForTransaction = function (txHash, retryInterval) {
         if (retryInterval === void 0) { retryInterval = 8000; }
         return __awaiter(this, void 0, void 0, function () {
-            var onchain, res, error;
+            var onchain, res, message, error;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -400,7 +430,10 @@ var Provider = /** @class */ (function () {
                             onchain = true;
                         }
                         else if (res.tx_status === 'REJECTED' || res.tx_status === 'NOT_RECEIVED') {
-                            error = Error(res.tx_status);
+                            message = res.tx_failure_reason
+                                ? res.tx_status + ": " + res.tx_failure_reason.code + "\n" + res.tx_failure_reason.error_message
+                                : res.tx_status;
+                            error = new Error(message);
                             error.response = res;
                             throw error;
                         }
@@ -410,6 +443,17 @@ var Provider = /** @class */ (function () {
             });
         });
     };
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
+    Provider.prototype.waitForTx = function (txHash, retryInterval) {
+        if (retryInterval === void 0) { retryInterval = 8000; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.waitForTransaction(txHash, retryInterval)];
+            });
+        });
+    };
     return Provider;
 }());
 exports.Provider = Provider;

package/dist/provider/interface.d.ts

@@ -97,5 +97,9 @@ export declare abstract class ProviderInterface {
      * @returns response from addTransaction
      */
     abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
-    abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
+    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/dist/signer/default.d.ts

@@ -6,5 +6,5 @@ export declare class Signer implements SignerInterface {
     constructor(keyPair: KeyPair);
     getPubKey(): Promise<string>;
     signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
-    signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
+    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
 }

package/dist/signer/default.js

@@ -38,10 +38,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Signer = void 0;
 var ellipticCurve_1 = require("../utils/ellipticCurve");
-var encode_1 = require("../utils/encode");
 var hash_1 = require("../utils/hash");
-var number_1 = require("../utils/number");
-var stark_1 = require("../utils/stark");
 var typedData_1 = require("../utils/typedData");
 var Signer = /** @class */ (function () {
     function Signer(keyPair) {
@@ -55,31 +52,22 @@ var Signer = /** @class */ (function () {
         });
     };
     Signer.prototype.signTransaction = function (transactions, transactionsDetail, abis) {
-        if (abis === void 0) { abis = []; }
         return __awaiter(this, void 0, void 0, function () {
-            var _a, contractAddress, entrypoint, _b, calldata, nonce, walletAddress, nonceBn, entrypointSelector, calldataDecimal, msgHash;
-            return __generator(this, function (_c) {
-                if (transactions.length !== 1) {
-                    throw new Error('Only one transaction at a time is currently supported by this signer');
-                }
-                if ((abis === null || abis === void 0 ? void 0 : abis.length) !== 0 && abis.length !== transactions.length) {
+            var msgHash;
+            return __generator(this, function (_a) {
+                if (abis && abis.length !== transactions.length) {
                     throw new Error('ABI must be provided for each transaction or no transaction');
                 }
-                _a = transactions[0], contractAddress = _a.contractAddress, entrypoint = _a.entrypoint, _b = _a.calldata, calldata = _b === void 0 ? [] : _b;
-                nonce = transactionsDetail.nonce, walletAddress = transactionsDetail.walletAddress;
-                nonceBn = (0, number_1.toBN)(nonce);
-                entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
-                calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
-                msgHash = (0, encode_1.addHexPrefix)((0, hash_1.hashMessage)(walletAddress, contractAddress, entrypointSelector, calldataDecimal, nonceBn.toString()));
+                msgHash = (0, hash_1.hashMulticall)(transactionsDetail.walletAddress, transactions, transactionsDetail.nonce.toString(), transactionsDetail.maxFee.toString());
                 return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });
     };
-    Signer.prototype.signMessage = function (typedData, walletAddress) {
+    Signer.prototype.signMessage = function (typedData, accountAddress) {
         return __awaiter(this, void 0, void 0, function () {
             var msgHash;
             return __generator(this, function (_a) {
-                msgHash = (0, typedData_1.getMessageHash)(typedData, walletAddress);
+                msgHash = (0, typedData_1.getMessageHash)(typedData, accountAddress);
                 return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });

package/dist/signer/interface.d.ts

@@ -11,11 +11,12 @@ export declare abstract class SignerInterface {
      * 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
      *
-     * @param json - JSON object to be signed
+     * @param typedData - JSON object to be signed
+     * @param accountAddress - account
      * @returns the signature of the JSON object
      * @throws {Error} if the JSON object is not a valid JSON
      */
-    abstract signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
+    abstract signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
     /**
      * Signs a transaction with the starknet private key and returns the signature
      *

package/dist/types/api.d.ts

@@ -115,6 +115,11 @@ export declare type GetCodeResponse = {
 export declare type GetTransactionStatusResponse = {
     tx_status: Status;
     block_hash: string;
+    tx_failure_reason?: {
+        tx_id: number;
+        code: string;
+        error_message: string;
+    };
 };
 export declare type GetTransactionResponse = {
     status: Status;
@@ -138,3 +143,10 @@ export declare type TransactionReceipt = {
     l2_to_l1_messages: string[];
     events: string[];
 };
+export declare type RawArgs = {
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
+};
+export declare type Calldata = string[];