starknet 3.5.1 → 3.6.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+# [3.6.0](https://github.com/seanjameshan/starknet.js/compare/v3.5.1...v3.6.0) (2022-03-24)
+
+### Bug Fixes
+
+- **account:** estimate fee transfered from provider to account class ([93e7dd9](https://github.com/seanjameshan/starknet.js/commit/93e7dd941b35bccb67cc426b9ae546801092964c))
+- formatting ([248246f](https://github.com/seanjameshan/starknet.js/commit/248246f2fe75b9897700b955fa98e1779aec1744))
+- link ([494e000](https://github.com/seanjameshan/starknet.js/commit/494e0005c3b1cb86f5de0f25a10cbbe786a87b34))
+- **provider:** estimateFee entrypoint conversion fix ([e40204a](https://github.com/seanjameshan/starknet.js/commit/e40204a2eca5f475fe50a88349fd4890bbc36790))
+- **provider:** estimation fee response type ([ce674ca](https://github.com/seanjameshan/starknet.js/commit/ce674ca632ff70a07d95d685c9bf2f48bebaca20))
+
+### Features
+
+- add LedgerSigner class + blind signing ([9b700f3](https://github.com/seanjameshan/starknet.js/commit/9b700f300a91a0967f8827d0ecdd69e531738ec4))
+- **contract:** contract expanded with estimateFee method ([fbaf4ba](https://github.com/seanjameshan/starknet.js/commit/fbaf4bab56ace0917ce7c66ecf90f8e2d0dc7f60))
+- improvements after PR reviewing ([9f30e20](https://github.com/seanjameshan/starknet.js/commit/9f30e20c2e5d2afafe4eae58c597b82dffc3bbe2))
+- new improvements after new PR review ([2e16808](https://github.com/seanjameshan/starknet.js/commit/2e168082b0042f27336946639f3948e91bc5f641))
+- **provider:** provider expanded with getTransactionTrace ([b67361a](https://github.com/seanjameshan/starknet.js/commit/b67361ad7c50218e00273c097426e14814441404))
+
 ## [3.5.1](https://github.com/seanjameshan/starknet.js/compare/v3.5.0...v3.5.1) (2022-03-11)
 
 ### Bug Fixes

package/__tests__/account.test.ts

@@ -44,6 +44,16 @@ describe('deploy and test Wallet', () => {
     await defaultProvider.waitForTransaction(dappResponse.transaction_hash);
   });
 
+  test('estimate fee', async () => {
+    const { amount, unit } = await account.estimateFee({
+      contractAddress: erc20Address,
+      entrypoint: 'transfer',
+      calldata: [erc20.address, '10'],
+    });
+    expect(typeof amount).toBe('number');
+    expect(typeof unit).toBe('string');
+  });
+
   test('same wallet address', () => {
     expect(account.address).toBe(account.address);
   });
@@ -65,11 +75,15 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute by wallet owner', async () => {
-    const { code, transaction_hash } = await account.execute({
-      contractAddress: erc20Address,
-      entrypoint: 'transfer',
-      calldata: [toBN(erc20Address).toString(), '10'],
-    });
+    const { code, transaction_hash } = await account.execute(
+      {
+        contractAddress: erc20Address,
+        entrypoint: 'transfer',
+        calldata: [erc20.address, '10'],
+      },
+      undefined,
+      { maxFee: '0' }
+    );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
     await defaultProvider.waitForTransaction(transaction_hash);
@@ -78,7 +92,7 @@ describe('deploy and test Wallet', () => {
   test('read balance of wallet after transfer', async () => {
     const { res } = await erc20.balance_of(account.address);
 
-    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
+    expect(res).toStrictEqual(toBN(990));
   });
 
   test('execute with custom nonce', async () => {
@@ -91,10 +105,10 @@ describe('deploy and test Wallet', () => {
       {
         contractAddress: erc20Address,
         entrypoint: 'transfer',
-        calldata: [toBN(erc20Address).toString(), '10'],
+        calldata: [account.address, '10'],
       },
       undefined,
-      { nonce }
+      { nonce, maxFee: '0' }
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
@@ -102,18 +116,22 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute multiple transactions', async () => {
-    const { code, transaction_hash } = await account.execute([
-      {
-        contractAddress: dapp.address,
-        entrypoint: 'set_number',
-        calldata: ['47'],
-      },
-      {
-        contractAddress: dapp.address,
-        entrypoint: 'increase_number',
-        calldata: ['10'],
-      },
-    ]);
+    const { code, transaction_hash } = await account.execute(
+      [
+        {
+          contractAddress: dapp.address,
+          entrypoint: 'set_number',
+          calldata: ['47'],
+        },
+        {
+          contractAddress: dapp.address,
+          entrypoint: 'increase_number',
+          calldata: ['10'],
+        },
+      ],
+      undefined,
+      { maxFee: '0' }
+    );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
     await defaultProvider.waitForTransaction(transaction_hash);

package/__tests__/accountContract.test.ts

@@ -1,5 +1,4 @@
 import { Contract, defaultProvider, ec, hash, number, stark } from '../src';
-import { transformCallsToMulticallArrays } from '../src/utils/transaction';
 import { compiledArgentAccount, compiledErc20 } from './fixtures';
 
 describe('getStarkAccountFromPrivateKey()', () => {
@@ -64,36 +63,6 @@ describe('deploy and test Wallet', () => {
 
     expect(res).toStrictEqual(number.toBN(1000));
   });
-
-  test('execute by wallet owner', async () => {
-    const nonce = (await accountContract.get_nonce()).nonce.toString();
-
-    const calls = [
-      { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [erc20Address, '10'] },
-    ];
-    const msgHash = hash.hashMulticall(accountContract.address, calls, nonce, '0');
-
-    const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-
-    const signature = ec.sign(starkKeyPair, msgHash);
-    // eslint-disable-next-line no-underscore-dangle
-    const { code, transaction_hash } = await accountContract.__execute__(
-      callArray,
-      calldata,
-      nonce,
-      signature
-    );
-
-    expect(code).toBe('TRANSACTION_RECEIVED');
-
-    await defaultProvider.waitForTransaction(transaction_hash);
-  });
-
-  test('read balance of wallet after transfer', async () => {
-    const { res } = await erc20.balance_of(accountContract.address);
-
-    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
-  });
 });
 
 test('build tx', async () => {

package/__tests__/constancts.ts

@@ -0,0 +1,2 @@
+export const ACCOUNT_ADDRESS = '0x4e5f6f6020ffa7e5761cbe96e932b7c1cbbcace70c0fe22767c5f0abf851a17';
+export const PRIVATE_KEY = '0x0529868a6dc774b36342024c207686af16e84fc157c5eeb3a9d31fa13c0d44c5';

package/__tests__/contract.test.ts

@@ -4,12 +4,8 @@ import { Account, Contract, ContractFactory, Provider, defaultProvider, ec, star
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
-import {
-  compiledArgentAccount,
-  compiledErc20,
-  compiledMulticall,
-  compiledTypeTransformation,
-} from './fixtures';
+import { ACCOUNT_ADDRESS, PRIVATE_KEY } from './constancts';
+import { compiledErc20, compiledMulticall, compiledTypeTransformation } from './fixtures';
 
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
@@ -50,6 +46,10 @@ describe('class Contract {}', () => {
       expect(res).toHaveProperty('signature');
     });
 
+    test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
+      expect(erc20.estimateFee.mint(wallet, '10')).rejects.toThrow();
+    });
+
     test('read initial balance of that account', async () => {
       const result = await erc20.balance_of(wallet);
       const [res] = result;
@@ -204,26 +204,13 @@ describe('class Contract {}', () => {
   });
 
   describe('Contract interaction with Account', () => {
-    const privateKey = stark.randomAddress();
-
-    const starkKeyPair = ec.getKeyPair(privateKey);
-    const starkKeyPub = ec.getStarkKey(starkKeyPair);
+    const starkKeyPair = ec.getKeyPair(PRIVATE_KEY);
     let account: Account;
     let erc20: Contract;
     let erc20Address: string;
 
     beforeAll(async () => {
-      const accountResponse = await defaultProvider.deployContract({
-        contract: compiledArgentAccount,
-        addressSalt: starkKeyPub,
-      });
-      const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
-      expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
-
-      const initializeResponse = await contract.initialize(starkKeyPub, '0');
-      expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
-
-      account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
+      account = new Account(defaultProvider, ACCOUNT_ADDRESS, starkKeyPair);
 
       const erc20Response = await defaultProvider.deployContract({
         contract: compiledErc20,
@@ -251,6 +238,12 @@ describe('class Contract {}', () => {
       expect(erc20.providerOrAccount instanceof Account);
     });
 
+    test('estimate gas fee for `mint`', async () => {
+      const res = await erc20.estimateFee.mint(wallet, '10');
+      expect(res).toHaveProperty('amount');
+      expect(res).toHaveProperty('unit');
+    });
+
     test('read balance of wallet', async () => {
       const { res } = await erc20.balance_of(account.address);
 

package/__tests__/provider.test.ts

@@ -93,6 +93,14 @@ describe('defaultProvider', () => {
         })
       ).resolves.not.toThrow();
     });
+
+    test('transaction trace', async () => {
+      const transactionTrace = await defaultProvider.getTransactionTrace(
+        '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
+      );
+      expect(transactionTrace).toHaveProperty('function_invocation');
+      expect(transactionTrace).toHaveProperty('signature');
+    });
   });
 
   describe('addTransaction()', () => {

package/account/default.d.ts

@@ -3,6 +3,7 @@ import {
   Abi,
   AddTransactionResponse,
   Call,
+  EstimateFeeResponse,
   InvocationsDetails,
   KeyPair,
   Signature,
@@ -16,6 +17,7 @@ export declare class Account extends Provider implements AccountInterface {
   private signer;
   constructor(provider: Provider, address: string, keyPair: KeyPair);
   getNonce(): Promise<string>;
+  estimateFee(calls: Call | Call[]): Promise<EstimateFeeResponse>;
   /**
    * Invoke execute function in account contract
    *

package/account/default.js

@@ -233,6 +233,46 @@ var Account = /** @class */ (function (_super) {
       });
     });
   };
+  Account.prototype.estimateFee = function (calls) {
+    return __awaiter(this, void 0, void 0, function () {
+      var transactions, nonce, signerDetails, signature, calldata;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            transactions = Array.isArray(calls) ? calls : [calls];
+            return [4 /*yield*/, this.getNonce()];
+          case 1:
+            nonce = _a.sent();
+            signerDetails = {
+              walletAddress: this.address,
+              nonce: (0, number_1.toBN)(nonce),
+              maxFee: (0, number_1.toBN)('0'),
+            };
+            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
+          case 2:
+            signature = _a.sent();
+            calldata = __spreadArray(
+              __spreadArray(
+                [],
+                __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)),
+                false
+              ),
+              [signerDetails.nonce.toString()],
+              false
+            );
+            return [
+              2 /*return*/,
+              this.fetchEndpoint('estimate_fee', undefined, {
+                contract_address: this.address,
+                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
+                calldata: calldata,
+                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
+              }),
+            ];
+        }
+      });
+    });
+  };
   /**
    * Invoke execute function in account contract
    *
@@ -250,15 +290,11 @@ var Account = /** @class */ (function (_super) {
       transactionsDetail = {};
     }
     return __awaiter(this, void 0, void 0, function () {
-      var transactions, signerDetails, _c, _d, signature, calldata;
-      var _e;
+      var transactions, nonce, _c, _d, maxFee, _e, signerDetails, signature, calldata;
       return __generator(this, function (_f) {
         switch (_f.label) {
           case 0:
             transactions = Array.isArray(calls) ? calls : [calls];
-            _e = {
-              walletAddress: this.address,
-            };
             _c = number_1.toBN;
             if (!((_a = transactionsDetail.nonce) !== null && _a !== void 0))
               return [3 /*break*/, 1];
@@ -270,14 +306,25 @@ var Account = /** @class */ (function (_super) {
             _d = _f.sent();
             _f.label = 3;
           case 3:
-            signerDetails =
-              ((_e.nonce = _c.apply(void 0, [_d])),
-              (_e.maxFee = (0, number_1.toBN)(
-                (_b = transactionsDetail.maxFee) !== null && _b !== void 0 ? _b : '0'
-              )),
-              _e);
-            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
+            nonce = _c.apply(void 0, [_d]);
+            if (!((_b = transactionsDetail.maxFee) !== null && _b !== void 0))
+              return [3 /*break*/, 4];
+            _e = _b;
+            return [3 /*break*/, 6];
           case 4:
+            return [4 /*yield*/, this.estimateFee(transactions)];
+          case 5:
+            _e = _f.sent().amount;
+            _f.label = 6;
+          case 6:
+            maxFee = _e;
+            signerDetails = {
+              walletAddress: this.address,
+              nonce: nonce,
+              maxFee: maxFee,
+            };
+            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
+          case 7:
             signature = _f.sent();
             calldata = __spreadArray(
               __spreadArray(
@@ -296,6 +343,7 @@ var Account = /** @class */ (function (_super) {
                 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)),
               }),
             ];
         }

package/account/interface.d.ts

@@ -4,6 +4,8 @@ import {
   AddTransactionResponse,
   Call,
   DeployContractPayload,
+  EstimateFeeResponse,
+  Invocation,
   InvocationsDetails,
   Signature,
 } from '../types';
@@ -25,6 +27,18 @@ export declare abstract class AccountInterface extends ProviderInterface {
     payload: DeployContractPayload,
     abi?: Abi
   ): Promise<AddTransactionResponse>;
+  /**
+   * Estimate Fee for a method on starknet
+   *
+   * @param invocation the invocation object containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   *
+   * @returns response from addTransaction
+   */
+  abstract estimateFee(invocation: Invocation): Promise<EstimateFeeResponse>;
   /**
    * Invoke execute function in account contract
    *

package/contract/default.d.ts

@@ -138,6 +138,6 @@ export declare class Contract implements ContractInterface {
   protected parseResponse(method: string, response: string[]): Result;
   invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
   call(method: string, args?: Array<any>): Promise<Result>;
-  estimate(_method: string, _args?: Array<any>): Promise<void>;
+  estimate(method: string, args?: Array<any>): Promise<import('../types').EstimateFeeResponse>;
   populate(method: string, args?: Array<any>): Invocation;
 }

package/contract/default.js

@@ -188,7 +188,6 @@ 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 hash_1 = require('../utils/hash');
 var number_1 = require('../utils/number');
 function parseFelt(candidate) {
   try {
@@ -726,9 +725,9 @@ var Contract = /** @class */ (function () {
       }
       return acc;
     }, 0);
-    var signature = [];
+    var overrides = {};
     if (args.length === inputsLength + 1 && Array.isArray(args[args.length - 1])) {
-      signature.push.apply(signature, __spreadArray([], __read(args.pop()), false));
+      Object.assign(overrides, args.pop());
     }
     if (args.length !== inputsLength) {
       throw Error(
@@ -746,10 +745,13 @@ var Contract = /** @class */ (function () {
       entrypoint: method,
     };
     if ('execute' in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation);
+      return this.providerOrAccount.execute(invocation, undefined, {
+        maxFee: overrides.maxFee,
+        nonce: overrides.nonce,
+      });
     }
     return this.providerOrAccount.invokeFunction(
-      __assign(__assign({}, invocation), { signature: signature })
+      __assign(__assign({}, invocation), { signature: overrides.signature || [] })
     );
   };
   Contract.prototype.call = function (method, args) {
@@ -794,14 +796,28 @@ var Contract = /** @class */ (function () {
       });
     });
   };
-  Contract.prototype.estimate = function (_method, _args) {
-    if (_args === void 0) {
-      _args = [];
+  Contract.prototype.estimate = function (method, args) {
+    if (args === void 0) {
+      args = [];
     }
     return __awaiter(this, void 0, void 0, function () {
-      return __generator(this, function (_a) {
+      var invocation;
+      var _a;
+      return __generator(this, function (_b) {
         //  TODO; remove error as soon as estimate fees are supported
-        throw Error('Estimation of the fees are not yet supported');
+        // ensure contract is connected
+        (0,
+        minimalistic_assert_1.default)(this.address !== null, 'contract isnt connected to an address');
+        // validate method and args
+        this.validateMethodAndArgs('INVOKE', method, args);
+        invocation = (_a = this.populateTransaction)[method].apply(
+          _a,
+          __spreadArray([], __read(args), false)
+        );
+        if ('estimateFee' in this.providerOrAccount) {
+          return [2 /*return*/, this.providerOrAccount.estimateFee(invocation)];
+        }
+        throw Error('Contract must be connected to the account contract to estimate');
       });
     });
   };
@@ -814,7 +830,7 @@ var Contract = /** @class */ (function () {
     }).inputs;
     return {
       contractAddress: this.address,
-      entrypoint: (0, hash_1.getSelectorFromName)(method),
+      entrypoint: method,
       calldata: this.compileCalldata(args, inputs),
       signature: [],
     };

package/dist/account/default.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from '../provider';
-import { Abi, AddTransactionResponse, Call, InvocationsDetails, KeyPair, Signature, Transaction } from '../types';
+import { Abi, AddTransactionResponse, Call, EstimateFeeResponse, InvocationsDetails, KeyPair, Signature, Transaction } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -8,6 +8,7 @@ export declare class Account extends Provider implements AccountInterface {
     private signer;
     constructor(provider: Provider, address: string, keyPair: KeyPair);
     getNonce(): Promise<string>;
+    estimateFee(calls: Call | Call[]): Promise<EstimateFeeResponse>;
     /**
      * Invoke execute function in account contract
      *

package/dist/account/default.js

@@ -113,6 +113,35 @@ var Account = /** @class */ (function (_super) {
             });
         });
     };
+    Account.prototype.estimateFee = function (calls) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions, nonce, signerDetails, signature, calldata;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        transactions = Array.isArray(calls) ? calls : [calls];
+                        return [4 /*yield*/, this.getNonce()];
+                    case 1:
+                        nonce = _a.sent();
+                        signerDetails = {
+                            walletAddress: this.address,
+                            nonce: (0, number_1.toBN)(nonce),
+                            maxFee: (0, number_1.toBN)('0'),
+                        };
+                        return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
+                    case 2:
+                        signature = _a.sent();
+                        calldata = __spreadArray(__spreadArray([], __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)), false), [signerDetails.nonce.toString()], false);
+                        return [2 /*return*/, this.fetchEndpoint('estimate_fee', undefined, {
+                                contract_address: this.address,
+                                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
+                                calldata: calldata,
+                                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
+                            })];
+                }
+            });
+        });
+    };
     /**
      * Invoke execute function in account contract
      *
@@ -126,15 +155,11 @@ 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, signerDetails, _c, _d, signature, calldata;
-            var _e;
+            var transactions, nonce, _c, _d, maxFee, _e, signerDetails, signature, calldata;
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
                         transactions = Array.isArray(calls) ? calls : [calls];
-                        _e = {
-                            walletAddress: this.address
-                        };
                         _c = number_1.toBN;
                         if (!((_a = transactionsDetail.nonce) !== null && _a !== void 0)) return [3 /*break*/, 1];
                         _d = _a;
@@ -144,11 +169,23 @@ var Account = /** @class */ (function (_super) {
                         _d = (_f.sent());
                         _f.label = 3;
                     case 3:
-                        signerDetails = (_e.nonce = _c.apply(void 0, [_d]),
-                            _e.maxFee = (0, number_1.toBN)((_b = transactionsDetail.maxFee) !== null && _b !== void 0 ? _b : '0'),
-                            _e);
+                        nonce = _c.apply(void 0, [_d]);
+                        if (!((_b = transactionsDetail.maxFee) !== null && _b !== void 0)) return [3 /*break*/, 4];
+                        _e = _b;
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.estimateFee(transactions)];
+                    case 5:
+                        _e = (_f.sent()).amount;
+                        _f.label = 6;
+                    case 6:
+                        maxFee = _e;
+                        signerDetails = {
+                            walletAddress: this.address,
+                            nonce: nonce,
+                            maxFee: maxFee,
+                        };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
-                    case 4:
+                    case 7:
                         signature = _f.sent();
                         calldata = __spreadArray(__spreadArray([], __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)), false), [signerDetails.nonce.toString()], false);
                         return [2 /*return*/, this.fetchEndpoint('add_transaction', undefined, {
@@ -157,6 +194,7 @@ var Account = /** @class */ (function (_super) {
                                 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)),
                             })];
                 }
             });

package/dist/account/interface.d.ts

@@ -1,5 +1,5 @@
 import { ProviderInterface } from '../provider';
-import { Abi, AddTransactionResponse, Call, DeployContractPayload, InvocationsDetails, Signature } from '../types';
+import { Abi, AddTransactionResponse, Call, DeployContractPayload, EstimateFeeResponse, Invocation, InvocationsDetails, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 export declare abstract class AccountInterface extends ProviderInterface {
@@ -15,6 +15,18 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * @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
+     *
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     *
+     * @returns response from addTransaction
+     */
+    abstract estimateFee(invocation: Invocation): Promise<EstimateFeeResponse>;
     /**
      * Invoke execute function in account contract
      *

package/dist/contract/default.d.ts

@@ -116,6 +116,6 @@ export declare class Contract implements ContractInterface {
     protected parseResponse(method: string, response: string[]): Result;
     invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
     call(method: string, args?: Array<any>): Promise<Result>;
-    estimate(_method: string, _args?: Array<any>): Promise<void>;
+    estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
     populate(method: string, args?: Array<any>): Invocation;
 }