starknet 3.18.2 → 3.19.0

package/contract/index.js

@@ -1,32 +1,19 @@
-'use strict';
-var __createBinding =
-  (this && this.__createBinding) ||
-  (Object.create
-    ? function (o, m, k, k2) {
-        if (k2 === undefined) k2 = k;
-        var desc = Object.getOwnPropertyDescriptor(m, k);
-        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-          desc = {
-            enumerable: true,
-            get: function () {
-              return m[k];
-            },
-          };
-        }
-        Object.defineProperty(o, k2, desc);
-      }
-    : 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);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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/contract/interface.d.ts

@@ -1,97 +1,77 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
-import {
-  Abi,
-  AddTransactionResponse,
-  AsyncContractFunction,
-  ContractFunction,
-  Invocation,
-  Overrides,
-  Result,
-} from '../types';
+import { Abi, AsyncContractFunction, ContractFunction, Invocation, InvokeFunctionResponse, Overrides, Result } from '../types';
 export declare abstract class ContractInterface {
-  abstract abi: Abi;
-  abstract address: string;
-  abstract providerOrAccount: ProviderInterface | AccountInterface;
-  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: ProviderInterface | AccountInterface): 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>,
-    options?: {
-      blockIdentifier?: BlockIdentifier;
-    }
-  ): 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>,
-    options?: Overrides
-  ): 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>,
-    options?: {
-      blockIdentifier?: BlockIdentifier;
-    }
-  ): 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;
+    abstract abi: Abi;
+    abstract address: string;
+    abstract providerOrAccount: ProviderInterface | AccountInterface;
+    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: ProviderInterface | AccountInterface): 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>, options?: {
+        blockIdentifier?: BlockIdentifier;
+    }): 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>, options?: Overrides): Promise<InvokeFunctionResponse>;
+    /**
+     * 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>, options?: {
+        blockIdentifier?: BlockIdentifier;
+    }): 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/contract/interface.js

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

package/dist/account/default.d.ts

@@ -1,6 +1,7 @@
-import { Provider, ProviderInterface } from '../provider';
+import { ProviderInterface, ProviderOptions } from '../provider';
+import { Provider } from '../provider/default';
 import { SignerInterface } from '../signer';
-import { Abi, AddTransactionResponse, Call, InvocationsDetails, KeyPair, Signature, Transaction } from '../types';
+import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
@@ -8,7 +9,7 @@ import { AccountInterface } from './interface';
 export declare class Account extends Provider implements AccountInterface {
     address: string;
     signer: SignerInterface;
-    constructor(provider: ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
+    constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
     getNonce(): Promise<string>;
     estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
     /**
@@ -21,12 +22,7 @@ export declare class Account extends Provider implements AccountInterface {
      * @param transactionsDetail - optional transaction details
      * @returns a confirmation of invoking a function on the starknet contract
      */
-    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
-    /**
-     * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
-     * @deprecated to remove ASAP
-     */
-    LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     /**
      * Sign an JSON object with the starknet private key and return the signature
      *

package/dist/account/default.js

@@ -14,6 +14,17 @@ 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) {
@@ -50,54 +61,23 @@ 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 __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Account = void 0;
-var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
 var constants_1 = require("../constants");
-var provider_1 = require("../provider");
+var default_1 = require("../provider/default");
 var signer_1 = require("../signer");
-var ellipticCurve_1 = require("../utils/ellipticCurve");
 var hash_1 = require("../utils/hash");
 var number_1 = require("../utils/number");
-var shortString_1 = require("../utils/shortString");
 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);
-    function Account(provider, address, keyPairOrSigner) {
-        var _this = _super.call(this, provider) || this;
+    function Account(providerOrOptions, address, keyPairOrSigner) {
+        var _this = _super.call(this, providerOrOptions) || this;
+        _this.address = address;
         _this.signer =
             'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new signer_1.Signer(keyPairOrSigner);
-        _this.address = address;
         return _this;
     }
     Account.prototype.getNonce = function () {
@@ -117,23 +97,22 @@ var Account = /** @class */ (function (_super) {
         });
     };
     Account.prototype.estimateFee = function (calls, _a) {
-        var _b;
-        var _c = _a === void 0 ? {} : _a, providedNonce = _c.nonce, _d = _c.blockIdentifier, blockIdentifier = _d === void 0 ? 'pending' : _d;
+        var _b = _a === void 0 ? {} : _a, providedNonce = _b.nonce, blockIdentifier = _b.blockIdentifier;
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _e, version, signerDetails, signature, calldata, fetchedEstimate, fee, suggestedMaxFee;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
+            var transactions, nonce, _c, version, signerDetails, signature, calldata, response, suggestedMaxFee;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         transactions = Array.isArray(calls) ? calls : [calls];
                         if (!(providedNonce !== null && providedNonce !== void 0)) return [3 /*break*/, 1];
-                        _e = providedNonce;
+                        _c = providedNonce;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, this.getNonce()];
                     case 2:
-                        _e = (_f.sent());
-                        _f.label = 3;
+                        _c = (_d.sent());
+                        _d.label = 3;
                     case 3:
