starknet 3.1.0 → 3.4.0

package/__tests__/account.test.ts

@@ -1,72 +1,59 @@
-import fs from 'fs';
-
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import {
-  Account,
-  CompiledContract,
-  Contract,
-  defaultProvider,
-  ec,
-  json,
-  number,
-  stark,
-} from '../src';
+import { Account, Contract, defaultProvider, ec, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-
-const { compileCalldata } = stark;
-
-const compiledArgentAccount: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
-);
-const compiledErc20: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
-);
+import { compiledArgentAccount, compiledErc20, compiledTestDapp } from './fixtures';
 
 describe('deploy and test Wallet', () => {
   const privateKey = stark.randomAddress();
 
   const starkKeyPair = ec.getKeyPair(privateKey);
   const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let walletAddress: string;
+  let account: Account;
   let erc20: Contract;
   let erc20Address: string;
-  let account: Account;
+  let dapp: Contract;
 
   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({
+    const accountResponse = await defaultProvider.deployContract({
       contract: compiledArgentAccount,
-      constructorCalldata: compileCalldata({
-        signer: starkKeyPub,
-        guardian: '0',
-        L1_address: '0',
-      }),
       addressSalt: starkKeyPub,
     });
-    walletAddress = walletAddressLocal;
-    expect(code).toBe('TRANSACTION_RECEIVED');
+    const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
+    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
-      recipient: walletAddress,
-      amount: '1000',
+    const initializeResponse = await contract.invoke('initialize', {
+      signer: starkKeyPub,
+      guardian: '0',
     });
+    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+    account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
 
-    account = new Account(defaultProvider, walletAddressLocal, starkKeyPair);
+    const erc20Response = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20Response.address;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+    expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
+
+    const mintResponse = await erc20.invoke('mint', {
+      recipient: account.address,
+      amount: '1000',
+    });
+    expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(txErc20Mint);
+    const dappResponse = await defaultProvider.deployContract({
+      contract: compiledTestDapp,
+    });
+    dapp = new Contract(compiledTestDapp.abi, dappResponse.address);
+    expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(dappResponse.transaction_hash);
   });
+
   test('same wallet address', () => {
-    expect(walletAddress).toBe(account.address);
+    expect(account.address).toBe(account.address);
   });
+
   test('read nonce', async () => {
     const { result } = await account.callContract({
       contractAddress: account.address,
@@ -76,13 +63,15 @@ describe('deploy and test Wallet', () => {
 
     expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
   });
+
   test('read balance of wallet', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: 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,
@@ -91,15 +80,17 @@ describe('deploy and test Wallet', () => {
     });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
   test('read balance of wallet after transfer', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: account.address,
     });
 
     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,
@@ -117,8 +108,30 @@ describe('deploy and test Wallet', () => {
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
+  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'],
+      },
+    ]);
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(transaction_hash);
+
+    const response = await dapp.call('get_number', { user: account.address });
+    expect(toBN(response.number as string).toString()).toStrictEqual('57');
+  });
+
   test('sign and verify offchain message', async () => {
     const signature = await account.signMessage(typedDataExample);
 

package/__tests__/accountContract.test.ts

@@ -1,18 +1,6 @@
-import fs from 'fs';
-
-import {
-  CompiledContract,
-  Contract,
-  defaultProvider,
-  ec,
-  encode,
-  hash,
-  json,
-  number,
-  stark,
-} from '../src';
-
-const { compileCalldata } = stark;
+import { Contract, defaultProvider, ec, hash, number, stark } from '../src';
+import { transformCallsToMulticallArrays } from '../src/utils/transaction';
+import { compiledArgentAccount, compiledErc20 } from './fixtures';
 
 describe('getStarkAccountFromPrivateKey()', () => {
   test('it works with valid privateKey', () => {
@@ -33,96 +21,87 @@ describe('getStarkAccountFromPrivateKey()', () => {
   });
 });
 
-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 accountContract: Contract;
   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({
+  beforeAll(async () => {
+    const accountResponse = 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');
+    accountContract = new Contract(compiledArgentAccount.abi, accountResponse.address);
+    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
-      recipient: walletAddress,
-      amount: '1000',
+    const initializeResponse = await accountContract.invoke('initialize', {
+      signer: starkKeyPub,
+      guardian: '0',
     });
+    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+    const erc20Response = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20Response.address;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+    expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(txErc20Mint);
+    const mintResponse = await erc20.invoke('mint', {
+      recipient: accountContract.connectedTo,
+      amount: '1000',
+    });
+    expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
   });
+
   test('read nonce', async () => {
-    const { nonce } = await wallet.call('get_nonce');
+    const { nonce } = await accountContract.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,
+      user: accountContract.connectedTo,
     });
 
     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 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 wallet.invoke(
-      'execute',
+    const { code, transaction_hash } = await accountContract.invoke(
+      '__execute__',
       {
-        to: erc20Address,
-        selector: stark.getSelectorFromName('transfer'),
-        calldata: [erc20Address, '10'],
-        nonce: nonce.toString(),
+        call_array: callArray,
+        calldata,
+        nonce,
       },
       signature
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
   test('read balance of wallet after transfer', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: accountContract.connectedTo,
     });
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
@@ -136,7 +115,7 @@ test('build tx', async () => {
 
   expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
 
-  const selector = stark.getSelectorFromName('transfer');
+  const selector = hash.getSelectorFromName('transfer');
 
   expect(selector).toBe(
     number.toHex(
@@ -144,18 +123,19 @@ test('build tx', async () => {
     )
   );
 
-  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
+  const calls = [{ contractAddress: '1', entrypoint: 'transfer', calldata: ['6', '7'] }];
+  const msgHash = hash.hashMulticall(address, calls, '0', '0');
   expect(number.toBN(msgHash).toString()).toStrictEqual(
     number
-      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
+      .toBN('533725737276146993132325070982049323585915612981489962412873515411469143806')
       .toString()
   );
 
   const [r, s] = ec.sign(keyPair, msgHash);
   expect(r.toString()).toBe(
-    '706800951915233622090196542158919402159816118214143837213294331713137614072'
+    '3081830197073374427897814075820860503521735760640862828374253887454357679197'
   );
   expect(s.toString()).toBe(
-    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
+    '384293936273611705317490990661155378189310283917528660618713929845936492551'
   );
 });

package/__tests__/contract.test.ts

@@ -1,33 +1,25 @@
-import fs from 'fs';
-
 import { isBN } from 'bn.js';
 
-import { CompiledContract, Contract, defaultProvider, json, stark } from '../src';
+import { Contract, defaultProvider, stark } from '../src';
+import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
-import { compileCalldata, getSelectorFromName } from '../src/utils/stark';
-
-const compiledERC20: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
-);
-const compiledTypeTransformation: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/contract.json').toString('ascii')
-);
-const compiledMulticall: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/multicall.json').toString('ascii')
-);
+import { compileCalldata } from '../src/utils/stark';
+import { compiledErc20, compiledMulticall, compiledTypeTransformation } from './fixtures';
 
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
+
   describe('Basic Interaction', () => {
     let erc20: Contract;
     let contract: Contract;
+
     beforeAll(async () => {
       const { code, transaction_hash, address } = await defaultProvider.deployContract({
-        contract: compiledERC20,
+        contract: compiledErc20,
       });
-      erc20 = new Contract(compiledERC20.abi, address, defaultProvider);
+      erc20 = new Contract(compiledErc20.abi, address, defaultProvider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTx(transaction_hash);
+      await defaultProvider.waitForTransaction(transaction_hash);
 
       // Deploy Multicall
 
@@ -43,14 +35,16 @@ describe('class Contract {}', () => {
 
       expect(m_code).toBe('TRANSACTION_RECEIVED');
 
-      await defaultProvider.waitForTx(m_transaction_hash);
+      await defaultProvider.waitForTransaction(m_transaction_hash);
     });
+
     test('read initial balance of that account', async () => {
       const { res } = await erc20.call('balance_of', {
         user: wallet,
       });
       expect(res).toStrictEqual(toBN(0));
     });
+
     test('add 10 test ERC20 to account', async () => {
       const response = await erc20.invoke('mint', {
         recipient: wallet,
@@ -58,8 +52,9 @@ describe('class Contract {}', () => {
       });
       expect(response.code).toBe('TRANSACTION_RECEIVED');
 
-      await defaultProvider.waitForTx(response.transaction_hash);
+      await defaultProvider.waitForTransaction(response.transaction_hash);
     });
+
     test('read balance after mint of that account', async () => {
       const { res } = await erc20.call('balance_of', {
         user: wallet,
@@ -67,6 +62,7 @@ describe('class Contract {}', () => {
 
       expect(res).toStrictEqual(toBN(10));
     });
+
     test('read balance in a multicall', async () => {
       const args1 = { user: wallet };
       const args2 = {};
@@ -87,25 +83,30 @@ describe('class Contract {}', () => {
       (result as BigNumberish[]).forEach((el) => expect(isBN(el)));
     });
   });
+
   describe('Type Transformation', () => {
     let contract: Contract;
+
     beforeAll(async () => {
       const { code, transaction_hash, address } = await defaultProvider.deployContract({
         contract: compiledTypeTransformation,
       });
       contract = new Contract(compiledTypeTransformation.abi, address, defaultProvider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTx(transaction_hash);
+      await defaultProvider.waitForTransaction(transaction_hash);
     });
+
     describe('Request Type Transformation', () => {
       test('Parsing the felt in request', async () => {
         return expect(contract.call('request_felt', { num: 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();
       });
+
       test('Parsing the struct in request', async () => {
         return expect(
           contract.call('request_struct', {
@@ -113,11 +114,13 @@ describe('class Contract {}', () => {
           })
         ).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();
       });
+
       test('Parsing the nested structs in request', async () => {
         return expect(
           contract.call('request_nested_structs', {
@@ -129,9 +132,11 @@ describe('class Contract {}', () => {
           })
         ).resolves.not.toThrow();
       });
+
       test('Parsing the tuple in request', async () => {
         return expect(contract.call('request_tuple', { tup: [1, 2] })).resolves.not.toThrow();
       });
+
       test('Parsing the multiple types in request', async () => {
         return expect(
           contract.call('request_mixed_types', {
@@ -145,23 +150,28 @@ describe('class Contract {}', () => {
         ).resolves.not.toThrow();
       });
     });
+
     describe('Response Type Transformation', () => {
       test('Parsing the felt in response', async () => {
         const { res } = await contract.call('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');
         expect(res).toStrictEqual([toBN(4), toBN(5)]);
       });
+
       test('Parsing the array of structs in response', async () => {
         const { res } = await contract.call('get_struct');
         expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
       });
+
       test('Parsing the array of structs in response', async () => {
         const { res } = await contract.call('get_array_of_structs');
         expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
       });
+
       test('Parsing the nested structs in response', async () => {
         const { res } = await contract.call('get_nested_structs');
         expect(res).toStrictEqual({
@@ -170,10 +180,12 @@ describe('class Contract {}', () => {
           extra: toBN(5),
         });
       });
+
       test('Parsing the tuple in response', async () => {
         const { res } = await contract.call('get_tuple');
         expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
       });
+
       test('Parsing the multiple types in response', async () => {
         const { tuple, number, array, point } = await contract.call('get_mixed_types');
         expect(tuple).toStrictEqual([toBN(1), toBN(2)]);

package/__tests__/fixtures.ts

@@ -0,0 +1,13 @@
+import fs from 'fs';
+
+import { json } from '../src';
+import { CompiledContract } from '../src/types';
+
+const readContract = (name: string): CompiledContract =>
+  json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
+
+export const compiledArgentAccount = readContract('ArgentAccount');
+export const compiledErc20 = readContract('ERC20');
+export const compiledTypeTransformation = readContract('contract');
+export const compiledMulticall = readContract('multicall');
+export const compiledTestDapp = readContract('TestDapp');

package/__tests__/provider.test.ts

@@ -1,13 +1,8 @@
-import fs from 'fs';
-
-import { CompiledContract, defaultProvider, json, stark } from '../src';
+import { defaultProvider, stark } from '../src';
+import { compiledArgentAccount } from './fixtures';
 
 const { compileCalldata } = stark;
 
-const compiledArgentAccount = json.parse(
-  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
-);
-
 describe('defaultProvider', () => {
   describe('feeder gateway endpoints', () => {
     test('getContractAddresses()', async () => {
@@ -102,15 +97,8 @@ describe('defaultProvider', () => {
 
   describe('addTransaction()', () => {
     test('deployContract()', async () => {
-      const inputContract = compiledArgentAccount as unknown as CompiledContract;
-
       const response = await defaultProvider.deployContract({
-        contract: inputContract,
-        constructorCalldata: compileCalldata({
-          signer: stark.randomAddress(),
-          guardian: '0',
-          L1_address: '0',
-        }),
+        contract: compiledArgentAccount,
       });
 
       expect(response.code).toBe('TRANSACTION_RECEIVED');