starknet 2.7.1 → 3.0.0

package/.eslintrc

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

package/CHANGELOG.md

@@ -1,3 +1,50 @@
+# [3.0.0](https://github.com/seanjameshan/starknet.js/compare/v2.9.0...v3.0.0) (2022-02-10)
+
+### Bug Fixes
+
+- **account:** dont allow additional signatures in execute ([ac02d46](https://github.com/seanjameshan/starknet.js/commit/ac02d46c5759904886f56a7b9e7e2686dbf52d4c))
+- comments ([f261120](https://github.com/seanjameshan/starknet.js/commit/f261120e1971710cde8f95bd17a5869860db8160))
+- review comments ([ee93bd6](https://github.com/seanjameshan/starknet.js/commit/ee93bd6e51eabcf3507a77d21c5bdc6fe93d5d1c))
+- **test:** remove only for getTransactionReceipt test ([eb11d3b](https://github.com/seanjameshan/starknet.js/commit/eb11d3b60f434f81390f4d13c0462ad8c7ed7321))
+- **types:** change type of `block_number` from `number` to `BlockNumber` in TransactionReceipt ([7a48ff8](https://github.com/seanjameshan/starknet.js/commit/7a48ff8e15a93a778fec62fdff10f92b1a073dec))
+- **types:** update TransactionReceipt type ([9f9f6a2](https://github.com/seanjameshan/starknet.js/commit/9f9f6a2f4cf3b8bfb438edda06ec38bd1471c03d))
+
+### Features
+
+- **account:** introduce execute method ([0be78c6](https://github.com/seanjameshan/starknet.js/commit/0be78c67a40d0b457c571a57a8b49008f5e423de))
+- **contract:** add an option to pass block identifier ([e34dd86](https://github.com/seanjameshan/starknet.js/commit/e34dd86c07495b7b8c38ee410838e15226a7b8d6))
+- new signer and provider interface ([4b2a71c](https://github.com/seanjameshan/starknet.js/commit/4b2a71c578e363b11abb1c3adb74472bbb9f73fe))
+- **provider:** add getTransactionReceipt() ([4267a5f](https://github.com/seanjameshan/starknet.js/commit/4267a5f5cec77bb4b09b2e8b4979ec0ee611d416))
+- split account and signer ([ca4ad9d](https://github.com/seanjameshan/starknet.js/commit/ca4ad9d62aee8b0637096eb3059e96dd4407f663))
+- update readme ([ed021dc](https://github.com/seanjameshan/starknet.js/commit/ed021dc25a394affec8ea92ed79eed4c68a040d8))
+
+### BREAKING CHANGES
+
+- new provider and signer interfaces
+
+# [2.9.0](https://github.com/seanjameshan/starknet.js/compare/v2.8.0...v2.9.0) (2022-02-04)
+
+### Bug Fixes
+
+- introduce block identifier type ([75599a9](https://github.com/seanjameshan/starknet.js/commit/75599a99bbcb5723cfc8575b5fbf994a0bbf5b67))
+
+### Features
+
+- **utils:** add validateAndParseAddress function ([c067fc4](https://github.com/seanjameshan/starknet.js/commit/c067fc443e4dc9c22b78ed6c093978a2f37debde))
+
+# [2.8.0](https://github.com/seanjameshan/starknet.js/compare/v2.7.2...v2.8.0) (2022-02-02)
+
+### Features
+
+- add tests ([e495d48](https://github.com/seanjameshan/starknet.js/commit/e495d4899141a79fe310d4fe76f70df03b1551ca))
+- implement verifyMessage and verifyMessageHash ([bc9c4e9](https://github.com/seanjameshan/starknet.js/commit/bc9c4e9574cc453af35705eb4488602ea33cc2cb))
+
+## [2.7.2](https://github.com/seanjameshan/starknet.js/compare/v2.7.1...v2.7.2) (2022-01-20)
+
+### Bug Fixes
+
+- **CONTRIBUTING:** wrong link ([2622a6c](https://github.com/seanjameshan/starknet.js/commit/2622a6c984259a6928e9ab02892b8de60b8c749e))
+
 ## [2.7.1](https://github.com/seanjameshan/starknet.js/compare/v2.7.0...v2.7.1) (2022-01-04)
 
 ### Bug Fixes

package/CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 We love pull requests. And following this guidelines will make your pull request easier to merge.
 
-If you want to contribute but don’t know what to do, take a look at these two labels: [help wanted](https://github.com/seanjameshan/starknet/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) and [good first issue](https://github.com/seanjameshan/starknet/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
+If you want to contribute but don’t know what to do, take a look at these two labels: [help wanted](https://github.com/seanjameshan/starknet.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) and [good first issue](https://github.com/seanjameshan/starknet.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
 
 _[Use GitHub interface](https://blog.sapegin.me/all/open-source-for-everyone/) for simple documentation changes, otherwise follow the steps below._
 

package/README.md

@@ -40,6 +40,8 @@ Install starknet with `npm`
 
 ```bash
 $ npm install starknet
+# or
+$ npm install starknet@next
 ```
 
 Import `starknet` and use the [API](https://www.starknetjs.com/modules.html)
@@ -54,16 +56,18 @@ const CONTRACT_ADDRESS =
   "0x03e19baa6cb2078631bcdb34844f3f7879449a544c9ce722681a54af08cff4b9";
 
 /**
- * addTransaction() example
+ * invokeFunction() example
 **/
 
 /** Reset the liquidity pool **/
-const addTokenResponse = await provider.addTransaction({
-  type: "INVOKE_FUNCTION",
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("init_pool"),
-  calldata: ["1000000", "1000000"],
-});
+const addTokenResponse = await defaultProvider.invokeFunction(
+  {
+    contractAddress: CONTRACT_ADDRESS,
+    entrypoint: "init_pool",
+    calldata: ["1000000", "1000000"],
+  },
+  abi // for displaying purposes only (default implementation has no display/ui)
+);
 console.log(addTokenResponse);
 
 /**
@@ -71,26 +75,24 @@ console.log(addTokenResponse);
 **/
 
 /** Get the balance of the liquidity pool of token A **/
-const poolBalanceTokenA = await callContract({
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("get_pool_token_balance"),
+const poolBalanceTokenA = await defaultProvider.callContract({
+  contractAddress: CONTRACT_ADDRESS,
+  entrypoint: "get_pool_token_balance",
   calldata: ["1"],
 });
 const balanceA = poolBalanceTokenA.result[0];
 console.log('token a liquidity pool balance: ', parseInt(balanceA, 16));
 
 /** Get the balance of the liquidity pool of token B **/
-const poolBalanceTokenB = await callContract({
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("get_pool_token_balance"),
+const poolBalanceTokenB = await defaultProvider.callContract({
+  contractAddress: CONTRACT_ADDRESS,
+  entrypoint: "get_pool_token_balance",
   calldata: ["2"],
 });
 const balanceB = poolBalanceTokenB.result[0];
 console.log('token b liquidity pool balance: ', parseInt(balanceB, 16));
 ```
 
-For more information about **signing transactions**, please take a look at this [pull request](https://github.com/seanjameshan/starknet.js/pull/51)
-
 ## 🌐 API
 
 [Click Here](https://www.starknetjs.com/modules.html)
@@ -113,6 +115,6 @@ This library would not be possible without these rockstars.
 
 ## 📜 License
 
-Copyright (c) 2021 Sean James Han
+Copyright (c) 2022 0xs34n
 
 Licensed under the [MIT license](https://github.com/seanjameshan/starknet.js/blob/main/LICENSE).

package/__mocks__/typedDataExample.json

@@ -0,0 +1,35 @@
+{
+  "types": {
+    "StarkNetDomain": [
+      { "name": "name", "type": "felt" },
+      { "name": "version", "type": "felt" },
+      { "name": "chainId", "type": "felt" }
+    ],
+    "Person": [
+      { "name": "name", "type": "felt" },
+      { "name": "wallet", "type": "felt" }
+    ],
+    "Mail": [
+      { "name": "from", "type": "Person" },
+      { "name": "to", "type": "Person" },
+      { "name": "contents", "type": "felt" }
+    ]
+  },
+  "primaryType": "Mail",
+  "domain": {
+    "name": "StarkNet Mail",
+    "version": "1",
+    "chainId": 1
+  },
+  "message": {
+    "from": {
+      "name": "Cow",
+      "wallet": "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"
+    },
+    "to": {
+      "name": "Bob",
+      "wallet": "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"
+    },
+    "contents": "Hello, Bob!"
+  }
+}

package/__tests__/account.test.ts

@@ -1,36 +1,18 @@
 import fs from 'fs';
 
+import typedDataExample from '../__mocks__/typedDataExample.json';
 import {
+  Account,
   CompiledContract,
   Contract,
   compileCalldata,
   defaultProvider,
   ec,
-  encode,
-  hash,
   json,
   number,
   stark,
 } from '../src';
-
-describe('getStarkAccountFromPrivateKey()', () => {
-  test('it works with valid privateKey', () => {
-    const privateKey = '0xb696427c0d79c5d28a1fa6f748bae1b98b3f4b86bd1a2505bab144673c856fa9';
-
-    const starkKeyPair = ec.getKeyPair(privateKey);
-    const starkKey = ec.getStarkKey(starkKeyPair);
-
-    expect(starkKey).toBe('0x060d46f8d7ef3d83ed05f3ed9beb91e22f9529289b9d863683fd71eafaf28035');
-  });
-  test('it works with valid privateKey', () => {
-    const privateKey = '0x5f65099e269b080000000000000000000000000000000000000000000000000';
-
-    const starkKeyPair = ec.getKeyPair(privateKey);
-    const starkKey = ec.getStarkKey(starkKeyPair);
-
-    expect(starkKey).toBe('0xf321e59b257a577836d8313150aabd21f412491358c329966218df76bab591');
-  });
-});
+import { toBN } from '../src/utils/number';
 
 const compiledArgentAccount: CompiledContract = json.parse(
   fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
@@ -44,31 +26,30 @@ describe('deploy and test Wallet', () => {
 
   const starkKeyPair = ec.getKeyPair(privateKey);
   const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let wallet: Contract;
   let walletAddress: string;
   let erc20: Contract;
   let erc20Address: string;
+  let account: Account;
+
   beforeAll(async () => {
-    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract(
-      compiledErc20,
-      []
-    );
+    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
     erc20Address = erc20AddressLocal;
     erc20 = new Contract(compiledErc20.abi, erc20Address);
 
     expect(codeErc20).toBe('TRANSACTION_RECEIVED');
 
-    const { code, address: walletAddressLocal } = await defaultProvider.deployContract(
-      compiledArgentAccount,
-      compileCalldata({
+    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+      contract: compiledArgentAccount,
+      constructorCalldata: compileCalldata({
         signer: starkKeyPub,
         guardian: '0',
         L1_address: '0',
       }),
-      starkKeyPub
-    );
+      addressSalt: starkKeyPub,
+    });
     walletAddress = walletAddressLocal;
-    wallet = new Contract(compiledArgentAccount.abi, walletAddress);
     expect(code).toBe('TRANSACTION_RECEIVED');
 
     const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
@@ -78,12 +59,21 @@ describe('deploy and test Wallet', () => {
 
     expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
 
+    account = new Account(defaultProvider, walletAddressLocal, starkKeyPair);
+
     await defaultProvider.waitForTx(txErc20Mint);
   });
+  test('same wallet address', () => {
+    expect(walletAddress).toBe(account.address);
+  });
   test('read nonce', async () => {
-    const { nonce } = await wallet.call('get_nonce');
+    const { result } = await account.callContract({
+      contractAddress: account.address,
+      entrypoint: 'get_nonce',
+    });
+    const nonce = result[0];
 
-    expect(number.toBN(nonce as string).toString()).toStrictEqual(number.toBN(0).toString());
+    expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
   });
   test('read balance of wallet', async () => {
     const { res } = await erc20.call('balance_of', {
@@ -93,31 +83,13 @@ describe('deploy and test Wallet', () => {
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
   test('execute by wallet owner', async () => {
-    const { nonce } = await wallet.call('get_nonce');
-    const msgHash = encode.addHexPrefix(
-      hash.hashMessage(
-        wallet.connectedTo,
-        erc20Address,
-        stark.getSelectorFromName('transfer'),
-        [erc20Address, '10'],
-        nonce.toString()
-      )
-    );
-
-    const signature = ec.sign(starkKeyPair, msgHash);
-    const { code, transaction_hash } = await wallet.invoke(
-      'execute',
-      {
-        to: erc20Address,
-        selector: stark.getSelectorFromName('transfer'),
-        calldata: [erc20Address, '10'],
-        nonce: nonce.toString(),
-      },
-      signature
-    );
+    const { code, transaction_hash } = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'transfer',
+      calldata: [toBN(erc20Address).toString(), '10'],
+    });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-
     await defaultProvider.waitForTx(transaction_hash);
   });
   test('read balance of wallet after transfer', async () => {
@@ -127,35 +99,28 @@ describe('deploy and test Wallet', () => {
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
   });
-});
+  test('execute with custom nonce', async () => {
+    const { result } = await account.callContract({
+      contractAddress: account.address,
+      entrypoint: 'get_nonce',
+    });
+    const nonce = toBN(result[0]).toNumber();
+    const { code, transaction_hash } = await account.execute(
+      {
+        contractAddress: erc20Address,
+        entrypoint: 'transfer',
+        calldata: [toBN(erc20Address).toString(), '10'],
+      },
+      undefined,
+      { nonce }
+    );
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTx(transaction_hash);
+  });
+  test('sign and verify offchain message', async () => {
+    const signature = await account.signMessage(typedDataExample);
 
-test('build tx', async () => {
-  const privateKey = '0x1B69B4BE052FAB1';
-  const keyPair = ec.getKeyPair(privateKey);
-  const address = ec.getStarkKey(keyPair);
-
-  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
-
-  const selector = stark.getSelectorFromName('transfer');
-
-  expect(selector).toBe(
-    number.toHex(
-      number.toBN('232670485425082704932579856502088130646006032362877466777181098476241604910')
-    )
-  );
-
-  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
-  expect(number.toBN(msgHash).toString()).toStrictEqual(
-    number
-      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
-      .toString()
-  );
-
-  const [r, s] = ec.sign(keyPair, msgHash);
-  expect(r.toString()).toBe(
-    '706800951915233622090196542158919402159816118214143837213294331713137614072'
-  );
-  expect(s.toString()).toBe(
-    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
-  );
+    expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
+  });
 });

package/__tests__/accountContract.test.ts

@@ -0,0 +1,160 @@
+import fs from 'fs';
+
+import {
+  CompiledContract,
+  Contract,
+  compileCalldata,
+  defaultProvider,
+  ec,
+  encode,
+  hash,
+  json,
+  number,
+  stark,
+} from '../src';
+
+describe('getStarkAccountFromPrivateKey()', () => {
+  test('it works with valid privateKey', () => {
+    const privateKey = '0xb696427c0d79c5d28a1fa6f748bae1b98b3f4b86bd1a2505bab144673c856fa9';
+
+    const starkKeyPair = ec.getKeyPair(privateKey);
+    const starkKey = ec.getStarkKey(starkKeyPair);
+
+    expect(starkKey).toBe('0x060d46f8d7ef3d83ed05f3ed9beb91e22f9529289b9d863683fd71eafaf28035');
+  });
+  test('it works with valid privateKey', () => {
+    const privateKey = '0x5f65099e269b080000000000000000000000000000000000000000000000000';
+
+    const starkKeyPair = ec.getKeyPair(privateKey);
+    const starkKey = ec.getStarkKey(starkKeyPair);
+
+    expect(starkKey).toBe('0xf321e59b257a577836d8313150aabd21f412491358c329966218df76bab591');
+  });
+});
+
+const compiledArgentAccount: CompiledContract = json.parse(
+  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
+);
+const compiledErc20: CompiledContract = json.parse(
+  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
+);
+
+describe('deploy and test Wallet', () => {
+  const privateKey = stark.randomAddress();
+
+  const starkKeyPair = ec.getKeyPair(privateKey);
+  const starkKeyPub = ec.getStarkKey(starkKeyPair);
+  let wallet: Contract;
+  let walletAddress: string;
+  let erc20: Contract;
+  let erc20Address: string;
+  beforeAll(async () => {
+    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20AddressLocal;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+
+    expect(codeErc20).toBe('TRANSACTION_RECEIVED');
+
+    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+      contract: compiledArgentAccount,
+      constructorCalldata: compileCalldata({
+        signer: starkKeyPub,
+        guardian: '0',
+        L1_address: '0',
+      }),
+      addressSalt: starkKeyPub,
+    });
+    walletAddress = walletAddressLocal;
+    wallet = new Contract(compiledArgentAccount.abi, walletAddress);
+    expect(code).toBe('TRANSACTION_RECEIVED');
+
+    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
+      recipient: walletAddress,
+      amount: '1000',
+    });
+
+    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+
+    await defaultProvider.waitForTx(txErc20Mint);
+  });
+  test('read nonce', async () => {
+    const { nonce } = await wallet.call('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: walletAddress,
+    });
+
+    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+  });
+  test('execute by wallet owner', async () => {
+    const { nonce } = await wallet.call('get_nonce');
+    const msgHash = encode.addHexPrefix(
+      hash.hashMessage(
+        wallet.connectedTo,
+        erc20Address,
+        stark.getSelectorFromName('transfer'),
+        [erc20Address, '10'],
+        nonce.toString()
+      )
+    );
+
+    const signature = ec.sign(starkKeyPair, msgHash);
+    const { code, transaction_hash } = await wallet.invoke(
+      'execute',
+      {
+        to: erc20Address,
+        selector: stark.getSelectorFromName('transfer'),
+        calldata: [erc20Address, '10'],
+        nonce: nonce.toString(),
+      },
+      signature
+    );
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+
+    await defaultProvider.waitForTx(transaction_hash);
+  });
+  test('read balance of wallet after transfer', async () => {
+    const { res } = await erc20.call('balance_of', {
+      user: walletAddress,
+    });
+
+    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
+  });
+});
+
+test('build tx', async () => {
+  const privateKey = '0x1B69B4BE052FAB1';
+  const keyPair = ec.getKeyPair(privateKey);
+  const address = ec.getStarkKey(keyPair);
+
+  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
+
+  const selector = stark.getSelectorFromName('transfer');
+
+  expect(selector).toBe(
+    number.toHex(
+      number.toBN('232670485425082704932579856502088130646006032362877466777181098476241604910')
+    )
+  );
+
+  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
+  expect(number.toBN(msgHash).toString()).toStrictEqual(
+    number
+      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
+      .toString()
+  );
+
+  const [r, s] = ec.sign(keyPair, msgHash);
+  expect(r.toString()).toBe(
+    '706800951915233622090196542158919402159816118214143837213294331713137614072'
+  );
+  expect(s.toString()).toBe(
+    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
+  );
+});

package/__tests__/contract.test.ts

@@ -14,7 +14,9 @@ describe('class Contract {}', () => {
       code,
       transaction_hash,
       address: erc20address,
-    } = await defaultProvider.deployContract(compiledERC20, []);
+    } = await defaultProvider.deployContract({
+      contract: compiledERC20,
+    });
 
     contract = new Contract(compiledERC20.abi, erc20address);
 

package/__tests__/jest.setup.ts

@@ -0,0 +1,9 @@
+import axios from 'axios';
+import * as AxiosLogger from 'axios-logger';
+
+jest.setTimeout(50 * 60 * 1000);
+
+if (process.env.DEBUG === 'true') {
+  axios.interceptors.request.use(AxiosLogger.requestLogger, AxiosLogger.errorLogger);
+  axios.interceptors.response.use(AxiosLogger.responseLogger, AxiosLogger.errorLogger);
+}

package/__tests__/provider.test.ts

@@ -21,7 +21,7 @@ describe('defaultProvider', () => {
       ).resolves.not.toThrow();
     });
     test('getBlock(blockHash=undefined, blockNumber=36657)', () => {
-      return expect(defaultProvider.getBlock(undefined, 36657)).resolves.not.toThrow();
+      return expect(defaultProvider.getBlock(36657)).resolves.not.toThrow();
     });
     test('getBlock(blockHash=undefined, blockNumber=null)', () => {
       return expect(defaultProvider.getBlock()).resolves.not.toThrow();
@@ -34,7 +34,6 @@ describe('defaultProvider', () => {
       return expect(
         defaultProvider.getCode(
           '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          undefined,
           36663
         )
       ).resolves.not.toThrow();
@@ -51,7 +50,6 @@ describe('defaultProvider', () => {
         defaultProvider.getStorageAt(
           '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
           0,
-          undefined,
           36663
         )
       ).resolves.not.toThrow();
@@ -78,11 +76,20 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
+
+    test('getTransactionReceipt', async () => {
+      return expect(
+        defaultProvider.getTransactionReceipt({
+          txHash: '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348',
+        })
+      ).resolves.not.toThrow();
+    });
+
     test('callContract()', () => {
       return expect(
         defaultProvider.callContract({
-          contract_address: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
-          entry_point_selector: stark.getSelectorFromName('balance_of'),
+          contractAddress: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+          entrypoint: 'balance_of',
           calldata: compileCalldata({
             user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
           }),
@@ -92,45 +99,21 @@ describe('defaultProvider', () => {
   });
 
   describe('addTransaction()', () => {
-    test('type: "DEPLOY"', async () => {
+    test('deployContract()', async () => {
       const inputContract = compiledArgentAccount as unknown as CompiledContract;
 
-      const contractDefinition = {
-        ...inputContract,
-        program: stark.compressProgram(inputContract.program),
-      };
-
-      const response = await defaultProvider.addTransaction({
-        type: 'DEPLOY',
-        contract_address_salt: stark.randomAddress(),
-        constructor_calldata: compileCalldata({
+      const response = await defaultProvider.deployContract({
+        contract: inputContract,
+        constructorCalldata: compileCalldata({
           signer: stark.randomAddress(),
           guardian: '0',
           L1_address: '0',
         }),
-        contract_definition: contractDefinition,
       });
 
       expect(response.code).toBe('TRANSACTION_RECEIVED');
       expect(response.transaction_hash).toBeDefined();
       expect(response.address).toBeDefined();
     });
-
-    test('deployContract()', async () => {
-      const inputContract = compiledArgentAccount as unknown as CompiledContract;
-
-      const response = await defaultProvider.deployContract(
-        inputContract,
-        compileCalldata({
-          signer: stark.randomAddress(),
-          guardian: '0',
-          L1_address: '0',
-        })
-      );
-
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.address).toBeDefined();
-    });
   });
 });