-                        nonce = _e;
+                        nonce = _c;
                         version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
                         signerDetails = {
                             walletAddress: this.address,
@@ -144,27 +123,13 @@ var Account = /** @class */ (function (_super) {
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
                     case 4:
-                        signature = _f.sent();
+                        signature = _d.sent();
                         calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [4 /*yield*/, this.fetchEndpoint('estimate_fee', { blockIdentifier: blockIdentifier }, {
-                                contract_address: this.address,
-                                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
-                                calldata: calldata,
-                                version: (0, number_1.toHex)(version),
-                                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
-                            })];
+                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, blockIdentifier, { version: version })];
                     case 5:
-                        fetchedEstimate = _f.sent();
-                        fee = (_b = fetchedEstimate.overall_fee) !== null && _b !== void 0 ? _b : fetchedEstimate.amount;
-                        if (fee === undefined) {
-                            throw new Error('Expected either amount or overall_fee in estimate_fee response');
-                        }
-                        suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(fee);
-                        return [2 /*return*/, {
-                                amount: fee,
-                                unit: fetchedEstimate.unit,
-                                suggestedMaxFee: suggestedMaxFee,
-                            }];
+                        response = _d.sent();
+                        suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
+                        return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
                 }
             });
         });
@@ -184,7 +149,7 @@ var Account = /** @class */ (function (_super) {
         if (abis === void 0) { abis = undefined; }
         if (transactionsDetail === void 0) { transactionsDetail = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, signerDetails, signature, calldata;
+            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, version, signerDetails, signature, calldata;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -209,120 +174,21 @@ var Account = /** @class */ (function (_super) {
                         maxFee = suggestedMaxFee.toString();
                         _d.label = 6;
                     case 6:
+                        version = (0, number_1.toBN)(hash_1.transactionVersion);
                         signerDetails = {
                             walletAddress: this.address,
                             nonce: nonce,
                             maxFee: maxFee,
-                            version: (0, number_1.toBN)(hash_1.transactionVersion),
+                            version: version,
                             chainId: this.chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
                     case 7:
                         signature = _d.sent();
                         calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        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),
-                                max_fee: (0, number_1.toHex)((0, number_1.toBN)(maxFee)),
-                            })];
-                }
-            });
-        });
-    };
-    /**
-     * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
-     * @deprecated to remove ASAP
-     */
-    Account.prototype.LEGACY_addTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            function hashMulticall(account, transactions, nonce, maxFee) {
-                var hashArray = transactions
-                    .map(function (_a) {
-                    var contract_address = _a.contract_address, entry_point_selector = _a.entry_point_selector, calldata = _a.calldata;
-                    return [
-                        contract_address,
-                        entry_point_selector,
-                        (0, hash_1.computeHashOnElements)(calldata || []),
-                    ];
-                })
-                    .map(number_1.bigNumberishArrayToDecimalStringArray)
-                    .map(hash_1.computeHashOnElements);
-                return (0, hash_1.computeHashOnElements)([
-                    (0, shortString_1.encodeShortString)('StarkNet Transaction'),
-                    account,
-                    (0, hash_1.computeHashOnElements)(hashArray),
-                    nonce,
-                    maxFee,
-                    hash_1.transactionVersion,
-                ]);
-            }
-            var nonceBn, result, msgHash, signature, transformCallsToMulticallArrays, fromCallsToExecuteCalldata2, calldata;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (transaction.type === 'DEPLOY')
-                            throw new Error('No DEPLOYS');
-                        if (transaction.type === 'DECLARE')
-                            throw new Error('No DECLARES');
-                        (0, minimalistic_assert_1.default)(!transaction.signature, "Adding signatures to a signer transaction currently isn't supported");
-                        if (!transaction.nonce) return [3 /*break*/, 1];
-                        nonceBn = (0, number_1.toBN)(transaction.nonce);
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.callContract({
-                            contractAddress: this.address,
-                            entrypoint: 'get_nonce',
-                        })];
-                    case 2:
-                        result = (_a.sent()).result;
-                        nonceBn = (0, number_1.toBN)(result[0]);
-                        _a.label = 3;
-                    case 3:
-                        msgHash = hashMulticall(this.address, [transaction], nonceBn.toString(), '0');
-                        if (!('keyPair' in this.signer)) {
-                            throw new Error('No keyPair');
-                        }
-                        signature = (0, ellipticCurve_1.sign)(this.signer.keyPair, msgHash);
-                        transformCallsToMulticallArrays = function (calls) {
-                            var callArray = [];
-                            var calldata = [];
-                            calls.forEach(function (call) {
-                                var data = call.calldata || [];
-                                callArray.push({
-                                    to: (0, number_1.toBN)(call.contract_address).toString(10),
-                                    selector: (0, number_1.toBN)(call.entry_point_selector).toString(10),
-                                    data_offset: calldata.length.toString(),
-                                    data_len: data.length.toString(),
-                                });
-                                calldata.push.apply(calldata, __spreadArray([], __read(data), false));
-                            });
-                            return {
-                                callArray: callArray,
-                                calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata),
-                            };
-                        };
-                        fromCallsToExecuteCalldata2 = function (calls) {
-                            var _a = transformCallsToMulticallArrays(calls), callArray = _a.callArray, calldata = _a.calldata;
-                            return __spreadArray(__spreadArray(__spreadArray([
-                                callArray.length.toString()
-                            ], __read(callArray
-                                .map(function (_a) {
-                                var to = _a.to, selector = _a.selector, data_offset = _a.data_offset, data_len = _a.data_len;
-                                return [to, selector, data_offset, data_len];
-                            })
-                                .flat()), false), [
-                                calldata.length.toString()
-                            ], false), __read(calldata), false);
-                        };
-                        calldata = __spreadArray(__spreadArray([], __read(fromCallsToExecuteCalldata2([transaction])), false), [nonceBn.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),
+                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, {
+                                maxFee: maxFee,
+                                version: version,
                             })];
                 }
             });
