starknet 3.4.0 → 3.6.0

package/.eslintrc

@@ -21,6 +21,7 @@
     "class-methods-use-this": 0,
     "import/prefer-default-export": 0,
     "@typescript-eslint/naming-convention": 0,
-    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
+    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
+    "func-names": 0
   }
 }

package/CHANGELOG.md

@@ -1,3 +1,48 @@
+# [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
+
+- account detection ([b3b3ba7](https://github.com/seanjameshan/starknet.js/commit/b3b3ba74dde72027ba7f0e1234fed34a604fdcec))
+- contract interface ([696116d](https://github.com/seanjameshan/starknet.js/commit/696116d383ba16c587e7ed708f7b47d02610b9d9))
+
+# [3.5.0](https://github.com/seanjameshan/starknet.js/compare/v3.4.0...v3.5.0) (2022-03-11)
+
+### Bug Fixes
+
+- contract test ([a9b4103](https://github.com/seanjameshan/starknet.js/commit/a9b410356baa5c7305da9ba69229c0882f7ae026))
+- **contract-factory:** move more towards ethers.js api ([4caa6ce](https://github.com/seanjameshan/starknet.js/commit/4caa6cee282fe73bc6fb91bea59c620cc42d31a0))
+- **contract:** structure change ([1ef9d2f](https://github.com/seanjameshan/starknet.js/commit/1ef9d2fee0158c9894d5e049f59cc72bfaad2d55))
+- **contract:** tests for new contract interface ([9273f54](https://github.com/seanjameshan/starknet.js/commit/9273f542b087e2940e0d2e88ecbeec58062953bf))
+- enable validateMethodAndArgs on call ([efa63d6](https://github.com/seanjameshan/starknet.js/commit/efa63d6fc7ae77b28f694640833cec73111b175d))
+- reverting validateMethodAndArgs changes ([d847fa8](https://github.com/seanjameshan/starknet.js/commit/d847fa8e4db3563d67861873046f9cb87d0fff8e))
+
+### Features
+
+- **contractFactory:** lib expanded with contract factory ([2c9c3d1](https://github.com/seanjameshan/starknet.js/commit/2c9c3d1b60961ddd698dc6b3175fff2f574f03bd))
+- **contract:** implement `contract.deployed() ⇒ Promise<Contract>` ([91f4992](https://github.com/seanjameshan/starknet.js/commit/91f4992a3f612a03ff5cde01d07a487ebb883f6d))
+- **contract:** new contract interface ([01eeae8](https://github.com/seanjameshan/starknet.js/commit/01eeae815619009de195a759891cad9d8ec992c7))
+- **contract:** new contract methods signature ([cc87943](https://github.com/seanjameshan/starknet.js/commit/cc8794362d2f20816aabf7b44596035d644a434d))
+- default contract args ([2a3956d](https://github.com/seanjameshan/starknet.js/commit/2a3956dab88f3e68a513916b1644fa0723c5235f))
+- **provider:** preparation for the fee integration ([c1c231b](https://github.com/seanjameshan/starknet.js/commit/c1c231b6ec803b01af280baf61d0afbc3f9be6bb))
+
 # [3.4.0](https://github.com/seanjameshan/starknet.js/compare/v3.3.0...v3.4.0) (2022-03-10)
 
 ### Features

package/__tests__/account.test.ts

@@ -21,10 +21,7 @@ describe('deploy and test Wallet', () => {
     const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
     expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const initializeResponse = await contract.invoke('initialize', {
-      signer: starkKeyPub,
-      guardian: '0',
-    });
+    const initializeResponse = await contract.initialize(starkKeyPub, '0');
     expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
     account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
@@ -36,10 +33,7 @@ describe('deploy and test Wallet', () => {
     erc20 = new Contract(compiledErc20.abi, erc20Address);
     expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    const mintResponse = await erc20.invoke('mint', {
-      recipient: account.address,
-      amount: '1000',
-    });
+    const mintResponse = await erc20.mint(account.address, '1000');
     expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
 
     const dappResponse = await defaultProvider.deployContract({
@@ -50,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,30 +69,30 @@ describe('deploy and test Wallet', () => {
   });
 
   test('read balance of wallet', async () => {
-    const { res } = await erc20.call('balance_of', {
-      user: account.address,
-    });
+    const { res } = await erc20.balance_of(account.address);
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
 
   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);
   });
 
   test('read balance of wallet after transfer', async () => {
-    const { res } = await erc20.call('balance_of', {
-      user: account.address,
-    });
+    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 () => {
@@ -101,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');
@@ -112,23 +116,27 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute multiple transactions', async () => {
-    const { code, transaction_hash } = await account.execute([
-      {
-        contractAddress: dapp.connectedTo,
-        entrypoint: 'set_number',
-        calldata: ['47'],
-      },
-      {
-        contractAddress: dapp.connectedTo,
-        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);
 
-    const response = await dapp.call('get_number', { user: account.address });
+    const response = await dapp.get_number(account.address);
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
   });
 

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()', () => {
@@ -38,10 +37,7 @@ describe('deploy and test Wallet', () => {
     accountContract = new Contract(compiledArgentAccount.abi, accountResponse.address);
     expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const initializeResponse = await accountContract.invoke('initialize', {
-      signer: starkKeyPub,
-      guardian: '0',
-    });
+    const initializeResponse = await accountContract.initialize(starkKeyPub, '0');
     expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
     const erc20Response = await defaultProvider.deployContract({
@@ -51,60 +47,21 @@ describe('deploy and test Wallet', () => {
     erc20 = new Contract(compiledErc20.abi, erc20Address);
     expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    const mintResponse = await erc20.invoke('mint', {
-      recipient: accountContract.connectedTo,
-      amount: '1000',
-    });
+    const mintResponse = await erc20.mint(accountContract.address, '1000');
     expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
     await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
   });
 
   test('read nonce', async () => {
-    const { nonce } = await accountContract.call('get_nonce');
+    const { nonce } = await accountContract.get_nonce();
 
     expect(number.toBN(nonce as string).toString()).toStrictEqual(number.toBN(0).toString());
   });
 
   test('read balance of wallet', async () => {
-    const { res } = await erc20.call('balance_of', {
-      user: accountContract.connectedTo,
-    });
-
-    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
-  });
-
-  test('execute by wallet owner', async () => {
-    const nonce = (await accountContract.call('get_nonce')).nonce.toString();
-
-    const calls = [
-      { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [erc20Address, '10'] },
-    ];
-    const msgHash = hash.hashMulticall(accountContract.connectedTo, calls, nonce, '0');
-
-    const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-
-    const signature = ec.sign(starkKeyPair, msgHash);
-    const { code, transaction_hash } = await accountContract.invoke(
-      '__execute__',
-      {
-        call_array: 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.call('balance_of', {
-      user: accountContract.connectedTo,
-    });
+    const { res } = await erc20.balance_of(accountContract.address);
 
-    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
+    expect(res).toStrictEqual(number.toBN(1000));
   });
 });
 

package/__tests__/constancts.ts

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

package/__tests__/contract.test.ts

@@ -1,9 +1,10 @@
 import { isBN } from 'bn.js';
 
-import { Contract, defaultProvider, stark } from '../src';
+import { Account, Contract, ContractFactory, Provider, defaultProvider, ec, stark } from '../src';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
+import { ACCOUNT_ADDRESS, PRIVATE_KEY } from './constancts';
 import { compiledErc20, compiledMulticall, compiledTypeTransformation } from './fixtures';
 
 describe('class Contract {}', () => {
@@ -20,7 +21,6 @@ describe('class Contract {}', () => {
       erc20 = new Contract(compiledErc20.abi, address, defaultProvider);
       expect(code).toBe('TRANSACTION_RECEIVED');
       await defaultProvider.waitForTransaction(transaction_hash);
-
       // Deploy Multicall
 
       const {
@@ -38,49 +38,60 @@ describe('class Contract {}', () => {
       await defaultProvider.waitForTransaction(m_transaction_hash);
     });
 
+    test('populate transaction for initial balance of that account', async () => {
+      const res = await erc20.populateTransaction.balance_of(wallet);
+      expect(res).toHaveProperty('contractAddress');
+      expect(res).toHaveProperty('entrypoint');
+      expect(res).toHaveProperty('calldata');
+      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 { res } = await erc20.call('balance_of', {
-        user: wallet,
-      });
+      const result = await erc20.balance_of(wallet);
+      const [res] = result;
       expect(res).toStrictEqual(toBN(0));
+      expect(res).toStrictEqual(result.res);
     });
 
     test('add 10 test ERC20 to account', async () => {
-      const response = await erc20.invoke('mint', {
-        recipient: wallet,
-        amount: '10',
-      });
+      const response = await erc20.mint(wallet, '10');
       expect(response.code).toBe('TRANSACTION_RECEIVED');
 
       await defaultProvider.waitForTransaction(response.transaction_hash);
     });
 
     test('read balance after mint of that account', async () => {
-      const { res } = await erc20.call('balance_of', {
-        user: wallet,
-      });
-
+      const result = await erc20.balance_of(wallet);
+      const [res] = result;
       expect(res).toStrictEqual(toBN(10));
+      expect(res).toStrictEqual(result.res);
     });
 
     test('read balance in a multicall', async () => {
       const args1 = { user: wallet };
       const args2 = {};
       const calls = [
-        erc20.connectedTo,
+        erc20.address,
         getSelectorFromName('balance_of'),
         Object.keys(args1).length,
         ...compileCalldata(args1),
 
-        erc20.connectedTo,
+        erc20.address,
         getSelectorFromName('decimals'),
         Object.keys(args2).length,
         ...compileCalldata(args2),
       ];
-      const { block_number, result } = await contract.call('aggregate', { calls });
+      const result = await contract.aggregate(calls);
+      const [block_number, res] = result;
       expect(isBN(block_number));
-      expect(Array.isArray(result));
-      (result as BigNumberish[]).forEach((el) => expect(isBN(el)));
+      expect(Array.isArray(res));
+      (res as BigNumberish[]).forEach((el) => expect(isBN(el)));
+      expect(block_number).toStrictEqual(result.block_number);
+      expect(res).toStrictEqual(result.result);
     });
   });
 
@@ -98,101 +109,180 @@ describe('class Contract {}', () => {
 
     describe('Request Type Transformation', () => {
       test('Parsing the felt in request', async () => {
-        return expect(contract.call('request_felt', { num: 3 })).resolves.not.toThrow();
+        return expect(contract.request_felt(3)).resolves.not.toThrow();
       });
 
       test('Parsing the array of felt in request', async () => {
-        return expect(
-          contract.call('request_array_of_felts', { arr: [1, 2] })
-        ).resolves.not.toThrow();
+        return expect(contract.request_array_of_felts([1, 2])).resolves.not.toThrow();
       });
 
       test('Parsing the struct in request', async () => {
-        return expect(
-          contract.call('request_struct', {
-            str: { x: 1, y: 2 },
-          })
-        ).resolves.not.toThrow();
+        return expect(contract.request_struct({ x: 1, y: 2 })).resolves.not.toThrow();
       });
 
       test('Parsing the array of structs in request', async () => {
-        return expect(
-          contract.call('request_array_of_structs', { str: [{ x: 1, y: 2 }] })
-        ).resolves.not.toThrow();
+        return expect(contract.request_array_of_structs([{ x: 1, y: 2 }])).resolves.not.toThrow();
       });
 
       test('Parsing the nested structs in request', async () => {
         return expect(
-          contract.call('request_nested_structs', {
-            str: {
-              p1: { x: 1, y: 2 },
-              p2: { x: 3, y: 4 },
-              extra: 5,
-            },
+          contract.request_nested_structs({
+            p1: { x: 1, y: 2 },
+            p2: { x: 3, y: 4 },
+            extra: 5,
           })
         ).resolves.not.toThrow();
       });
 
       test('Parsing the tuple in request', async () => {
-        return expect(contract.call('request_tuple', { tup: [1, 2] })).resolves.not.toThrow();
+        return expect(contract.request_tuple([1, 2])).resolves.not.toThrow();
       });
 
       test('Parsing the multiple types in request', async () => {
-        return expect(
-          contract.call('request_mixed_types', {
-            num: 2,
-            point: {
-              x: 1,
-              y: 2,
-            },
-            arr: [1],
-          })
-        ).resolves.not.toThrow();
+        return expect(contract.request_mixed_types(2, { x: 1, y: 2 }, [1])).resolves.not.toThrow();
       });
     });
 
     describe('Response Type Transformation', () => {
       test('Parsing the felt in response', async () => {
-        const { res } = await contract.call('get_felt');
+        const { res } = await contract.get_felt();
         expect(res).toStrictEqual(toBN(4));
       });
 
       test('Parsing the array of felt in response', async () => {
-        const { res } = await contract.call('get_array_of_felts');
+        const result = await contract.get_array_of_felts();
+        const [res] = result;
         expect(res).toStrictEqual([toBN(4), toBN(5)]);
+        expect(res).toStrictEqual(result.res);
       });
 
       test('Parsing the array of structs in response', async () => {
-        const { res } = await contract.call('get_struct');
+        const result = await contract.get_struct();
+        const [res] = result;
         expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
+        expect(res).toStrictEqual(result.res);
       });
 
       test('Parsing the array of structs in response', async () => {
-        const { res } = await contract.call('get_array_of_structs');
+        const result = await contract.get_array_of_structs();
+        const [res] = result;
         expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
+        expect(res).toStrictEqual(result.res);
       });
 
       test('Parsing the nested structs in response', async () => {
-        const { res } = await contract.call('get_nested_structs');
+        const result = await contract.get_nested_structs();
+        const [res] = result;
         expect(res).toStrictEqual({
           p1: { x: toBN(1), y: toBN(2) },
           p2: { x: toBN(3), y: toBN(4) },
           extra: toBN(5),
         });
+        expect(res).toStrictEqual(result.res);
       });
 
       test('Parsing the tuple in response', async () => {
-        const { res } = await contract.call('get_tuple');
+        const result = await contract.get_tuple();
+        const [res] = result;
         expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
+        expect(res).toStrictEqual(result.res);
       });
 
       test('Parsing the multiple types in response', async () => {
-        const { tuple, number, array, point } = await contract.call('get_mixed_types');
+        const result = await contract.get_mixed_types();
+        const [tuple, number, array, point] = result;
         expect(tuple).toStrictEqual([toBN(1), toBN(2)]);
         expect(number).toStrictEqual(toBN(3));
         expect(array).toStrictEqual([toBN(4)]);
         expect(point).toStrictEqual({ x: toBN(1), y: toBN(2) });
+        expect(tuple).toStrictEqual(result.tuple);
+        expect(number).toStrictEqual(result.number);
+        expect(array).toStrictEqual(result.array);
+        expect(point).toStrictEqual(result.point);
+      });
+    });
+  });
+
+  describe('Contract interaction with Account', () => {
+    const starkKeyPair = ec.getKeyPair(PRIVATE_KEY);
+    let account: Account;
+    let erc20: Contract;
+    let erc20Address: string;
+
+    beforeAll(async () => {
+      account = new Account(defaultProvider, ACCOUNT_ADDRESS, starkKeyPair);
+
+      const erc20Response = await defaultProvider.deployContract({
+        contract: compiledErc20,
       });
+      erc20Address = erc20Response.address;
+      erc20 = new Contract(compiledErc20.abi, erc20Address, defaultProvider);
+      await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
+      expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
+
+      const mintResponse = await erc20.mint(account.address, '1000');
+
+      await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
+    });
+
+    test('read balance of wallet', async () => {
+      const result = await erc20.balance_of(account.address);
+      const [res] = result;
+      expect(res).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(result.res);
     });
+
+    test('change from provider to account', async () => {
+      expect(erc20.providerOrAccount instanceof Provider);
+      erc20.connect(account);
+      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);
+
+      expect(res).toStrictEqual(toBN(1000));
+    });
+
+    test('invoke contract by wallet owner', async () => {
+      const { transaction_hash, code } = await erc20.transfer(toBN(erc20Address).toString(), 10);
+      expect(code).toBe('TRANSACTION_RECEIVED');
+      await defaultProvider.waitForTransaction(transaction_hash);
+      const { res } = await erc20.balance_of(account.address);
+      expect(res).toStrictEqual(toBN(990));
+    });
+  });
+});
+
+describe('class ContractFactory {}', () => {
+  let erc20Address: string;
+  beforeAll(async () => {
+    const { code, transaction_hash, address } = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(transaction_hash);
+    erc20Address = address;
+  });
+  test('deployment of new contract', async () => {
+    const factory = new ContractFactory(compiledErc20);
+    const erc20 = await factory.deploy();
+    expect(erc20 instanceof Contract);
+  });
+  test('wait for deployment transaction', async () => {
+    const factory = new ContractFactory(compiledErc20);
+    const contract = await factory.deploy();
+    expect(contract.deployed()).resolves.not.toThrow();
+  });
+  test('attach new contract', async () => {
+    const factory = new ContractFactory(compiledErc20);
+    const erc20 = factory.attach(erc20Address);
+    expect(erc20 instanceof Contract);
   });
 });

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/__tests__/utils/utils.browser.test.ts

@@ -17,9 +17,7 @@ test('isBrowser', () => {
 });
 describe('compressProgram()', () => {
   test('compresses a contract program', () => {
-    const inputContract = compiledArgentAccount as any;
-
-    const compressed = stark.compressProgram(inputContract.program);
+    const compressed = stark.compressProgram(compiledArgentAccount.program);
 
     expect(compressed).toMatchSnapshot();
   });

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
    *