@@ -413,5 +279,5 @@ var Account = /** @class */ (function (_super) {
         });
     };
     return Account;
-}(provider_1.Provider));
+}(default_1.Provider));
 exports.Account = Account;

package/dist/account/interface.d.ts

@@ -1,23 +1,11 @@
 import { ProviderInterface } from '../provider';
 import { SignerInterface } from '../signer';
-import { Abi, AddTransactionResponse, Call, DeployContractPayload, InvocationsDetails, Signature } from '../types';
-import { EstimateFee, EstimateFeeDetails } from '../types/account';
+import { Abi, Call, EstimateFeeDetails, EstimateFeeResponse, InvocationsDetails, InvokeFunctionResponse, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 export declare abstract class AccountInterface extends ProviderInterface {
     abstract address: string;
     abstract signer: SignerInterface;
-    /**
-     * Deploys a given compiled contract (json) to starknet
-     *
-     * @param payload payload to be deployed containing:
-     * - compiled contract code
-     * - constructor calldata
-     * - address salt
-     * @param abi the abi of the contract
-     * @returns a confirmation of sending a transaction on the starknet contract
-     */
-    abstract deployContract(payload: DeployContractPayload, abi?: Abi): Promise<AddTransactionResponse>;
     /**
      * Estimate Fee for a method on starknet
      *
@@ -29,7 +17,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
      *
      * @returns response from addTransaction
      */
-    abstract estimateFee(calls: Call | Call[], estimateFeeDetails?: EstimateFeeDetails): Promise<EstimateFee>;
+    abstract estimateFee(calls: Call | Call[], estimateFeeDetails?: EstimateFeeDetails): Promise<EstimateFeeResponse>;
     /**
      * Invoke execute function in account contract
      *
@@ -42,7 +30,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
      *
      * @returns response from addTransaction
      */
-    abstract execute(transactions: Call | Call[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
+    abstract execute(transactions: Call | Call[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     /**
      * 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/contractFactory.js

@@ -61,7 +61,7 @@ var ContractFactory = /** @class */ (function () {
      */
     ContractFactory.prototype.deploy = function (constructorCalldata, addressSalt) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, address, code, transaction_hash, contractInstance;
+            var _a, contract_address, transaction_hash, contractInstance;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.providerOrAccount.deployContract({
@@ -70,9 +70,9 @@ var ContractFactory = /** @class */ (function () {
                             addressSalt: addressSalt,
                         })];
                     case 1:
-                        _a = _b.sent(), address = _a.address, code = _a.code, transaction_hash = _a.transaction_hash;
-                        (0, minimalistic_assert_1.default)(code === 'TRANSACTION_RECEIVED' && Boolean(address), 'Deployment of the contract failed');
-                        contractInstance = new default_1.Contract(this.compiledContract.abi, address, this.providerOrAccount);
+                        _a = _b.sent(), contract_address = _a.contract_address, transaction_hash = _a.transaction_hash;
+                        (0, minimalistic_assert_1.default)(Boolean(contract_address), 'Deployment of the contract failed');
+                        contractInstance = new default_1.Contract(this.compiledContract.abi, contract_address, this.providerOrAccount);
                         contractInstance.deployTransactionHash = transaction_hash;
                         return [2 /*return*/, contractInstance];
                 }

package/dist/contract/default.d.ts

@@ -1,7 +1,7 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
-import { Abi, AbiEntry, AddTransactionResponse, Args, AsyncContractFunction, Calldata, ContractFunction, Invocation, Overrides, ParsedStruct, Result, StructAbi } from '../types';
+import { Abi, AbiEntry, Args, AsyncContractFunction, Calldata, ContractFunction, Invocation, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ContractInterface } from './interface';
 export declare class Contract implements ContractInterface {
@@ -115,10 +115,10 @@ export declare class Contract implements ContractInterface {
      * @return - parsed response corresponding to the abi
      */
     protected parseResponse(method: string, response: string[]): Result;
-    invoke(method: string, args?: Array<any>, options?: Overrides): Promise<AddTransactionResponse>;
+    invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
     call(method: string, args?: Array<any>, { blockIdentifier, }?: {
         blockIdentifier?: BlockIdentifier;
     }): Promise<Result>;
-    estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFee>;
+    estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
     populate(method: string, args?: Array<any>): Invocation;
 }